/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-04-06 06:59:03 UTC
  • mfrom: (5051.5.1 subunit)
  • Revision ID: pqm@pqm.ubuntu.com-20100406065903-y9dxgwmog1pmw7dz
Use subunit when running tests in PQM.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/win32utils.py
19
19
Only one dependency: ctypes should be installed.
20
20
"""
21
21
 
22
 
from __future__ import absolute_import
23
 
 
24
22
import glob
25
 
import operator
26
23
import os
 
24
import re
27
25
import struct
28
26
import sys
29
27
 
30
 
from breezy import (
31
 
    cmdline,
32
 
    )
33
 
from breezy.i18n import gettext
 
28
from bzrlib import cmdline
 
29
 
 
30
# Windows version
 
31
if sys.platform == 'win32':
 
32
    _major,_minor,_build,_platform,_text = sys.getwindowsversion()
 
33
    # from MSDN:
 
34
    # dwPlatformId
 
35
    #   The operating system platform.
 
36
    #   This member can be one of the following values.
 
37
    #   ==========================  ======================================
 
38
    #   Value                       Meaning
 
39
    #   --------------------------  --------------------------------------
 
40
    #   VER_PLATFORM_WIN32_NT       The operating system is Windows Vista,
 
41
    #   2                           Windows Server "Longhorn",
 
42
    #                               Windows Server 2003, Windows XP,
 
43
    #                               Windows 2000, or Windows NT.
 
44
    #
 
45
    #   VER_PLATFORM_WIN32_WINDOWS  The operating system is Windows Me,
 
46
    #   1                           Windows 98, or Windows 95.
 
47
    #   ==========================  ======================================
 
48
    if _platform == 2:
 
49
        winver = 'Windows NT'
 
50
    else:
 
51
        # don't care about real Windows name, just to force safe operations
 
52
        winver = 'Windows 98'
 
53
else:
 
54
    winver = None
 
55
 
34
56
 
35
57
# We can cope without it; use a separate variable to help pyflakes
36
58
try:
39
61
except ImportError:
40
62
    has_ctypes = False
41
63
else:
42
 
    create_buffer = ctypes.create_unicode_buffer
43
 
    extract_buffer = operator.attrgetter("value")
44
 
    suffix = 'W'
 
64
    if winver == 'Windows 98':
 
65
        create_buffer = ctypes.create_string_buffer
 
66
        suffix = 'A'
 
67
    else:
 
68
        create_buffer = ctypes.create_unicode_buffer
 
69
        suffix = 'W'
45
70
try:
 
71
    import win32file
46
72
    import pywintypes
47
 
    has_pywintypes = True
48
 
except ImportError:
49
 
    has_pywintypes = has_win32file = has_win32api = False
50
 
else:
51
 
    try:
52
 
        import win32file
53
 
        has_win32file = True
54
 
    except ImportError:
55
 
        has_win32file = False
56
 
    try:
57
 
        import win32api
58
 
        has_win32api = True
59
 
    except ImportError:
60
 
        has_win32api = False
 
73
    has_win32file = True
 
74
except ImportError:
 
75
    has_win32file = False
 
76
try:
 
77
    import win32api
 
78
    has_win32api = True
 
79
except ImportError:
 
80
    has_win32api = False
61
81
 
62
82
# pulling in win32com.shell is a bit of overhead, and normally we don't need
63
83
# it as ctypes is preferred and common.  lazy_imports and "optional"
87
107
 
88
108
def debug_memory_win32api(message='', short=True):
89
109
    """Use trace.note() to dump the running memory info."""
90
 
    from breezy import trace
 
110
    from bzrlib import trace
91
111
    if has_ctypes:
92
112
        class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
93
113
            """Used by GetProcessMemoryInfo"""
109
129
            ctypes.byref(mem_struct),
110
130
            ctypes.sizeof(mem_struct))
111
131
        if not ret:
112
 
            trace.note(gettext('Failed to GetProcessMemoryInfo()'))
 
132
            trace.note('Failed to GetProcessMemoryInfo()')
113
133
            return
114
134
        info = {'PageFaultCount': mem_struct.PageFaultCount,
115
135
                'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
130
150
        proc = win32process.GetCurrentProcess()
131
151
        info = win32process.GetProcessMemoryInfo(proc)
132
152
    else:
133
 
        trace.note(gettext('Cannot debug memory on win32 without ctypes'
134
 
                   ' or win32process'))
 
153
        trace.note('Cannot debug memory on win32 without ctypes'
 
154
                   ' or win32process')
135
155
        return
136
156
    if short:
137
157
        # using base-2 units (see HACKING.txt).
138
 
        trace.note(gettext('WorkingSize {0:>7}KiB'
139
 
                   '\tPeakWorking {1:>7}KiB\t{2}').format(
 
158
        trace.note('WorkingSize %7dKiB'
 
159
                   '\tPeakWorking %7dKiB\t%s',
140
160
                   info['WorkingSetSize'] / 1024,
141
161
                   info['PeakWorkingSetSize'] / 1024,
142
 
                   message))
 
162
                   message)
143
163
        return
144
164
    if message:
145
165
        trace.note('%s', message)
146
 
    trace.note(gettext('WorkingSize       %8d KiB'), info['WorkingSetSize'] / 1024)
147
 
    trace.note(gettext('PeakWorking       %8d KiB'), info['PeakWorkingSetSize'] / 1024)
148
 
    trace.note(gettext('PagefileUsage     %8d KiB'), info.get('PagefileUsage', 0) / 1024)
149
 
    trace.note(gettext('PeakPagefileUsage %8d KiB'),
 
166
    trace.note('WorkingSize       %8d KiB', info['WorkingSetSize'] / 1024)
 
167
    trace.note('PeakWorking       %8d KiB', info['PeakWorkingSetSize'] / 1024)
 
168
    trace.note('PagefileUsage     %8d KiB', info.get('PagefileUsage', 0) / 1024)
 
169
    trace.note('PeakPagefileUsage %8d KiB',
150
170
               info.get('PeakPagefileUsage', 0) / 1024)
151
 
    trace.note(gettext('PrivateUsage      %8d KiB'), info.get('PrivateUsage', 0) / 1024)
152
 
    trace.note(gettext('PageFaultCount    %8d'), info.get('PageFaultCount', 0))
 
171
    trace.note('PrivateUsage      %8d KiB', info.get('PrivateUsage', 0) / 1024)
 
172
    trace.note('PageFaultCount    %8d', info.get('PageFaultCount', 0))
153
173
 
154
174
 
155
175
def get_console_size(defaultx=80, defaulty=25):
193
213
            pass
194
214
        else:
195
215
            buf = ctypes.create_unicode_buffer(MAX_PATH)
196
 
            if SHGetSpecialFolderPath(None, buf, csidl, 0):
 
216
            if SHGetSpecialFolderPath(None,buf,csidl,0):
197
217
                return buf.value
198
218
 
199
219
    global has_win32com_shell
223
243
    one that moves with the user as they logon to different machines, and
224
244
    a 'local' one that stays local to the machine.  This returns the 'roaming'
225
245
    directory, and thus is suitable for storing user-preferences, etc.
 
246
 
 
247
    Returned value can be unicode or plain string.
 
248
    To convert plain string to unicode use
 
249
    s.decode(osutils.get_user_encoding())
 
250
    (XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
226
251
    """
