← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

  • Committer: Robert Collins
  • Date: 2009-07-07 04:32:13 UTC
  • mto: This revision was merged to the branch mainline in revision 4524.
  • Revision ID: robertc@robertcollins.net-20090707043213-4hjjhgr40iq7gk2d
More informative assertions in xml serialisation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/win32utils.py
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
 
64
64
    else:
65
65
        create_buffer = ctypes.create_unicode_buffer
66
66
        suffix = 'W'
 
67
try:
 
68
    import win32file
 
69
    has_win32file = True
 
70
except ImportError:
 
71
    has_win32file = False
 
72
try:
 
73
    import win32api
 
74
    has_win32api = True
 
75
except ImportError:
 
76
    has_win32api = False
67
77
 
 
78
# pulling in win32com.shell is a bit of overhead, and normally we don't need
 
79
# it as ctypes is preferred and common.  lazy_imports and "optional"
 
80
# modules don't work well, so we do our own lazy thing...
 
81
has_win32com_shell = None # Set to True or False once we know for sure...
68
82
 
69
83
# Special Win32 API constants
70
84
# Handles of std streams
74
88
 
75
89
# CSIDL constants (from MSDN 2003)
76
90
CSIDL_APPDATA = 0x001A      # Application Data folder
 
91
CSIDL_LOCAL_APPDATA = 0x001c# <user name>\Local Settings\Application Data (non roaming)
77
92
CSIDL_PERSONAL = 0x0005     # My Documents folder
78
93
 
79
94
# from winapi C headers
81
96
UNLEN = 256
82
97
MAX_COMPUTERNAME_LENGTH = 31
83
98
 
 
99
# Registry data type ids
 
100
REG_SZ = 1
 
101
REG_EXPAND_SZ = 2
 
102
 
 
103
 
 
104
def debug_memory_win32api(message='', short=True):
 
105
    """Use trace.note() to dump the running memory info."""
 
106
    from bzrlib import trace
 
107
    if has_ctypes:
 
108
        class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
 
109
            """Used by GetProcessMemoryInfo"""
 
110
            _fields_ = [('cb', ctypes.c_ulong),
 
111
                        ('PageFaultCount', ctypes.c_ulong),
 
112
                        ('PeakWorkingSetSize', ctypes.c_size_t),
 
113
                        ('WorkingSetSize', ctypes.c_size_t),
 
114
                        ('QuotaPeakPagedPoolUsage', ctypes.c_size_t),
 
115
                        ('QuotaPagedPoolUsage', ctypes.c_size_t),
 
116
                        ('QuotaPeakNonPagedPoolUsage', ctypes.c_size_t),
 
117
                        ('QuotaNonPagedPoolUsage', ctypes.c_size_t),
 
118
                        ('PagefileUsage', ctypes.c_size_t),
 
119
                        ('PeakPagefileUsage', ctypes.c_size_t),
 
120
                        ('PrivateUsage', ctypes.c_size_t),
 
121
                       ]
 
122
        cur_process = ctypes.windll.kernel32.GetCurrentProcess()
 
123
        mem_struct = PROCESS_MEMORY_COUNTERS_EX()
 
124
        ret = ctypes.windll.psapi.GetProcessMemoryInfo(cur_process,
 
125
            ctypes.byref(mem_struct),
 
126
            ctypes.sizeof(mem_struct))
 
127
        if not ret:
 
128
            trace.note('Failed to GetProcessMemoryInfo()')
 
129
            return
 
130
        info = {'PageFaultCount': mem_struct.PageFaultCount,
 
131
                'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
 
132
                'WorkingSetSize': mem_struct.WorkingSetSize,
 
133
                'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
 
134
                'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
 
135
                'QuotaPeakNonPagedPoolUsage': mem_struct.QuotaPeakNonPagedPoolUsage,
 
136
                'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
 
137
                'PagefileUsage': mem_struct.PagefileUsage,
 
138
                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
 
139
                'PrivateUsage': mem_struct.PrivateUsage,
 
140
               }
 
141
    elif has_win32api:
 
142
        import win32process
 
143
        # win32process does not return PrivateUsage, because it doesn't use
 
144
        # PROCESS_MEMORY_COUNTERS_EX (it uses the one without _EX).
 
145
        proc = win32process.GetCurrentProcess()
 
146
        info = win32process.GetProcessMemoryInfo(proc)
 
147
    else:
 
