← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-03-25 00:02:51 UTC
  • mfrom: (5106.1.1 version-bump)
  • Revision ID: pqm@pqm.ubuntu.com-20100325000251-bwsv5c5d3l9x3lnn
(Jelmer) Bump API version for 2.2.0.

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 bzrlib import (
31
 
    cmdline,
32
 
    symbol_versioning,
33
 
    )
34
 
from bzrlib.i18n import gettext
 
28
from bzrlib import cmdline
35
29
 
36
30
# Windows version
37
31
if sys.platform == 'win32':
69
63
else:
70
64
    if winver == 'Windows 98':
71
65
        create_buffer = ctypes.create_string_buffer
72
 
        def extract_buffer(buf):
73
 
            return buf.value.decode("mbcs")
74
66
        suffix = 'A'
75
67
    else:
76
68
        create_buffer = ctypes.create_unicode_buffer
77
 
        extract_buffer = operator.attrgetter("value")
78
69
        suffix = 'W'
79
70
try:
 
71
    import win32file
80
72
    import pywintypes
81
 
    has_pywintypes = True
82
 
except ImportError:
83
 
    has_pywintypes = has_win32file = has_win32api = False
84
 
else:
85
 
    try:
86
 
        import win32file
87
 
        has_win32file = True
88
 
    except ImportError:
89
 
        has_win32file = False
90
 
    try:
91
 
        import win32api
92
 
        has_win32api = True
93
 
    except ImportError:
94
 
        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
95
81
 
96
82
# pulling in win32com.shell is a bit of overhead, and normally we don't need
97
83
# it as ctypes is preferred and common.  lazy_imports and "optional"
143
129
            ctypes.byref(mem_struct),
144
130
            ctypes.sizeof(mem_struct))
145
131
        if not ret:
146
 
            trace.note(gettext('Failed to GetProcessMemoryInfo()'))
 
132
            trace.note('Failed to GetProcessMemoryInfo()')
147
133
            return
148
134
        info = {'PageFaultCount': mem_struct.PageFaultCount,
149
135
                'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
164
150
        proc = win32process.GetCurrentProcess()
165
151
        info = win32process.GetProcessMemoryInfo(proc)
166
152
    else:
167
 
        trace.note(gettext('Cannot debug memory on win32 without ctypes'
168
 
                   ' or win32process'))
 
153
        trace.note('Cannot debug memory on win32 without ctypes'
 
154
                   ' or win32process')
169
155
        return
170
156
    if short:
171
157
        # using base-2 units (see HACKING.txt).
172
 
        trace.note(gettext('WorkingSize {0:>7}KiB'
173
 
                   '\tPeakWorking {1:>7}KiB\t{2}').format(
 
158
        trace.note('WorkingSize %7dKiB'
 
159
                   '\tPeakWorking %7dKiB\t%s',
174
160
                   info['WorkingSetSize'] / 1024,
175
161
                   info['PeakWorkingSetSize'] / 1024,
176
 
                   message))
 
162
                   message)
177
163
        return
178
164
    if message:
179
165
        trace.note('%s', message)
180
 
    trace.note(gettext('WorkingSize       %8d KiB'), info['WorkingSetSize'] / 1024)
181
 
    trace.note(gettext('PeakWorking       %8d KiB'), info['PeakWorkingSetSize'] / 1024)
182
 
    trace.note(gettext('PagefileUsage     %8d KiB'), info.get('PagefileUsage', 0) / 1024)
183
 
    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',
184
170
               info.get('PeakPagefileUsage', 0) / 1024)
185
 
    trace.note(gettext('PrivateUsage      %8d KiB'), info.get('PrivateUsage', 0) / 1024)
186
 
    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))
187
173
 
188
174
 
189
175
def get_console_size(defaultx=80, defaulty=25):
257
243
    one that moves with the user as they logon to different machines, and
258
244
    a 'local' one that stays local to the machine.  This returns the 'roaming'
259
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')
260
251
    """
261
252
    appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
262
253
    if appdata:
263
254
        return appdata
264
 
    # Use APPDATA if defined, will return None if not
265
 
    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
266
268
 
267
269
 
268
270
def get_local_appdata_location():
274
276
    a 'local' one that stays local to the machine.  This returns the 'local'
275
277
    directory, and thus is suitable for caches, temp files and other things
276
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')
277
284
    """
278
285
    local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
279
286
    if local:
280
287
        return local
281
288
    # Vista supplies LOCALAPPDATA, but XP and earlier do not.
282
 
    local = get_environ_unicode('LOCALAPPDATA')
 
289
    local = os.environ.get('LOCALAPPDATA')
283
290
    if local:
284
291
        return local
285
292
    return get_appdata_location()
290
297
    Assume on win32 it's the <My Documents> folder.
291
298
    If location cannot be obtained return system drive root,