227
252
    appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
228
253
    if appdata:
229
254
        return appdata
230
 
    # Use APPDATA if defined, will return None if not
231
 
    return get_environ_unicode('APPDATA')
 
255
    # from env variable
 
256
    appdata = os.environ.get('APPDATA')
 
257
    if appdata:
 
258
        return appdata
 
259
    # if we fall to this point we on win98
 
260
    # at least try C:/WINDOWS/Application Data
 
261
    windir = os.environ.get('windir')
 
262
    if windir:
 
263
        appdata = os.path.join(windir, 'Application Data')
 
264
        if os.path.isdir(appdata):
 
265
            return appdata
 
266
    # did not find anything
 
267
    return None
232
268
 
233
269
 
234
270
def get_local_appdata_location():
240
276
    a 'local' one that stays local to the machine.  This returns the 'local'
241
277
    directory, and thus is suitable for caches, temp files and other things
242
278
    which don't need to move with the user.
 
279
 
 
280
    Returned value can be unicode or plain string.
 
281
    To convert plain string to unicode use
 
282
    s.decode(osutils.get_user_encoding())
 
283
    (XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
243
284
    """
244
285
    local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
245
286
    if local:
246
287
        return local
247
288
    # Vista supplies LOCALAPPDATA, but XP and earlier do not.
248
 
    local = get_environ_unicode('LOCALAPPDATA')
 
289
    local = os.environ.get('LOCALAPPDATA')
249
290
    if local:
250
291
        return local
251
292
    return get_appdata_location()
256
297
    Assume on win32 it's the <My Documents> folder.
257
298
    If location cannot be obtained return system drive root,
258
299
    i.e. C:\
 
300
 
 
301
    Returned value can be unicode or plain string.
 
302
    To convert plain string to unicode use
 
303
    s.decode(osutils.get_user_encoding())
259
304
    """
260
305
    home = _get_sh_special_folder_path(CSIDL_PERSONAL)
261
306
    if home:
262
307
        return home
263
 
    home = get_environ_unicode('HOME')
264
 
    if home is not None:
 
308
    # try for HOME env variable
 
309
    home = os.path.expanduser('~')
 
310
    if home != '~':
265
311
        return home
266
 
    homepath = get_environ_unicode('HOMEPATH')
267
 
    if homepath is not None:
268
 
        return os.path.join(get_environ_unicode('HOMEDIR', ''), home)
269
312
    # at least return windows root directory
270
 
    windir = get_environ_unicode('WINDIR')
 
313
    windir = os.environ.get('windir')
271
314
    if windir:
272
315
        return os.path.splitdrive(windir)[0] + '/'
273
316
    # otherwise C:\ is good enough for 98% users
274
 
    return u'C:/'
 
317
    return 'C:/'
275
318
 
276
319
 
277
320
def get_user_name():
278
321
    """Return user name as login name.
279
322
    If name cannot be obtained return None.
 
323
 
 
324
    Returned value can be unicode or plain string.
 
325
    To convert plain string to unicode use
 
326
    s.decode(osutils.get_user_encoding())
280
327
    """
281
328
    if has_ctypes:
282
329
        try:
288
335
            buf = create_buffer(UNLEN+1)
289
336
            n = ctypes.c_int(UNLEN+1)
290
337
            if GetUserName(buf, ctypes.byref(n)):
291
 
                return extract_buffer(buf)
 
338
                return buf.value
292
339
    # otherwise try env variables
293
 
    return get_environ_unicode('USERNAME')
 
340
    return os.environ.get('USERNAME', None)
294
341
 
295
342
 
296
343
# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local
301
348
    """Return host machine name.
302
349
    If name cannot be obtained return None.
303
350
 
304
 
    :return: A unicode string representing the host name.
 
351
    :return: A unicode string representing the host name. On win98, this may be
 
352
        a plain string as win32 api doesn't support unicode.
305
353
    """
306
354
    if has_win32api:
307
355
        try:
324
372
            if (GetComputerNameEx is not None
325
373
                and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
326
374
                                      buf, ctypes.byref(n))):
