← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

  • Committer: Andrew Bennetts
  • Date: 2009-07-01 10:46:27 UTC
  • mto: This revision was merged to the branch mainline in revision 4504.
  • Revision ID: andrew.bennetts@canonical.com-20090701104627-fgiuxcyfiotm386r
Remove more unused imports.

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
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
135
132
                'WorkingSetSize': mem_struct.WorkingSetSize,
136
133
                'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
137
134
                'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
138
 
                'QuotaPeakNonPagedPoolUsage':
139
 
                    mem_struct.QuotaPeakNonPagedPoolUsage,
 
135
                'QuotaPeakNonPagedPoolUsage': mem_struct.QuotaPeakNonPagedPoolUsage,
140
136
                'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
141
137
                'PagefileUsage': mem_struct.PagefileUsage,
142
138
                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
153
149
                   ' or win32process')
154
150
        return
155
151
    if short:
156
 
        # using base-2 units (see HACKING.txt).
157
 
        trace.note('WorkingSize %7dKiB'
158
 
                   '\tPeakWorking %7dKiB\t%s',
 
152
        trace.note('WorkingSize %7dKB'
 
153
                   '\tPeakWorking %7dKB\t%s',
159
154
                   info['WorkingSetSize'] / 1024,
160
155
                   info['PeakWorkingSetSize'] / 1024,
161
156
                   message)
162
157
        return
163
158
    if message:
164
159
        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)
 
160
    trace.note('WorkingSize       %8d KB', info['WorkingSetSize'] / 1024)
 
161
    trace.note('PeakWorking       %8d KB', info['PeakWorkingSetSize'] / 1024)
 
162
    trace.note('PagefileUsage     %8d KB', info.get('PagefileUsage', 0) / 1024)
 
163
    trace.note('PeakPagefileUsage %8d KB', info.get('PeakPagefileUsage', 0) / 1024)
 
164
    trace.note('PrivateUsage      %8d KB', info.get('PrivateUsage', 0) / 1024)
171
165
    trace.note('PageFaultCount    %8d', info.get('PageFaultCount', 0))
172
166
 
173
167
 
183
177
        return (defaultx, defaulty)
184
178
 
185
179
    # To avoid problem with redirecting output via pipe
186
 
    # we need to use stderr instead of stdout
 
180
    # need to use stderr instead of stdout
187
181
    h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
188
182
    csbi = ctypes.create_string_buffer(22)
189
183
    res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
190
184
 
191
185
    if res:
192
186
        (bufx, bufy, curx, cury, wattr,
193
 
        left, top, right, bottom, maxx, maxy) = struct.unpack(
194
 
            "hhhhHhhhhhh", csbi.raw)
 
187
        left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
195
188
        sizex = right - left + 1
196
189
        sizey = bottom - top + 1
197
190
        return (sizex, sizey)
394
387
 
395
388
 
396
389
def _ensure_unicode(s):
 
390
    from bzrlib import osutils
397
391
    if s and type(s) != unicode:
398
392
        from bzrlib import osutils
399
393
        s = s.decode(osutils.get_user_encoding())
414
408
 
415
409
 
416
410
def _ensure_with_dir(path):
417
 
    if (not os.path.split(path)[0] or path.startswith(u'*')
418
 
        or path.startswith(u'?')):
 
411
    if not os.path.split(path)[0] or path.startswith(u'*') or path.startswith(u'?'):
419
412
        return u'./' + path, True
420
413
    else:
421
414
        return path, False
428
421
 
429
422
 
430
423
 
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
424
def glob_expand(file_list):
452
425
    """Replacement for glob expansion by the shell.
453
426
 
461
434
    """
462
435
    if not file_list:
463
436
        return []
 
437
    import glob
464
438
    expanded_file_list = []
465
439
    for possible_glob in file_list:
466
 
        expanded_file_list.extend(glob_one(possible_glob))
467
 
    return expanded_file_list
 
440
        # work around bugs in glob.glob()
 
441
        # - Python bug #1001604 ("glob doesn't return unicode with ...")
 
442
        # - failing expansion for */* with non-iso-8859-* chars
 
443
        possible_glob, corrected = _ensure_with_dir(possible_glob)
 
444
        glob_files = glob.glob(possible_glob)
 
445
 
 
446
        if glob_files == []:
 
447
            # special case to let the normal code path handle
 
448
            # files that do not exists
 
449
            expanded_file_list.append(
 
450
                _undo_ensure_with_dir(possible_glob, corrected))
 
