← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

  • Committer: Jelmer Vernooij
  • Date: 2009-02-10 04:10:44 UTC
  • mto: This revision was merged to the branch mainline in revision 3995.
  • Revision ID: jelmer@samba.org-20090210041044-42lmb09hskt9lt9l
Review from Ian.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/win32utils.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Win32-specific helper functions
18
18
 
19
19
Only one dependency: ctypes should be installed.
20
20
"""
21
21
 
22
 
import glob
23
22
import os
24
23
import struct
25
24
import sys
26
25
 
27
 
from bzrlib import cmdline
28
26
 
29
27
# Windows version
30
28
if sys.platform == 'win32':
68
66
        suffix = 'W'
69
67
try:
70
68
    import win32file
71
 
    import pywintypes
72
69
    has_win32file = True
73
70
except ImportError:
74
71
    has_win32file = False
99
96
UNLEN = 256
100
97
MAX_COMPUTERNAME_LENGTH = 31
101
98
 
102
 
# Registry data type ids
103
 
REG_SZ = 1
104
 
REG_EXPAND_SZ = 2
105
 
 
106
 
 
107
 
def debug_memory_win32api(message='', short=True):
108
 
    """Use trace.note() to dump the running memory info."""
109
 
    from bzrlib import trace
110
 
    if has_ctypes:
111
 
        class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
112
 
            """Used by GetProcessMemoryInfo"""
113
 
            _fields_ = [('cb', ctypes.c_ulong),
114
 
                        ('PageFaultCount', ctypes.c_ulong),
115
 
                        ('PeakWorkingSetSize', ctypes.c_size_t),
116
 
                        ('WorkingSetSize', ctypes.c_size_t),
117
 
                        ('QuotaPeakPagedPoolUsage', ctypes.c_size_t),
118
 
                        ('QuotaPagedPoolUsage', ctypes.c_size_t),
119
 
                        ('QuotaPeakNonPagedPoolUsage', ctypes.c_size_t),
120
 
                        ('QuotaNonPagedPoolUsage', ctypes.c_size_t),
121
 
                        ('PagefileUsage', ctypes.c_size_t),
122
 
                        ('PeakPagefileUsage', ctypes.c_size_t),
123
 
                        ('PrivateUsage', ctypes.c_size_t),
124
 
                       ]
125
 
        cur_process = ctypes.windll.kernel32.GetCurrentProcess()
126
 
        mem_struct = PROCESS_MEMORY_COUNTERS_EX()
127
 
        ret = ctypes.windll.psapi.GetProcessMemoryInfo(cur_process,
128
 
            ctypes.byref(mem_struct),
129
 
            ctypes.sizeof(mem_struct))
130
 
        if not ret:
131
 
            trace.note('Failed to GetProcessMemoryInfo()')
132
 
            return
133
 
        info = {'PageFaultCount': mem_struct.PageFaultCount,
134
 
                'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
135
 
                'WorkingSetSize': mem_struct.WorkingSetSize,
136
 
                'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
137
 
                'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
138
 
                'QuotaPeakNonPagedPoolUsage':
139
 
                    mem_struct.QuotaPeakNonPagedPoolUsage,
140
 
                'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
141
 
                'PagefileUsage': mem_struct.PagefileUsage,
142
 
                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
143
 
                'PrivateUsage': mem_struct.PrivateUsage,
144
 
               }
145
 
    elif has_win32api:
146
 
        import win32process
147
 
        # win32process does not return PrivateUsage, because it doesn't use
148
 
        # PROCESS_MEMORY_COUNTERS_EX (it uses the one without _EX).
149
 
        proc = win32process.GetCurrentProcess()
150
 
        info = win32process.GetProcessMemoryInfo(proc)
151
 
    else:
152
 
        trace.note('Cannot debug memory on win32 without ctypes'
153
 
                   ' or win32process')
154
 
        return
155
 
    if short:
156
 
        # using base-2 units (see HACKING.txt).
157
 
        trace.note('WorkingSize %7dKiB'
158
 
                   '\tPeakWorking %7dKiB\t%s',
159
 
                   info['WorkingSetSize'] / 1024,
160
 
                   info['PeakWorkingSetSize'] / 1024,
161
 
                   message)
162
 
        return
163
 
    if message:
164
 
        trace.note('%s', message)
165
 
    trace.note('WorkingSize       %8d KiB', info['WorkingSetSize'] / 1024)
166
 
    trace.note('PeakWorking       %8d KiB', info['PeakWorkingSetSize'] / 1024)
167
 
    trace.note('PagefileUsage     %8d KiB', info.get('PagefileUsage', 0) / 1024)
168
 
    trace.note('PeakPagefileUsage %8d KiB',
169
 
               info.get('PeakPagefileUsage', 0) / 1024)
170
 
    trace.note('PrivateUsage      %8d KiB', info.get('PrivateUsage', 0) / 1024)
171
 
    trace.note('PageFaultCount    %8d', info.get('PageFaultCount', 0))
172
 
 
173
99
 
174
100
def get_console_size(defaultx=80, defaulty=25):
175
101
    """Return size of current console.