327
 
                return extract_buffer(buf)
 
375
                return buf.value
328
376
 
329
377
            # Try GetComputerName in case GetComputerNameEx wasn't found
330
378
            # It returns the NETBIOS name, which isn't as good, but still ok.
334
382
                                      None)
335
383
            if (GetComputerName is not None
336
384
                and GetComputerName(buf, ctypes.byref(n))):
337
 
                return extract_buffer(buf)
338
 
    return get_environ_unicode('COMPUTERNAME')
 
385
                return buf.value
 
386
    # otherwise try env variables, which will be 'mbcs' encoded
 
387
    # on Windows (Python doesn't expose the native win32 unicode environment)
 
388
    # According to this:
 
389
    # http://msdn.microsoft.com/en-us/library/aa246807.aspx
 
390
    # environment variables should always be encoded in 'mbcs'.
 
391
    try:
 
392
        return os.environ['COMPUTERNAME'].decode("mbcs")
 
393
    except KeyError:
 
394
        return None
 
395
 
 
396
 
 
397
def _ensure_unicode(s):
 
398
    if s and type(s) != unicode:
 
399
        from bzrlib import osutils
 
400
        s = s.decode(osutils.get_user_encoding())
 
401
    return s
 
402
 
 
403
 
 
404
def get_appdata_location_unicode():
 
405
    return _ensure_unicode(get_appdata_location())
 
406
 
 
407
def get_home_location_unicode():
 