148
        trace.note('Cannot debug memory on win32 without ctypes'
 
149
                   ' or win32process')
 
150
        return
 
151
    if short:
 
152
        trace.note('WorkingSize %7dKB'
 
153
                   '\tPeakWorking %7dKB\t%s',
 
154
                   info['WorkingSetSize'] / 1024,
 
155
                   info['PeakWorkingSetSize'] / 1024,
 
156
                   message)
 
157
        return
 
158
    if message:
 
159
        trace.note('%s', message)
 
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)
 
165
    trace.note('PageFaultCount    %8d', info.get('PageFaultCount', 0))
 
166
 
84
167
 
85
168
def get_console_size(defaultx=80, defaulty=25):
86
169
    """Return size of current console.
109
192
        return (defaultx, defaulty)
110
193
 
111
194
 
 
195
def _get_sh_special_folder_path(csidl):
 
196
    """Call SHGetSpecialFolderPathW if available, or return None.
 
197
 
 
198
    Result is always unicode (or None).
 
199
    """
 
200
    if has_ctypes:
 
201
        try:
 
202
            SHGetSpecialFolderPath = \
 
203
                ctypes.windll.shell32.SHGetSpecialFolderPathW
 
204
        except AttributeError:
 
205
            pass
 
206
        else:
 
207
            buf = ctypes.create_unicode_buffer(MAX_PATH)
 
208
            if SHGetSpecialFolderPath(None,buf,csidl,0):
 
209
                return buf.value
 
210
 
 
211
    global has_win32com_shell
 
212
    if has_win32com_shell is None:
 
213
        try:
 
214
            from win32com.shell import shell
 
215
            has_win32com_shell = True
 
216
        except ImportError:
 
217
            has_win32com_shell = False
 
218
    if has_win32com_shell:
 
219
        # still need to bind the name locally, but this is fast.
 
220
        from win32com.shell import shell
 
221
        try:
 
222
            return shell.SHGetSpecialFolderPath(0, csidl, 0)
 
223
        except shell.error:
 
224
            # possibly E_NOTIMPL meaning we can't load the function pointer,
 
225
            # or E_FAIL meaning the function failed - regardless, just ignore it
 
226
            pass
 
227
    return None
 
228
 
 
229
 
112
230
def get_appdata_location():
113
231
    """Return Application Data location.
114
232
    Return None if we cannot obtain location.
115
233
 
116
 
    Returned value can be unicode or plain sring.
 
234
    Windows defines two 'Application Data' folders per user - a 'roaming'
 
235
    one that moves with the user as they logon to different machines, and
 
236
    a 'local' one that stays local to the machine.  This returns the 'roaming'
 
237
    directory, and thus is suitable for storing user-preferences, etc.
 
238
 
 
239
    Returned value can be unicode or plain string.
117
240
    To convert plain string to unicode use
118
 
    s.decode(bzrlib.user_encoding)
 
241
    s.decode(osutils.get_user_encoding())
 
