← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

(jameinel) Allow 'bzr serve' to interpret SIGHUP as a graceful shutdown.
 (bug #795025) (John A Meinel)

Show diffs side-by-side

added added

removed removed

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