292
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())
293
304
    """
294
305
    home = _get_sh_special_folder_path(CSIDL_PERSONAL)
295
306
    if home:
296
307
        return home
297
 
    home = get_environ_unicode('HOME')
298
 
    if home is not None:
 
308
    # try for HOME env variable
 
309
    home = os.path.expanduser('~')
 
310
    if home != '~':
299
311
        return home
300
 
    homepath = get_environ_unicode('HOMEPATH')
301
 
    if homepath is not None:
302
 
        return os.path.join(get_environ_unicode('HOMEDIR', ''), home)
303
312
    # at least return windows root directory
304
 
    windir = get_environ_unicode('WINDIR')
 
313
    windir = os.environ.get('windir')
305
314
    if windir:
306
315
        return os.path.splitdrive(windir)[0] + '/'
307
316
    # otherwise C:\ is good enough for 98% users
308
 
    return unicode('C:/')
 
317
    return 'C:/'
309
318
 
310
319
 
311
320
def get_user_name():
312
321
    """Return user name as login name.
313
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())
314
327
    """
315
328
    if has_ctypes:
316
329
        try:
322
335
            buf = create_buffer(UNLEN+1)
323
336
            n = ctypes.c_int(UNLEN+1)
324
337
            if GetUserName(buf, ctypes.byref(n)):
325
 
                return extract_buffer(buf)
 
338
                return buf.value
326
339
    # otherwise try env variables
327
 
    return get_environ_unicode('USERNAME')
 
340
    return os.environ.get('USERNAME', None)
328
341
 
329
342
 
330
343
# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local
335
348
    """Return host machine name.
336
349
    If name cannot be obtained return None.
337
350
 
338
 
    :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.
339
353
    """
340
354
    if has_win32api:
341
355
        try:
358
372
            if (GetComputerNameEx is not None
359
373
                and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
360
374
                                      buf, ctypes.byref(n))):
361
 
                return extract_buffer(buf)
 
375
                return buf.value
362
376
 
363
377
            # Try GetComputerName in case GetComputerNameEx wasn't found
364
378
            # It returns the NETBIOS name, which isn't as good, but still ok.
368
382
                                      None)
369
383
            if (GetComputerName is not None
370
384
                and GetComputerName(buf, ctypes.byref(n))):
371
 
                return extract_buffer(buf)
372
 
    return get_environ_unicode('COMPUTERNAME')
373
 
 
374
 
 
375
 
@symbol_versioning.deprecated_function(
376
 
    symbol_versioning.deprecated_in((2, 5, 0)))
 
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
 
377
397
def _ensure_unicode(s):
378
398
    if s and type(s) != unicode:
379
399
        from bzrlib import osutils
381
401
    return s
382
402
 
383
403
 
384
 
get_appdata_location_unicode = symbol_versioning.deprecated_function(
385
 
    symbol_versioning.deprecated_in((2, 5, 0)))(get_appdata_location)
386
 
 
387
 
get_home_location_unicode = symbol_versioning.deprecated_function(
388
 
    symbol_versioning.deprecated_in((2, 5, 0)))(get_home_location)
389
 
 
390
 
get_user_name_unicode = symbol_versioning.deprecated_function(
391
 
    symbol_versioning.deprecated_in((2, 5, 0)))(get_user_name)
392
 
 
393
 
get_host_name_unicode = symbol_versioning.deprecated_function(
394
 
    symbol_versioning.deprecated_in((2, 5, 0)))(get_host_name)
 
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())
395
415
 
396
416
 
397
417
def _ensure_with_dir(path):
408
428
        return path
409
429
 
410
430
 
 
431
 
411
432
def glob_one(possible_glob):
412
433
    """Same as glob.glob().
413
434
 
448
469
 
449
470
 
450
471
def get_app_path(appname):
451
 
    r"""Look up in Windows registry for full path to application executable.
 
472
    """Look up in Windows registry for full path to application executable.
452
473
    Typically, applications create subkey with their basename
453
474
    in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
454
475
 
502
523
            trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
503
524
 
504
525
 
505
 
def _command_line_to_argv(command_line, argv, single_quotes_allowed=False):
 
526
def _command_line_to_argv(command_line, single_quotes_allowed=False):
506
527
    """Convert a Unicode command line into a list of argv arguments.
507
528
 
508
529
    It performs wildcard expansion to make wildcards act closer to how they
515
536
                                  default.
516
537
    :return: A list of unicode strings.
517
538
    """
518
 
    # First, split the command line
519
539
    s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
520
 
    
521
 
    # Bug #587868 Now make sure that the length of s agrees with sys.argv 
522
 
    # we do this by simply counting the number of arguments in each. The counts should 
523
 
    # agree no matter what encoding sys.argv is in (AFAIK) 
524
 
    # len(arguments) < len(sys.argv) should be an impossibility since python gets 
525
 
    # args from the very same PEB as does GetCommandLineW
526
 
    arguments = list(s)
527
 
    
528
 
    # Now shorten the command line we get from GetCommandLineW to match sys.argv
529
 
    if len(arguments) < len(argv):
530
 
        raise AssertionError("Split command line can't be shorter than argv")
531
 
    arguments = arguments[len(arguments) - len(argv):]
532
 
    
533
 
    # Carry on to process globs (metachars) in the command line
534
 
    # expand globs if necessary
 
540
    # Now that we've split the content, expand globs if necessary
535
541
    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
536
542
    #       '**/' style globs