183
109
        return (defaultx, defaulty)
184
110
 
185
111
    # To avoid problem with redirecting output via pipe
186
 
    # we need to use stderr instead of stdout
 
112
    # need to use stderr instead of stdout
187
113
    h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
188
114
    csbi = ctypes.create_string_buffer(22)
189
115
    res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
190
116
 
191
117
    if res:
192
118
        (bufx, bufy, curx, cury, wattr,
193
 
        left, top, right, bottom, maxx, maxy) = struct.unpack(
194
 
            "hhhhHhhhhhh", csbi.raw)
 
119
        left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
195
120
        sizex = right - left + 1
196
121
        sizey = bottom - top + 1
197
122
        return (sizex, sizey)
201
126
 
202
127
def _get_sh_special_folder_path(csidl):
203
128
    """Call SHGetSpecialFolderPathW if available, or return None.
204
 
 
 
129
    
205
130
    Result is always unicode (or None).
206
131
    """
207
132
    if has_ctypes:
278
203
 
279
204
    Returned value can be unicode or plain string.
280
205
    To convert plain string to unicode use
281
 
    s.decode(osutils.get_user_encoding())
 
206
    s.decode(bzrlib.user_encoding)
282
207
    (XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
283
208
    """
284
209
    local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
297
222
    If location cannot be obtained return system drive root,
298
223
    i.e. C:\
299
224
 
300
 
    Returned value can be unicode or plain string.
 
225
    Returned value can be unicode or plain sring.
301
226
    To convert plain string to unicode use
302
227
    s.decode(osutils.get_user_encoding())
303
228
    """
320
245
    """Return user name as login name.
321
246
    If name cannot be obtained return None.
322
247
 
323
 
    Returned value can be unicode or plain string.
 
248
    Returned value can be unicode or plain sring.
324
249
    To convert plain string to unicode use
325
250
    s.decode(osutils.get_user_encoding())
326
251
    """
394
319
 
395
320
 
396
321
def _ensure_unicode(s):
 
322
    from bzrlib import osutils
397
323
    if s and type(s) != unicode:
398
324
        from bzrlib import osutils
399
325
        s = s.decode(osutils.get_user_encoding())
414
340
 
415
341
 
416
342
def _ensure_with_dir(path):
417
 
    if (not os.path.split(path)[0] or path.startswith(u'*')
418
 
        or path.startswith(u'?')):
 
343
    if not os.path.split(path)[0] or path.startswith(u'*') or path.startswith(u'?'):
419
344
        return u'./' + path, True
420
345
    else:
421
346
        return path, False
422
 
 
 
347
    
423
348
def _undo_ensure_with_dir(path, corrected):
424
349
    if corrected:
425
350
        return path[2:]
428
353
 
429
354
 
430
355
 
431
 
def glob_one(possible_glob):
432
 
    """Same as glob.glob().
433
 
 
434
 
    work around bugs in glob.glob()
435
 
    - Python bug #1001604 ("glob doesn't return unicode with ...")
436
 
    - failing expansion for */* with non-iso-8859-* chars
437
 
    """
438
 
    corrected_glob, corrected = _ensure_with_dir(possible_glob)
439
 
    glob_files = glob.glob(corrected_glob)
440
 
 
441
 
    if not glob_files:
442
 
        # special case to let the normal code path handle
443
 
        # files that do not exist, etc.
444
 
        glob_files = [possible_glob]
445
 
    elif corrected:
446
 
        glob_files = [_undo_ensure_with_dir(elem, corrected)
447
 
                      for elem in glob_files]
448
 
    return [elem.replace(u'\\', u'/') for elem in glob_files]
449
 
 
450
 
 
451
356
def glob_expand(file_list):
452
357
    """Replacement for glob expansion by the shell.
453
358
 
461
366
    """
462
367
    if not file_list:
463
368
        return []
 
369
    import glob
464
370
    expanded_file_list = []
465
371
    for possible_glob in file_list:
466
 
        expanded_file_list.extend(glob_one(possible_glob))
467
 
    return expanded_file_list
 
372
        
 
373
        # work around bugs in glob.glob()
 
374
        # - Python bug #1001604 ("glob doesn't return unicode with ...")
 
375
        # - failing expansion for */* with non-iso-8859-* chars
 
376
        possible_glob, corrected = _ensure_with_dir(possible_glob)
 
377
        glob_files = glob.glob(possible_glob)
 
378
 
 
379
        if glob_files == []:
 
380
            # special case to let the normal code path handle
 
381
            # files that do not exists
 
382
            expanded_file_list.append(
 
383
                _undo_ensure_with_dir(possible_glob, corrected))
 
384
        else:
 
385
            glob_files = [_undo_ensure_with_dir(elem, corrected) for elem in glob_files]
 
386
            expanded_file_list += glob_files
 
387
            
 
388
    return [elem.replace(u'\\', u'/') for elem in expanded_file_list] 
468
389
 
469
390
 
470
391
def get_app_path(appname):
471
392
    """Look up in Windows registry for full path to application executable.
472
 
    Typically, applications create subkey with their basename
 
393
    Typicaly, applications create subkey with their basename
473
394
    in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
474
395
 
475
396
    :param  appname:    name of application (if no filename extension
478
399
                or appname itself if nothing found.
479
400
    """
480
401
    import _winreg
 
402
    try:
 
403
        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
 
404
                               r'SOFTWARE\Microsoft\Windows'
 
405
                               r'\CurrentVersion\App Paths')
 