242
    (XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
119
243
    """
120
 
    if has_ctypes:
121
 
        try:
122
 
            SHGetSpecialFolderPath = \
123
 
                ctypes.windll.shell32.SHGetSpecialFolderPathW
124
 
        except AttributeError:
125
 
            pass
126
 
        else:
127
 
            buf = ctypes.create_unicode_buffer(MAX_PATH)
128
 
            if SHGetSpecialFolderPath(None,buf,CSIDL_APPDATA,0):
129
 
                return buf.value
 
244
    appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
 
245
    if appdata:
 
246
        return appdata
130
247
    # from env variable
131
248
    appdata = os.environ.get('APPDATA')
132
249
    if appdata:
142
259
    return None
143
260
 
144
261
 
 
262
def get_local_appdata_location():
 
263
    """Return Local Application Data location.
 
264
    Return the same as get_appdata_location() if we cannot obtain location.
 
265
 
 
266
    Windows defines two 'Application Data' folders per user - a 'roaming'
 
267
    one that moves with the user as they logon to different machines, and
 
268
    a 'local' one that stays local to the machine.  This returns the 'local'
 
269
    directory, and thus is suitable for caches, temp files and other things
 
270
    which don't need to move with the user.
 
271
 
 
272
    Returned value can be unicode or plain string.
 
273
    To convert plain string to unicode use
 
274
    s.decode(osutils.get_user_encoding())
 
275
    (XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
 
276
    """
 
277
    local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
 
278
    if local:
 
279
        return local
 
280
    # Vista supplies LOCALAPPDATA, but XP and earlier do not.
 
281
    local = os.environ.get('LOCALAPPDATA')
 
282
    if local:
 
283
        return local
 
284
    return get_appdata_location()
 
285
 
 
286
 
145
287
def get_home_location():
146
288
    """Return user's home location.
147
289
    Assume on win32 it's the <My Documents> folder.
148
290
    If location cannot be obtained return system drive root,
149
291
    i.e. C:\
150
292
 
151
 
    Returned value can be unicode or plain sring.
 
293
    Returned value can be unicode or plain string.
152
294
    To convert plain string to unicode use
153
 
    s.decode(bzrlib.user_encoding)
 
295
    s.decode(osutils.get_user_encoding())
154
296
    """
155
 
    if has_ctypes:
156
 
        try:
157
 
            SHGetSpecialFolderPath = \
158
 
                ctypes.windll.shell32.SHGetSpecialFolderPathW
159
 
        except AttributeError:
160
 
            pass
161
 
        else:
162
 
            buf = ctypes.create_unicode_buffer(MAX_PATH)
163
 
            if SHGetSpecialFolderPath(None,buf,CSIDL_PERSONAL,0):
164
 
                return buf.value
 
297
    home = _get_sh_special_folder_path(CSIDL_PERSONAL)
 
298
    if home:
 
299
        return home
165
300
    # try for HOME env variable
166
301
    home = os.path.expanduser('~')
167
302
    if home != '~':
178
313
    """Return user name as login name.
179
314
    If name cannot be obtained return None.
180
315
 
181
 
    Returned value can be unicode or plain sring.
 
316
    Returned value can be unicode or plain string.
182
317
    To convert plain string to unicode use
183
 
    s.decode(bzrlib.user_encoding)
 
318
    s.decode(osutils.get_user_encoding())
184
319
    """
185
320
    if has_ctypes:
186
321
        try:
197
332
    return os.environ.get('USERNAME', None)
198
333
 
199
334
 
 
335
# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local
 
336
# computer or the cluster associated with the local computer."
 
337
_WIN32_ComputerNameDnsHostname = 1
 
338
 
200
339
def get_host_name():
201
340
    """Return host machine name.
202
341
    If name cannot be obtained return None.
203
342
 
204
 
    Returned value can be unicode or plain sring.
205
 
    To convert plain string to unicode use
206
 
    s.decode(bzrlib.user_encoding)
 
343
    :return: A unicode string representing the host name. On win98, this may be
 
344
        a plain string as win32 api doesn't support unicode.
207
345
    """
 
346
    if has_win32api:
 
347
        try:
 
348
            return win32api.GetComputerNameEx(_WIN32_ComputerNameDnsHostname)
 
349
        except (NotImplementedError, win32api.error):
 
350
            # NotImplemented will happen on win9x...
 
351
            pass
208
352
    if has_ctypes:
209
353
        try:
210
354
            kernel32 = ctypes.windll.kernel32
211
 
            GetComputerName = getattr(kernel32, 'GetComputerName'+suffix)
212
355
        except AttributeError:
213
 
            pass
 
356
            pass # Missing the module we need
214
357
        else:
215
358
            buf = create_buffer(MAX_COMPUTERNAME_LENGTH+1)
216
359
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
217
 
            if GetComputerName(buf, ctypes.byref(n)):
218
 
                return buf.value
219
 
    # otherwise try env variables
220
 
    return os.environ.get('COMPUTERNAME', None)
 
360
 
 
361
            # Try GetComputerNameEx which gives a proper Unicode hostname
 
362
            GetComputerNameEx = getattr(kernel32, 'GetComputerNameEx'+suffix,
 
363
                                        None)
 
364
            if (GetComputerNameEx is not None
 
365
                and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,
 
366
                                      buf, ctypes.byref(n))):
 
367
                return buf.value
 
368
 
 
369
            # Try GetComputerName in case GetComputerNameEx wasn't found
 
370
            # It returns the NETBIOS name, which isn't as good, but still ok.
 
371
            # The first GetComputerNameEx might have changed 'n', so reset it
 
372
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
 
373
            GetComputerName = getattr(kernel32, 'GetComputerName'+suffix,
 
374
                                      None)
 
375
            if (GetComputerName is not None
 
376
                and GetComputerName(buf, ctypes.byref(n))):
 
377
                return buf.value
 
378
    # otherwise try env variables, which will be 'mbcs' encoded
 
379
    # on Windows (Python doesn't expose the native win32 unicode environment)
 
380
    # According to this:
 
381
    # http://msdn.microsoft.com/en-us/library/aa246807.aspx
 
382
    # environment variables should always be encoded in 'mbcs'.
 
383
    try:
 
384
        return os.environ['COMPUTERNAME'].decode("mbcs")
 
385
    except KeyError:
 
386
        return None
221
387
 
222
388
 
223
389
def _ensure_unicode(s):
 
390
    from bzrlib import osutils
224
391
    if s and type(s) != unicode:
225
 
        import bzrlib
226
 
        s = s.decode(bzrlib.user_encoding)
 
392
        from bzrlib import osutils
 
393
        s = s.decode(osutils.get_user_encoding())
227
394
    return s
228
 
    
 
395
 
229
396
 
230
397
def get_appdata_location_unicode():
231
398
    return _ensure_unicode(get_appdata_location())
240
407
    return _ensure_unicode(get_host_name())
241
408
 
242
409
 
 
410
def _ensure_with_dir(path):
 
411
    if not os.path.split(path)[0] or path.startswith(u'*') or path.startswith(u'?'):
 
412
        return u'./' + path, True
 
413
    else:
 
414
        return path, False
 
415
 
 
416
def _undo_ensure_with_dir(path, corrected):
 
417
    if corrected:
 
418
        return path[2:]
 
419
    else:
 
420
        return path
 
421
 
 
422
 
 
423
 
243
424
def glob_expand(file_list):
244
425
    """Replacement for glob expansion by the shell.
245
426
 
256
437
    import glob
257
438
    expanded_file_list = []
258
439
    for possible_glob in 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)
259
444
        glob_files = glob.glob(possible_glob)
260
445
 
261
446
        if glob_files == []:
262
447
            # special case to let the normal code path handle
263
448
            # files that do not exists
264
 
            expanded_file_list.append(possible_glob)
 
449
            expanded_file_list.append(
 
450
                _undo_ensure_with_dir(possible_glob, corrected))
265
451
        else:
 
452
            glob_files = [_undo_ensure_with_dir(elem, corrected) for elem in glob_files]
266
453
            expanded_file_list += glob_files
267
 
    return expanded_file_list
268
 
 
269
 
 
 
454
 
 
455
    return [elem.replace(u'\\', u'/') for elem in expanded_file_list]
 
456
 
 
457
 
 
458
def get_app_path(appname):
 
459
    """Look up in Windows registry for full path to application executable.
 
460
    Typically, applications create subkey with their basename
 
461
    in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
 
462
 
 
463
    :param  appname:    name of application (if no filename extension
 
464
                        is specified, .exe used)
 
465
    :return:    full path to aplication executable from registry,
 
466
                or appname itself if nothing found.
 
467
    """
 
468
    import _winreg
 
469
 
 
470
    basename = appname
 
471
    if not os.path.splitext(basename)[1]:
 
472
        basename = appname + '.exe'
 
473
 
 
474
    try:
 
475
        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
 
476
            'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
 
477
            basename)
 
478
    except EnvironmentError:
 
479
        return appname
 
480
 
 
481
    try:
 
482
        try:
 
483
            path, type_id = _winreg.QueryValueEx(hkey, '')
 
484
        except WindowsError:
 
485
            return appname
 
486
    finally:
 
487
        _winreg.CloseKey(hkey)
 
488
 
 
489
    if type_id == REG_SZ:
 
490
        return path
 
491
    if type_id == REG_EXPAND_SZ and has_win32api:
 
492
        fullpath = win32api.ExpandEnvironmentStrings(path)
 
493
        if len(fullpath) > 1 and fullpath[0] == '"' and fullpath[-1] == '"':
 
494
            fullpath = fullpath[1:-1]   # remove quotes around value
 
495
        return fullpath
 
496
    return appname
 
497
 
 
498
 
 
499
def set_file_attr_hidden(path):
 
500
    """Set file attributes to hidden if possible"""
 
501
    if has_win32file:
 
502
        win32file.SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
 
503
 
 
504
 
 
505
if has_ctypes and winver != 'Windows 98':
 
506
    def get_unicode_argv():
 
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))
 
518
        # Skip the first argument, since we only care about parameters
 
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:]
 
529
        return argv
 
530
else:
 
531
    get_unicode_argv = None