537
543
    args = []
538
 
    for is_quoted, arg in arguments:
 
544
    for is_quoted, arg in s:
539
545
        if is_quoted or not glob.has_magic(arg):
540
546
            args.append(arg)
541
547
        else:
543
549
    return args
544
550
 
545
551
 
546
 
if has_ctypes and winver == 'Windows NT':
 
552
if has_ctypes and winver != 'Windows 98':
547
553
    def get_unicode_argv():
548
554
        prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
549
555
        GetCommandLineW = prototype(("GetCommandLineW",
552
558
        if command_line is None:
553
559
            raise ctypes.WinError()
554
560
        # Skip the first argument, since we only care about parameters
555
 
        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:]
556
572
        return argv
557
 
    
558
 
 
559
 
    def get_environ_unicode(key, default=None):
560
 
        """Get `key` from environment as unicode or `default` if unset
561
 
 
562
 
        The environment is natively unicode on modern windows versions but
563
 
        Python 2 only accesses it through the legacy bytestring api.
564
 
 
565
 
        Environmental variable names are case insenstive on Windows.
566
 
 
567
 
        A large enough buffer will be allocated to retrieve the value, though
568
 
        it may take two calls to the underlying library function.
569
 
 
570
 
        This needs ctypes because pywin32 does not expose the wide version.
571
 
        """
572
 
        cfunc = getattr(get_environ_unicode, "_c_function", None)
573
 
        if cfunc is None:
574
 
            from ctypes.wintypes import DWORD, LPCWSTR, LPWSTR
575
 
            cfunc = ctypes.WINFUNCTYPE(DWORD, LPCWSTR, LPWSTR, DWORD)(
576
 
                ("GetEnvironmentVariableW", ctypes.windll.kernel32))
577
 
            get_environ_unicode._c_function = cfunc
578
 
        buffer_size = 256 # heuristic, 256 characters often enough
579
 
        while True:
580
 
            buffer = ctypes.create_unicode_buffer(buffer_size)
581
 
            length = cfunc(key, buffer, buffer_size)
582
 
            if not length:
583
 
                code = ctypes.GetLastError()
584
 
                if code == 203: # ERROR_ENVVAR_NOT_FOUND
585
 
                    return default
586
 
                raise ctypes.WinError(code)
587
 
            if buffer_size > length:
588
 
                return buffer[:length]
589
 
            buffer_size = length
590
573
else:
591
574
    get_unicode_argv = None
592
 
    def get_environ_unicode(key, default=None):
593
 
        """Get `key` from environment as unicode or `default` if unset
594
 
 
595
 
        Fallback version that should basically never be needed.
596
 
        """
597
 
        from bzrlib import osutils
598
 
        try:
599
 
            return os.environ[key].decode(osutils.get_user_encoding())
600
 
        except KeyError:
601
 
            return default
602
 
 
603
 
 
604
 
if has_win32api:
605
 
    def _pywin32_is_local_pid_dead(pid):
606
 
        """True if pid doesn't correspond to live process on this machine"""
607
 
        try:
608
 
            handle = win32api.OpenProcess(1, False, pid) # PROCESS_TERMINATE
609
 
        except pywintypes.error, e:
610
 
            if e[0] == 5: # ERROR_ACCESS_DENIED
611
 
                # Probably something alive we're not allowed to kill
612
 
                return False
613
 
            elif e[0] == 87: # ERROR_INVALID_PARAMETER
614
 
                return True
615
 
            raise
616
 
        handle.close()
617
 
        return False
618
 
    is_local_pid_dead = _pywin32_is_local_pid_dead
619
 
elif has_ctypes and sys.platform == 'win32':
620
 
    from ctypes.wintypes import BOOL, DWORD, HANDLE
621
 
    _kernel32 = ctypes.windll.kernel32
622
 
    _CloseHandle = ctypes.WINFUNCTYPE(BOOL, HANDLE)(
623
 
        ("CloseHandle", _kernel32))
624
 
    _OpenProcess = ctypes.WINFUNCTYPE(HANDLE, DWORD, BOOL, DWORD)(
625
 
        ("OpenProcess", _kernel32))
626
 
    def _ctypes_is_local_pid_dead(pid):
627
 
        """True if pid doesn't correspond to live process on this machine"""
628
 
        handle = _OpenProcess(1, False, pid) # PROCESS_TERMINATE
629
 
        if not handle:
630
 
            errorcode = ctypes.GetLastError()
631
 
            if errorcode == 5: # ERROR_ACCESS_DENIED
632
 
                # Probably something alive we're not allowed to kill
633
 
                return False
634
 
            elif errorcode == 87: # ERROR_INVALID_PARAMETER
635
 
                return True
636
 
            raise ctypes.WinError(errorcode)
637
 
        _CloseHandle(handle)
638
 
        return False
639
 
    is_local_pid_dead = _ctypes_is_local_pid_dead
640
 
 
641
 
 
642
 
def _is_pywintypes_error(evalue):
643
 
    """True if exception instance is an error from pywin32"""
644
 
    if has_pywintypes and isinstance(evalue, pywintypes.error):
645
 
        return True
646
 
    return False