406
    except EnvironmentError:
 
407
        return appname
481
408
 
482
409
    basename = appname
483
410
    if not os.path.splitext(basename)[1]:
484
411
        basename = appname + '.exe'
485
 
 
486
 
    try:
487
 
        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
488
 
            'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
489
 
            basename)
490
 
    except EnvironmentError:
491
 
        return appname
492
 
 
493
412
    try:
494
413
        try:
495
 
            path, type_id = _winreg.QueryValueEx(hkey, '')
 
414
            fullpath = _winreg.QueryValue(hkey, basename)
496
415
        except WindowsError:
497
 
            return appname
 
416
            fullpath = appname
498
417
    finally:
499
418
        _winreg.CloseKey(hkey)
500
419
 
501
 
    if type_id == REG_SZ:
502
 
        return path
503
 
    if type_id == REG_EXPAND_SZ and has_win32api:
504
 
        fullpath = win32api.ExpandEnvironmentStrings(path)
505
 
        if len(fullpath) > 1 and fullpath[0] == '"' and fullpath[-1] == '"':
506
 
            fullpath = fullpath[1:-1]   # remove quotes around value
507
 
        return fullpath
508
 
    return appname
 
420
    return fullpath
509
421
 
510
422
 
511
423
def set_file_attr_hidden(path):
512
424
    """Set file attributes to hidden if possible"""
513
425
    if has_win32file:
514
 
        if winver != 'Windows 98':
515
 
            SetFileAttributes = win32file.SetFileAttributesW
516
 
        else:
517
 
            SetFileAttributes = win32file.SetFileAttributes
518
 
        try:
519
 
            SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
520
 
        except pywintypes.error, e:
521
 
            from bzrlib import trace
522
 
            trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
523
 
 
524
 
 
525
 
def _command_line_to_argv(command_line, argv, single_quotes_allowed=False):
526
 
    """Convert a Unicode command line into a list of argv arguments.
527
 
 
528
 
    It performs wildcard expansion to make wildcards act closer to how they
529
 
    work in posix shells, versus how they work by default on Windows. Quoted
530
 
    arguments are left untouched.
531
 
 
532
 
    :param command_line: The unicode string to split into an arg list.
533
 
    :param single_quotes_allowed: Whether single quotes are accepted as quoting
534
 
                                  characters like double quotes. False by
535
 
                                  default.
536
 
    :return: A list of unicode strings.
537
 
    """
538
 
    # First, spit the command line
539
 
    s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
540
 
    
541
 
    # Bug #587868 Now make sure that the length of s agrees with sys.argv 
542
 
    # we do this by simply counting the number of arguments in each. The counts should 
543
 
    # agree no matter what encoding sys.argv is in (AFAIK) 
544
 
    # len(arguments) < len(sys.argv) should be an impossibility since python gets 
545
 
    # args from the very same PEB as does GetCommandLineW
546
 
    arguments = list(s)
547
 
    
548
 
    # Now shorten the command line we get from GetCommandLineW to match sys.argv
549
 
    if len(arguments) < len(argv):
550
 
        raise AssertionError("Split command line can't be shorter than argv")
551
 
    arguments = arguments[len(arguments) - len(argv):]
552
 
    
553
 
    # Carry on to process globs (metachars) in the command line
554
 
    # expand globs if necessary
555
 
    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
556
 
    #       '**/' style globs
557
 
    args = []
558
 
    for is_quoted, arg in arguments:
559
 
        if is_quoted or not glob.has_magic(arg):
560
 
            args.append(arg)
561
 
        else:
562
 
            args.extend(glob_one(arg))
563
 
    return args
564
 
 
565
 
 
566
 
if has_ctypes and winver != 'Windows 98':
567
 
    def get_unicode_argv():
568
 
        prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
569
 
        GetCommandLineW = prototype(("GetCommandLineW",
570
 
                                     ctypes.windll.kernel32))
571
 
        command_line = GetCommandLineW()
572
 
        if command_line is None:
573
 
            raise ctypes.WinError()
574
 
        # Skip the first argument, since we only care about parameters
575
 
        argv = _command_line_to_argv(command_line, sys.argv)[1:]
576
 
        return argv
577
 
else:
578
 
    get_unicode_argv = None
 
426
        win32file.SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)