← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

  • Committer: Danny van Heumen
  • Date: 2010-03-09 21:42:11 UTC
  • mto: (4634.139.5 2.0)
  • mto: This revision was merged to the branch mainline in revision 5160.
  • Revision ID: danny@dannyvanheumen.nl-20100309214211-iqh42x6qcikgd9p3
Reverted now-useless TODO list.

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