← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

  • Committer: John Arbash Meinel
  • Date: 2009-06-02 18:59:18 UTC
  • mto: This revision was merged to the branch mainline in revision 4469.
  • Revision ID: john@arbash-meinel.com-20090602185918-86l9eljnn8z2iljk
Add a VersionedFile.add_text() api.

Similar to VF.add_lines() except it takes a string for the content, rather
than a list of lines.

For now, it just thunks over to VF.add_lines(), but it will be special
cased in the future.

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
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
99
 
107
100
def debug_memory_win32api(message='', short=True):
108
101
    """Use trace.note() to dump the running memory info."""
135
128
                'WorkingSetSize': mem_struct.WorkingSetSize,
136
129
                'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
137
130
                'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
138
 
                'QuotaPeakNonPagedPoolUsage':
139
 
                    mem_struct.QuotaPeakNonPagedPoolUsage,
 
131
                'QuotaPeakNonPagedPoolUsage': mem_struct.QuotaPeakNonPagedPoolUsage,
140
132
                'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
141
133
                'PagefileUsage': mem_struct.PagefileUsage,
142
134
                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
153
145
                   ' or win32process')
154
146
        return
155
147
    if short:
156
 
        # using base-2 units (see HACKING.txt).
157
 
        trace.note('WorkingSize %7dKiB'
158
 
                   '\tPeakWorking %7dKiB\t%s',
 
148
        trace.note('WorkingSize %7dKB'
 
149
                   '\tPeakWorking %7dKB\t%s',
159
150
                   info['WorkingSetSize'] / 1024,
160
151
                   info['PeakWorkingSetSize'] / 1024,
161
152
                   message)
162
153
        return
163
154
    if message:
164
155
        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)
 
156
    trace.note('WorkingSize       %8d KB', info['WorkingSetSize'] / 1024)
 
157
    trace.note('PeakWorking       %8d KB', info['PeakWorkingSetSize'] / 1024)
 
158
    trace.note('PagefileUsage     %8d KB', info.get('PagefileUsage', 0) / 1024)
 
159
    trace.note('PeakPagefileUsage %8d KB', info.get('PeakPagefileUsage', 0) / 1024)
 
160
    trace.note('PrivateUsage      %8d KB', info.get('PrivateUsage', 0) / 1024)
171
161
    trace.note('PageFaultCount    %8d', info.get('PageFaultCount', 0))
172
162
 
173
163
 
183
173
        return (defaultx, defaulty)
184
174
 
185
175
    # To avoid problem with redirecting output via pipe
186
 
    # we need to use stderr instead of stdout
 
176
    # need to use stderr instead of stdout
187
177
    h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
188
178
    csbi = ctypes.create_string_buffer(22)
189
179
    res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
190
180
 
191
181
    if res:
192
182
        (bufx, bufy, curx, cury, wattr,
193
 
        left, top, right, bottom, maxx, maxy) = struct.unpack(
194
 
            "hhhhHhhhhhh", csbi.raw)
 
183
        left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
195
184
        sizex = right - left + 1
196
185
        sizey = bottom - top + 1
197
186
        return (sizex, sizey)
278
267
 
279
268
    Returned value can be unicode or plain string.
280
269
    To convert plain string to unicode use
281
 
    s.decode(osutils.get_user_encoding())
 
270
    s.decode(bzrlib.user_encoding)