451
        else:
 
452
            glob_files = [_undo_ensure_with_dir(elem, corrected) for elem in glob_files]
 
453
            expanded_file_list += glob_files
 
454
 
 
455
    return [elem.replace(u'\\', u'/') for elem in expanded_file_list]
468
456
 
469
457
 
470
458
def get_app_path(appname):
471
 
    r"""Look up in Windows registry for full path to application executable.
 
459
    """Look up in Windows registry for full path to application executable.
472
460
    Typically, applications create subkey with their basename
473
461
    in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
474
462
 
511
499
def set_file_attr_hidden(path):
512
500
    """Set file attributes to hidden if possible"""
513
501
    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
 
502
        win32file.SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
564
503
 
565
504
 
566
505
if has_ctypes and winver != 'Windows 98':
567
506
    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()
 
507
        LPCWSTR = ctypes.c_wchar_p
 
508
        INT = ctypes.c_int
 
509
        POINTER = ctypes.POINTER
 
510
        prototype = ctypes.WINFUNCTYPE(LPCWSTR)
 
511
        GetCommandLine = prototype(("GetCommandLineW",
 
512
                                    ctypes.windll.kernel32))
 
513
        prototype = ctypes.WINFUNCTYPE(POINTER(LPCWSTR), LPCWSTR, POINTER(INT))
 
514
        CommandLineToArgv = prototype(("CommandLineToArgvW",
 
515
                                       ctypes.windll.shell32))
 
516
        c = INT(0)
 
517
        pargv = CommandLineToArgv(GetCommandLine(), ctypes.byref(c))
574
518
        # Skip the first argument, since we only care about parameters
575
 
        argv = _command_line_to_argv(command_line, sys.argv)[1:]
 
519
        argv = [pargv[i] for i in range(1, c.value)]
 
520
        if getattr(sys, 'frozen', None) is None:
 
521
            # Invoked via 'python.exe' which takes the form:
 
522
            #   python.exe [PYTHON_OPTIONS] C:\Path\bzr [BZR_OPTIONS]
 
523
            # we need to get only BZR_OPTIONS part,
 
524
            # so let's using sys.argv[1:] as reference to get the tail
 
525
            # of unicode argv
 
526
            tail_len = len(sys.argv[1:])
 
527
            ix = len(argv) - tail_len
 
528
            argv = argv[ix:]
576
529
        return argv
577
530
else:
578
531
    get_unicode_argv = None
579
 
 
580
 
 
581
 
if has_win32api:
582
 
    def _pywin32_is_local_pid_dead(pid):
583
 
        """True if pid doesn't correspond to live process on this machine"""
584
 
        try:
585
 
            handle = win32api.OpenProcess(1, False, pid) # PROCESS_TERMINATE
586
 
        except pywintypes.error, e:
587
 
            if e[0] == 5: # ERROR_ACCESS_DENIED
588
 
                # Probably something alive we're not allowed to kill
589
 
                return False
590
 
            elif e[0] == 87: # ERROR_INVALID_PARAMETER
591
 
                return True
592
 
            raise
593
 
        handle.close()
594
 
        return False
595
 
    is_local_pid_dead = _pywin32_is_local_pid_dead
596
 
elif has_ctypes and sys.platform == 'win32':
597
 
    from ctypes.wintypes import BOOL, DWORD, HANDLE
598
 
    _kernel32 = ctypes.windll.kernel32
599
 
    _CloseHandle = ctypes.WINFUNCTYPE(BOOL, HANDLE)(
600
 
        ("CloseHandle", _kernel32))
601
 
    _OpenProcess = ctypes.WINFUNCTYPE(HANDLE, DWORD, BOOL, DWORD)(
602
 
        ("OpenProcess", _kernel32))
603
 
    def _ctypes_is_local_pid_dead(pid):
604
 
        """True if pid doesn't correspond to live process on this machine"""
605
 
        handle = _OpenProcess(1, False, pid) # PROCESS_TERMINATE
606
 
        if not handle:
607
 
            errorcode = ctypes.GetLastError()
608
 
            if errorcode == 5: # ERROR_ACCESS_DENIED
609
 
                # Probably something alive we're not allowed to kill
610
 
                return False
611
 
            elif errorcode == 87: # ERROR_INVALID_PARAMETER
612
 
                return True
613
 
            raise ctypes.WinError(errorcode)
614
 
        _CloseHandle(handle)
615
 
        return False
616
 
    is_local_pid_dead = _ctypes_is_local_pid_dead