← 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-18 09:13:28 UTC
  • mfrom: (5096.1.1 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20100318091328-8fo347hq4at1usky
(vila) Get better feedback about why
        TestGetFileMTime.test_get_file_mtime is failing

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
 
24
import re
23
25
import struct
24
26
import sys
25
27
 
 
28
from bzrlib import cmdline
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
75
79
except ImportError:
76
80
    has_win32api = False
77
81
 
 
82
# pulling in win32com.shell is a bit of overhead, and normally we don't need
 
83
# it as ctypes is preferred and common.  lazy_imports and "optional"
 
84
# modules don't work well, so we do our own lazy thing...
 
85
has_win32com_shell = None # Set to True or False once we know for sure...
78
86
 
79
87
# Special Win32 API constants
80
88
# Handles of std streams
84
92
 
85
93
# CSIDL constants (from MSDN 2003)
86
94
CSIDL_APPDATA = 0x001A      # Application Data folder
 
95
CSIDL_LOCAL_APPDATA = 0x001c# <user name>\Local Settings\Application Data (non roaming)
87
96
CSIDL_PERSONAL = 0x0005     # My Documents folder
88
97
 
89
98
# from winapi C headers
91
100
UNLEN = 256
92
101
MAX_COMPUTERNAME_LENGTH = 31
93
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('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('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('WorkingSize %7dKiB'
 
159
                   '\tPeakWorking %7dKiB\t%s',
 
160
                   info['WorkingSetSize'] / 1024,
 
161
                   info['PeakWorkingSetSize'] / 1024,
 
162
                   message)
 
163
        return
 
164
    if message:
 
165
        trace.note('%s', message)
 
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',
 
170
               info.get('PeakPagefileUsage', 0) / 1024)
 
171
    trace.note('PrivateUsage      %8d KiB', info.get('PrivateUsage', 0) / 1024)
 
172
    trace.note('PageFaultCount    %8d', info.get('PageFaultCount', 0))
 
173
 
94
174
 
95
175
def get_console_size(defaultx=80, defaulty=25):
96
176
    """Return size of current console.
104
184
        return (defaultx, defaulty)
105
185
 
106
186
    # To avoid problem with redirecting output via pipe
107
 
    # need to use stderr instead of stdout
 
187
    # we need to use stderr instead of stdout
108
188
    h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
109
189
    csbi = ctypes.create_string_buffer(22)
110
190
    res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
111
191
 
112
192
    if res:
113
193
        (bufx, bufy, curx, cury, wattr,
114
 
        left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
 
194
        left, top, right, bottom, maxx, maxy) = struct.unpack(
 
195
            "hhhhHhhhhhh", csbi.raw)
115
196
        sizex = right - left + 1
116
197
        sizey = bottom - top + 1
117
198
        return (sizex, sizey)
119
200
        return (defaultx, defaulty)
120
201
 
121
202
 
 
203
def _get_sh_special_folder_path(csidl):
 
204
    """Call SHGetSpecialFolderPathW if available, or return None.
 
205
 
 
206
    Result is always unicode (or None).
 
207
    """
 
208
    if has_ctypes:
 
209
        try:
 
210
            SHGetSpecialFolderPath = \
 
211
                ctypes.windll.shell32.SHGetSpecialFolderPathW
 
212
        except AttributeError:
 
213
            pass
 
214
        else:
 
215
            buf = ctypes.create_unicode_buffer(MAX_PATH)
 
216
            if SHGetSpecialFolderPath(None,buf,csidl,0):
 
217
                return buf.value
 
218
 
 
219
    global has_win32com_shell
 
220
    if has_win32com_shell is None:
 
221
        try:
 
222
            from win32com.shell import shell
 
223
            has_win32com_shell = True
 
224
        except ImportError:
 
225
            has_win32com_shell = False
 
226
    if has_win32com_shell:
 
227
        # still need to bind the name locally, but this is fast.
 
228
        from win32com.shell import shell
 
229
        try:
 
230
            return shell.SHGetSpecialFolderPath(0, csidl, 0)
 
231
        except shell.error:
 
232
            # possibly E_NOTIMPL meaning we can't load the function pointer,
 
233
            # or E_FAIL meaning the function failed - regardless, just ignore it
 
234
            pass
 
235
    return None
 
236
 
 
237
 
122
238
def get_appdata_location():
123
239
    """Return Application Data location.
124
240
    Return None if we cannot obtain location.
125
241
 
126
 
    Returned value can be unicode or plain sring.
 
242
    Windows defines two 'Application Data' folders per user - a 'roaming'
 
243
    one that moves with the user as they logon to different machines, and
 
244
    a 'local' one that stays local to the machine.  This returns the 'roaming'
 
245
    directory, and thus is suitable for storing user-preferences, etc.
 
246
 
 
247
    Returned value can be unicode or plain string.
127
248
    To convert plain string to unicode use
128
 
    s.decode(bzrlib.user_encoding)
 
249
    s.decode(osutils.get_user_encoding())
 
250
    (XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
129
251
    """
130
 
    if has_ctypes:
131
 
        try:
132
 
            SHGetSpecialFolderPath = \
133
 
                ctypes.windll.shell32.SHGetSpecialFolderPathW
134
 
        except AttributeError:
135
 
            pass
136
 
        else:
137
 
            buf = ctypes.create_unicode_buffer(MAX_PATH)
138
 
            if SHGetSpecialFolderPath(None,buf,CSIDL_APPDATA,0):
139
 
                return buf.value
 
252
    appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
 
253
    if appdata:
 
254
        return appdata
140
255
    # from env variable
141
256
    appdata = os.environ.get('APPDATA')
142
257
    if appdata:
152
267
    return None
153
268
 
154
269
 
 
270
def get_local_appdata_location():
 
271
    """Return Local Application Data location.
 
272
    Return the same as get_appdata_location() if we cannot obtain location.
 
273
 
 
274
    Windows defines two 'Application Data' folders per user - a 'roaming'
 
275
    one that moves with the user as they logon to different machines, and
 
276
    a 'local' one that stays local to the machine.  This returns the 'local'
 
277
    directory, and thus is suitable for caches, temp files and other things
 
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')
 
284
    """
 
285
    local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
 
286
    if local:
 
287
        return local
 
288
    # Vista supplies LOCALAPPDATA, but XP and earlier do not.
 
289
    local = os.environ.get('LOCALAPPDATA')
 
290
    if local:
 
291
        return local
 
292
    return get_appdata_location()
 
293
 
 
294
 
155
295
def get_home_location():
156
296
    """Return user's home location.
157
297
    Assume on win32 it's the <My Documents> folder.
158
298
    If location cannot be obtained return system drive root,
159
299
    i.e. C:\
160
300
 
161
 
    Returned value can be unicode or plain sring.
 
301
    Returned value can be unicode or plain string.
162
302
    To convert plain string to unicode use
163
 
    s.decode(bzrlib.user_encoding)
 
303
    s.decode(osutils.get_user_encoding())
164
304
    """
165
 
    if has_ctypes:
166
 
        try:
167
 
            SHGetSpecialFolderPath = \
168
 
                ctypes.windll.shell32.SHGetSpecialFolderPathW
169
 
        except AttributeError:
170
 
            pass
171
 
        else:
172
 
            buf = ctypes.create_unicode_buffer(MAX_PATH)
173
 
            if SHGetSpecialFolderPath(None,buf,CSIDL_PERSONAL,0):
174
 
                return buf.value
 
305
    home = _get_sh_special_folder_path(CSIDL_PERSONAL)
 
306
    if home:
 
307
        return home
175
308
    # try for HOME env variable
176
309
    home = os.path.expanduser('~')
177
310
    if home != '~':
188
321
    """Return user name as login name.
189
322
    If name cannot be obtained return None.
190
323
 
191
 
    Returned value can be unicode or plain sring.
 
324
    Returned value can be unicode or plain string.
192
325
    To convert plain string to unicode use
193
 
    s.decode(bzrlib.user_encoding)
 
326
    s.decode(osutils.get_user_encoding())
194
327
    """
195
328
    if has_ctypes:
196
329
        try:
263
396
 
264
397
def _ensure_unicode(s):
265
398
    if s and type(s) != unicode:
266
 
        import bzrlib
267
 
        s = s.decode(bzrlib.user_encoding)
 
399
        from bzrlib import osutils
 
400
        s = s.decode(osutils.get_user_encoding())
268
401
    return s
269
402
 
270
403
 
282
415
 
283
416
 
284
417
def _ensure_with_dir(path):
285
 
    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'?')):
286
420
        return u'./' + path, True
287
421
    else:
288
422
        return path, False
289
 
    
 
423
 
290
424
def _undo_ensure_with_dir(path, corrected):
291
425
    if corrected:
292
426
        return path[2:]
295
429
 
296
430
 
297
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
 
298
452
def glob_expand(file_list):
299
453
    """Replacement for glob expansion by the shell.
300
454
 
308
462
    """
309
463
    if not file_list:
310
464
        return []
311
 
    import glob
312
465
    expanded_file_list = []
313
466
    for possible_glob in file_list:
314
 
        
315
 
        # work around bugs in glob.glob()
316
 
        # - Python bug #1001604 ("glob doesn't return unicode with ...")
317
 
        # - failing expansion for */* with non-iso-8859-* chars
318
 
        possible_glob, corrected = _ensure_with_dir(possible_glob)
319
 
        glob_files = glob.glob(possible_glob)
320
 
 
321
 
        if glob_files == []:
322
 
            # special case to let the normal code path handle
323
 
            # files that do not exists
324
 
            expanded_file_list.append(
325
 
                _undo_ensure_with_dir(possible_glob, corrected))
326
 
        else:
327
 
            glob_files = [_undo_ensure_with_dir(elem, corrected) for elem in glob_files]
328
 
            expanded_file_list += glob_files
329
 
            
330
 
    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
331
469
 
332
470
 
333
471
def get_app_path(appname):
334
472
    """Look up in Windows registry for full path to application executable.
335
 
    Typicaly, applications create subkey with their basename
 
473
    Typically, applications create subkey with their basename
336
474
    in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
337
475
 
338
476
    :param  appname:    name of application (if no filename extension
341
479
                or appname itself if nothing found.
342
480
    """
343
481
    import _winreg
 
482
 
 
483
    basename = appname
 
484
    if not os.path.splitext(basename)[1]:
 
485
        basename = appname + '.exe'
 
486
 
344
487
    try:
345
488
        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
346
 
                               r'SOFTWARE\Microsoft\Windows'
347
 
                               r'\CurrentVersion\App Paths')
 
489
            'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
 
490
            basename)
348
491
    except EnvironmentError:
349
492
        return appname
350
493
 
351
 
    basename = appname
352
 
    if not os.path.splitext(basename)[1]:
353
 
        basename = appname + '.exe'
354
494
    try:
355
495
        try:
356
 
            fullpath = _winreg.QueryValue(hkey, basename)
 
496
            path, type_id = _winreg.QueryValueEx(hkey, '')
357
497
        except WindowsError:
358
 
            fullpath = appname
 
498
            return appname
359
499
    finally:
360
500
        _winreg.CloseKey(hkey)
361
501
 
362
 
    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
363
510
 
364
511
 
365
512
def set_file_attr_hidden(path):
366
513
    """Set file attributes to hidden if possible"""
367
514
    if has_win32file:
368
 
        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, 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
    s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
 
540
    # Now that we've split the content, expand globs if necessary
 
541
    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
 
542
    #       '**/' style globs
 
543
    args = []
 
544
    for is_quoted, arg in s:
 
545
        if is_quoted or not glob.has_magic(arg):
 
546
            args.append(arg)
 
547
        else:
 
548
            args.extend(glob_one(arg))
 
549
    return args
 
550
 
 
551
 
 
552
if has_ctypes and winver != 'Windows 98':
 
553
    def get_unicode_argv():
 
554
        prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
 
555
        GetCommandLineW = prototype(("GetCommandLineW",
 
556
                                     ctypes.windll.kernel32))
 
557
        command_line = GetCommandLineW()
 
558
        if command_line is None:
 
559
            raise ctypes.WinError()
 
560
        # Skip the first argument, since we only care about parameters
 
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:]
 
572
        return argv
 
573
else:
 
574
    get_unicode_argv = None