← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

  • Committer: John Arbash Meinel
  • Date: 2008-09-05 02:29:34 UTC
  • mto: (3697.7.4 1.7)
  • mto: This revision was merged to the branch mainline in revision 3748.
  • Revision ID: john@arbash-meinel.com-20080905022934-s8692mbwpkdwi106
Cleanups to the algorithm documentation.

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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Win32-specific helper functions
18
18
 
66
66
        suffix = 'W'
67
67
try:
68
68
    import win32file
69
 
    import pywintypes
70
69
    has_win32file = True
71
70
except ImportError:
72
71
    has_win32file = False
73
 
try:
74
 
    import win32api
75
 
    has_win32api = True
76
 
except ImportError:
77
 
    has_win32api = False
78
72
 
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...
83
73
 
84
74
# Special Win32 API constants
85
75
# Handles of std streams
89
79
 
90
80
# CSIDL constants (from MSDN 2003)
91
81
CSIDL_APPDATA = 0x001A      # Application Data folder
92
 
CSIDL_LOCAL_APPDATA = 0x001c# <user name>\Local Settings\Application Data (non roaming)
93
82
CSIDL_PERSONAL = 0x0005     # My Documents folder
94
83
 
95
84
# from winapi C headers
97
86
UNLEN = 256
98
87
MAX_COMPUTERNAME_LENGTH = 31
99
88
 
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
 
 
168
89
 
169
90
def get_console_size(defaultx=80, defaulty=25):
170
91
    """Return size of current console.
193
114
        return (defaultx, defaulty)
194
115
 
195
116
 
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
 
 
231
117
def get_appdata_location():
232
118
    """Return Application Data location.
233
119
    Return None if we cannot obtain location.
234
120
 
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.
 
121
    Returned value can be unicode or plain sring.
241
122
    To convert plain string to unicode use
242
 
    s.decode(osutils.get_user_encoding())