408
    return _ensure_unicode(get_home_location())
 
409
 
 
410
def get_user_name_unicode():
 
411
    return _ensure_unicode(get_user_name())
 
412
 
 
413
def get_host_name_unicode():
 
414
    return _ensure_unicode(get_host_name())
339
415
 
340
416
 
341
417
def _ensure_with_dir(path):
352
428
        return path
353
429
 
354
430
 
 
431
 
355
432
def glob_one(possible_glob):
356
433
    """Same as glob.glob().
357
434
 
381
458
    :param file_list: A list of filenames which may include shell globs.
382
459
    :return: An expanded list of filenames.
383
460
 
384
 
    Introduced in breezy 0.18.
 
461
    Introduced in bzrlib 0.18.
385
462
    """
386
463
    if not file_list:
387
464
        return []
392
469
 
393
470
 
394
471
def get_app_path(appname):
395
 
    r"""Look up in Windows registry for full path to application executable.
 
472
    """Look up in Windows registry for full path to application executable.
396
473
    Typically, applications create subkey with their basename
397
474
    in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
398
475
 
435
512
def set_file_attr_hidden(path):
436
513
    """Set file attributes to hidden if possible"""
437
514
    if has_win32file:
438
 
        SetFileAttributes = win32file.SetFileAttributesW
 
515
        if winver != 'Windows 98':
 
516
            SetFileAttributes = win32file.SetFileAttributesW
 
517
        else:
 
518
            SetFileAttributes = win32file.SetFileAttributes
439
519
        try:
440
520
            SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
441
 
        except pywintypes.error as e:
442
 
            from . import trace
 
521
        except pywintypes.error, e:
 
522
            from bzrlib import trace
443
523
            trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
444
524
 
445
525
 
446
 
def _command_line_to_argv(command_line, argv, single_quotes_allowed=False):
 
526
def _command_line_to_argv(command_line, single_quotes_allowed=False):
447
527
    """Convert a Unicode command line into a list of argv arguments.
448
528
 
449
529
    It performs wildcard expansion to make wildcards act closer to how they
456
536
                                  default.
457
537
    :return: A list of unicode strings.
458
538
    """
459
 
    # First, split the command line
460
539
    s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
461
 
    
462
 
    # Bug #587868 Now make sure that the length of s agrees with sys.argv 
463
 
    # we do this by simply counting the number of arguments in each. The counts should 
464
 
    # agree no matter what encoding sys.argv is in (AFAIK) 
465
 
    # len(arguments) < len(sys.argv) should be an impossibility since python gets 
466
 
    # args from the very same PEB as does GetCommandLineW
467
 
    arguments = list(s)
468
 
    
469
 
    # Now shorten the command line we get from GetCommandLineW to match sys.argv
470
 
    if len(arguments) < len(argv):
471
 
        raise AssertionError("Split command line can't be shorter than argv")
472
 
    arguments = arguments[len(arguments) - len(argv):]
473
 
    
474
 
    # Carry on to process globs (metachars) in the command line
475
 
    # expand globs if necessary
 
540
    # Now that we've split the content, expand globs if necessary
476
541
    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
477
542
    #       '**/' style globs
478
543
    args = []
479
 
    for is_quoted, arg in arguments:
 
544
    for is_quoted, arg in s:
480
545
        if is_quoted or not glob.has_magic(arg):
481
546
            args.append(arg)
482
547
        else:
484
549
    return args
485
550
 
486
551
 
487
 
if has_ctypes:
 
552
if has_ctypes and winver != 'Windows 98':
488
553
    def get_unicode_argv():
489
554
        prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
