← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

  • Committer: Aaron Bentley
  • Date: 2007-03-07 23:15:10 UTC
  • mto: (1551.19.24 Aaron's mergeable stuff)
  • mto: This revision was merged to the branch mainline in revision 2325.
  • Revision ID: abentley@panoramicfeedback.com-20070307231510-jae63zsli83db3eb
Make ChangeReporter private

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