243
 
    (XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
 
123
    s.decode(bzrlib.user_encoding)
244
124
    """
245
 
    appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
246
 
    if appdata:
247
 
        return appdata
 
125
    if has_ctypes:
 
126
        try:
 
127
            SHGetSpecialFolderPath = \
 
128
                ctypes.windll.shell32.SHGetSpecialFolderPathW
 
129
        except AttributeError:
 
130
            pass
 
131
        else:
 
132
            buf = ctypes.create_unicode_buffer(MAX_PATH)
 
133
            if SHGetSpecialFolderPath(None,buf,CSIDL_APPDATA,0):
 
134
                return buf.value
248
135
    # from env variable
249
136
    appdata = os.environ.get('APPDATA')
250
137
    if appdata:
260
147
    return None
261
148
 
262
149
 
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
 
 
288
150
def get_home_location():
289
151
    """Return user's home location.
290
152
    Assume on win32 it's the <My Documents> folder.
291
153
    If location cannot be obtained return system drive root,
292
154
    i.e. C:\
293
155
 
294
 
    Returned value can be unicode or plain string.
 
156
    Returned value can be unicode or plain sring.
295
157
    To convert plain string to unicode use
296
 
    s.decode(osutils.get_user_encoding())
 
158
    s.decode(bzrlib.user_encoding)
297
159
    """
298
 
    home = _get_sh_special_folder_path(CSIDL_PERSONAL)
299
 
    if home:
300
 
        return home
 
160
    if has_ctypes:
 
161
        try:
 
162
            SHGetSpecialFolderPath = \
 
163
                ctypes.windll.shell32.SHGetSpecialFolderPathW
 
164
        except AttributeError:
 
165
            pass
 
166
        else:
 
167
            buf = ctypes.create_unicode_buffer(MAX_PATH)
 
168
            if SHGetSpecialFolderPath(None,buf,CSIDL_PERSONAL,0):
 
169
                return buf.value
301
170
    # try for HOME env variable
302
171
    home = os.path.expanduser('~')
303
172
    if home != '~':
314
183
    """Return user name as login name.
315
184
    If name cannot be obtained return None.
316
185
 
317
 
    Returned value can be unicode or plain string.
 
186
    Returned value can be unicode or plain sring.
318
187
    To convert plain string to unicode use
319
 
    s.decode(osutils.get_user_encoding())
 
188
    s.decode(bzrlib.user_encoding)
320
189
    """
321
190
    if has_ctypes:
322
191
        try:
333
202
    return os.environ.get('USERNAME', None)
334
203
 
335
204
 
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
 
 
340
205
def get_host_name():
341
206
    """Return host machine name.
342
207
    If name cannot be obtained return None.
343
208
 
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.
 
209
    Returned value can be unicode or plain sring.
 
210
    To convert plain string to unicode use
 
211
    s.decode(bzrlib.user_encoding)
346
212
    """
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
353
213
    if has_ctypes:
354
214
        try:
355
215
            kernel32 = ctypes.windll.kernel32
 
216
            GetComputerName = getattr(kernel32, 'GetComputerName'+suffix)
356
217
        except AttributeError:
357
 
            pass # Missing the module we need
 
218
            pass
358
219
        else:
359
220
            buf = create_buffer(MAX_COMPUTERNAME_LENGTH+1)
360
221
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
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
 
222
            if GetComputerName(buf, ctypes.byref(n)):
 
223
                return buf.value
 
224
    # otherwise try env variables
 
225
    return os.environ.get('COMPUTERNAME', None)
388
226
 
389
227
 
390
228
def _ensure_unicode(s):
391
 
    from bzrlib import osutils
392
229
    if s and type(s) != unicode:
393
 
        from bzrlib import osutils
394
 
        s = s.decode(osutils.get_user_encoding())
 
230
        import bzrlib
 
231
        s = s.decode(bzrlib.user_encoding)
395
232
    return s
396
 
 
 
233
    
397
234
 
398
235
def get_appdata_location_unicode():
399
236
    return _ensure_unicode(get_appdata_location())
413
250
        return u'./' + path, True
414
251
    else:
415
252
        return path, False
416
 
 
 
253
    
417
254
def _undo_ensure_with_dir(path, corrected):
418
255
    if corrected:
419
256
        return path[2:]
438
275
    import glob
439
276
    expanded_file_list = []
440
277
    for possible_glob in file_list:
 
278
        
441
279
        # work around bugs in glob.glob()
442
280
        # - Python bug #1001604 ("glob doesn't return unicode with ...")
443
281
        # - failing expansion for */* with non-iso-8859-* chars
452
290
        else:
453
291
            glob_files = [_undo_ensure_with_dir(elem, corrected) for elem in glob_files]
454
292
            expanded_file_list += glob_files
455
 
 
456
 
    return [elem.replace(u'\\', u'/') for elem in expanded_file_list]
 
293
            
 
294
    return [elem.replace(u'\\', u'/') for elem in expanded_file_list] 
457
295
 
458
296
 
459
297
def get_app_path(appname):
460
298
    """Look up in Windows registry for full path to application executable.
461
 
    Typically, applications create subkey with their basename
 
299
    Typicaly, applications create subkey with their basename
462
300
    in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
463
301
 
464
302
    :param  appname:    name of application (if no filename extension
467
305
                or appname itself if nothing found.
468
306
    """
469
307
    import _winreg
 
308
    try:
 
309
        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
 
310
                               r'SOFTWARE\Microsoft\Windows'
 
311
                               r'\CurrentVersion\App Paths')
 
312
    except EnvironmentError:
 
313
        return appname
470
314
 
471
315
    basename = appname
472
316
    if not os.path.splitext(basename)[1]:
473
317
        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
318
    try:
483
319
        try:
484
 
            path, type_id = _winreg.QueryValueEx(hkey, '')
 
320
            fullpath = _winreg.QueryValue(hkey, basename)
485
321
        except WindowsError:
486
 
            return appname
 
322
            fullpath = appname
487
323
    finally:
488
324
        _winreg.CloseKey(hkey)
489
325
 
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
 
326
    return fullpath
498
327
 
499
328
 
500
329
def set_file_attr_hidden(path):
501
330
    """Set file attributes to hidden if possible"""
502
331
    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
 
332
        win32file.SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)