282
271
    (XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
283
272
    """
284
273
    local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
394
383
 
395
384
 
396
385
def _ensure_unicode(s):
 
386
    from bzrlib import osutils
397
387
    if s and type(s) != unicode:
398
388
        from bzrlib import osutils
399
389
        s = s.decode(osutils.get_user_encoding())
414
404
 
415
405
 
416
406
def _ensure_with_dir(path):
417
 
    if (not os.path.split(path)[0] or path.startswith(u'*')
418
 
        or path.startswith(u'?')):
 
407
    if not os.path.split(path)[0] or path.startswith(u'*') or path.startswith(u'?'):
419
408
        return u'./' + path, True
420
409
    else:
421
410
        return path, False
428
417
 
429
418
 
430
419
 
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
420
def glob_expand(file_list):
452
421
    """Replacement for glob expansion by the shell.
453
422
 
461
430
    """
462
431
    if not file_list:
463
432
        return []
 
433
    import glob
464
434
    expanded_file_list = []
465
435
    for possible_glob in file_list:
466
 
        expanded_file_list.extend(glob_one(possible_glob))
467
 
    return expanded_file_list
 
436
        # work around bugs in glob.glob()
 
437
        # - Python bug #1001604 ("glob doesn't return unicode with ...")
 
438
        # - failing expansion for */* with non-iso-8859-* chars
 
439
        possible_glob, corrected = _ensure_with_dir(possible_glob)
 
440
        glob_files = glob.glob(possible_glob)
 
441
 
 
442
        if glob_files == []:
 
443
            # special case to let the normal code path handle
 
444
            # files that do not exists
 
445
            expanded_file_list.append(
 
446
                _undo_ensure_with_dir(possible_glob, corrected))
 
447
        else:
 
448
            glob_files = [_undo_ensure_with_dir(elem, corrected) for elem in glob_files]
 
449
            expanded_file_list += glob_files
 
450
 
 
451
    return [elem.replace(u'\\', u'/') for elem in expanded_file_list]
468
452
 
469
453
 
470
454
def get_app_path(appname):
471
 
    r"""Look up in Windows registry for full path to application executable.
 
455
    """Look up in Windows registry for full path to application executable.
472
456
    Typically, applications create subkey with their basename
473
457
    in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
474
458
 
478
462
                or appname itself if nothing found.
479
463
    """
480
464
    import _winreg
 
465
    try:
 
466
        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
 
467
                               r'SOFTWARE\Microsoft\Windows'
 
468
                               r'\CurrentVersion\App Paths')
 
469
    except EnvironmentError:
 
470
        return appname
481
471
 
482
472
    basename = appname
483
473
    if not os.path.splitext(basename)[1]:
484
474
        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
475
    try:
494
476
        try:
495
 
            path, type_id = _winreg.QueryValueEx(hkey, '')
 
477
            fullpath = _winreg.QueryValue(hkey, basename)
496
478
        except WindowsError:
497
 
            return appname
 
479
            fullpath = appname
498
480
    finally:
499
481
        _winreg.CloseKey(hkey)
500
482
 
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
 
483
    return fullpath
509
484
 
510
485
 
511
486
def set_file_attr_hidden(path):
512
487
    """Set file attributes to hidden if possible"""
513
488
    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
 
489
        win32file.SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
564
490
 
565
491
 
566
492
if has_ctypes and winver != 'Windows 98':
567
493
    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()
 
494
        LPCWSTR = ctypes.c_wchar_p
 
495
        INT = ctypes.c_int
 
496
        POINTER = ctypes.POINTER
 
497
        prototype = ctypes.WINFUNCTYPE(LPCWSTR)
 
498
        GetCommandLine = prototype(("GetCommandLineW",
 
499
                                    ctypes.windll.kernel32))
 
500
        prototype = ctypes.WINFUNCTYPE(POINTER(LPCWSTR), LPCWSTR, POINTER(INT))
 
501
        CommandLineToArgv = prototype(("CommandLineToArgvW",
 
502
                                       ctypes.windll.shell32))
 
503
        c = INT(0)
 
504
        pargv = CommandLineToArgv(GetCommandLine(), ctypes.byref(c))
574
505
        # Skip the first argument, since we only care about parameters
575
 
        argv = _command_line_to_argv(command_line, sys.argv)[1:]
 
506
        argv = [pargv[i] for i in range(1, c.value)]
 
507
        if getattr(sys, 'frozen', None) is None:
 
508
            # Invoked via 'python.exe' which takes the form:
 
509
            #   python.exe [PYTHON_OPTIONS] C:\Path\bzr [BZR_OPTIONS]
 
510
            # we need to get only BZR_OPTIONS part,
 
511
            # so let's using sys.argv[1:] as reference to get the tail
 
512
            # of unicode argv
 
513
            tail_len = len(sys.argv[1:])
 
514
            ix = len(argv) - tail_len
 
515
            argv = argv[ix:]
576
516
        return argv
577
517
else:
578
518
    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