490
555
        GetCommandLineW = prototype(("GetCommandLineW",
493
558
        if command_line is None:
494
559
            raise ctypes.WinError()
495
560
        # Skip the first argument, since we only care about parameters
496
 
        argv = _command_line_to_argv(command_line, sys.argv)[1:]
 
561
        argv = _command_line_to_argv(command_line)[1:]
 
562
        if getattr(sys, 'frozen', None) is None:
 
563
            # Invoked via 'python.exe' which takes the form:
 
564
            #   python.exe [PYTHON_OPTIONS] C:\Path\bzr [BZR_OPTIONS]
 
565
            # we need to get only BZR_OPTIONS part,
 
566
            # We already removed 'python.exe' so we remove everything up to and
 
567
            # including the first non-option ('-') argument.
 
568
            for idx in xrange(len(argv)):
 
569
                if argv[idx][:1] != '-':
 
570
                    break
 
571
            argv = argv[idx+1:]
497
572
        return argv
498
 
 
499
 
 
500
 
    def get_environ_unicode(key, default=None):
501
 
        """Get `key` from environment as unicode or `default` if unset
502
 
 
503
 
        The environment is natively unicode on modern windows versions but
504
 
        Python 2 only accesses it through the legacy bytestring api.
505
 
 
506
 
        Environmental variable names are case insenstive on Windows.
507
 
 
508
 
        A large enough buffer will be allocated to retrieve the value, though
509
 
        it may take two calls to the underlying library function.
510
 
 
511
 
        This needs ctypes because pywin32 does not expose the wide version.
512
 
        """
513
 
        cfunc = getattr(get_environ_unicode, "_c_function", None)
514
 
        if cfunc is None:
515
 
            from ctypes.wintypes import DWORD, LPCWSTR, LPWSTR
516
 
            cfunc = ctypes.WINFUNCTYPE(DWORD, LPCWSTR, LPWSTR, DWORD)(
517
 
                ("GetEnvironmentVariableW", ctypes.windll.kernel32))
518
 
            get_environ_unicode._c_function = cfunc
519
 
        buffer_size = 256 # heuristic, 256 characters often enough
520
 
        while True:
521
 
            buffer = ctypes.create_unicode_buffer(buffer_size)
522
 
            length = cfunc(key, buffer, buffer_size)
523
 
            if not length:
524
 
                code = ctypes.GetLastError()
525
 
                if code == 203: # ERROR_ENVVAR_NOT_FOUND
526
 
                    return default
527
 
                raise ctypes.WinError(code)
528
 
            if buffer_size > length:
529
 
                return buffer[:length]
530
 
            buffer_size = length
531
 
 
532
 
 
533
 
if has_win32api:
534
 
    def _pywin32_is_local_pid_dead(pid):
535
 
        """True if pid doesn't correspond to live process on this machine"""
536
 
        try:
537
 
            handle = win32api.OpenProcess(1, False, pid) # PROCESS_TERMINATE
538
 
        except pywintypes.error as e:
539
 
            if e[0] == 5: # ERROR_ACCESS_DENIED
540
 
                # Probably something alive we're not allowed to kill
541
 
                return False
542
 
            elif e[0] == 87: # ERROR_INVALID_PARAMETER
543
 
                return True
544
 
            raise
545
 
        handle.close()
546
 
        return False
547
 
    is_local_pid_dead = _pywin32_is_local_pid_dead
548
 
elif has_ctypes and sys.platform == 'win32':
549
 
    from ctypes.wintypes import BOOL, DWORD, HANDLE
550
 
    _kernel32 = ctypes.windll.kernel32
551
 
    _CloseHandle = ctypes.WINFUNCTYPE(BOOL, HANDLE)(
552
 
        ("CloseHandle", _kernel32))
553
 
    _OpenProcess = ctypes.WINFUNCTYPE(HANDLE, DWORD, BOOL, DWORD)(
554
 
        ("OpenProcess", _kernel32))
555
 
    def _ctypes_is_local_pid_dead(pid):
556
 
        """True if pid doesn't correspond to live process on this machine"""
557
 
        handle = _OpenProcess(1, False, pid) # PROCESS_TERMINATE
558
 
        if not handle:
559
 
            errorcode = ctypes.GetLastError()
560
 
            if errorcode == 5: # ERROR_ACCESS_DENIED
561
 
                # Probably something alive we're not allowed to kill
562
 
                return False
563
 
            elif errorcode == 87: # ERROR_INVALID_PARAMETER
564
 
                return True
565
 
            raise ctypes.WinError(errorcode)
566
 
        _CloseHandle(handle)
567
 
        return False
568
 
    is_local_pid_dead = _ctypes_is_local_pid_dead
569
 
 
570
 
 
571
 
def _is_pywintypes_error(evalue):
572
 
    """True if exception instance is an error from pywin32"""
573
 
    if has_pywintypes and isinstance(evalue, pywintypes.error):
574
 
        return True
575
 
    return False
 
573
else:
 
574
    get_unicode_argv = None