← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

  • Committer: Vincent Ladeuil
  • Date: 2009-06-22 12:52:39 UTC
  • mto: (4471.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 4472.
  • Revision ID: v.ladeuil+lp@free.fr-20090622125239-kabo9smxt9c3vnir
Use a consistent scheme for naming pyrex source files.

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
 
69
69
    has_win32file = True
70
70
except ImportError:
71
71
    has_win32file = False
 
72
try:
 
73
    import win32api
 
74
    has_win32api = True
 
75
except ImportError:
 
76
    has_win32api = False
72
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...
73
82
 
74
83
# Special Win32 API constants
75
84
# Handles of std streams
79
88
 
80
89
# CSIDL constants (from MSDN 2003)
81
90
CSIDL_APPDATA = 0x001A      # Application Data folder
 
91
CSIDL_LOCAL_APPDATA = 0x001c# <user name>\Local Settings\Application Data (non roaming)
82
92
CSIDL_PERSONAL = 0x0005     # My Documents folder
83
93
 
84
94
# from winapi C headers
87
97
MAX_COMPUTERNAME_LENGTH = 31
88
98
 
89
99
 
 
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
 
90
164
def get_console_size(defaultx=80, defaulty=25):
91
165
    """Return size of current console.
92
166
 
114
188
        return (defaultx, defaulty)
115
189
 
116
190
 
 
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
 
117
226
def get_appdata_location():
118
227
    """Return Application Data location.
119
228
    Return None if we cannot obtain location.
120
229
 
121
 
    Returned value can be unicode or plain sring.
 
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.
122
236
    To convert plain string to unicode use
123
 
    s.decode(bzrlib.user_encoding)
 
237
    s.decode(osutils.get_user_encoding())
 
238
    (XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
124
239
    """
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
 
240
    appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
 
241
    if appdata:
 
242
        return appdata
135
243
    # from env variable
136
244
    appdata = os.environ.get('APPDATA')
137
245
    if appdata:
147
255
    return None
148
256
 
149
257
 
 
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(osutils.get_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
 
150
283
def get_home_location():
151
284
    """Return user's home location.
152
285
    Assume on win32 it's the <My Documents> folder.
153
286
    If location cannot be obtained return system drive root,
154
287
    i.e. C:\
155
288
 
156
 
    Returned value can be unicode or plain sring.
 
289
    Returned value can be unicode or plain string.
157
290
    To convert plain string to unicode use
158
 
    s.decode(bzrlib.user_encoding)
 
291
    s.decode(osutils.get_user_encoding())
159
292
    """
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
 
293
    home = _get_sh_special_folder_path(CSIDL_PERSONAL)
 
294
    if home:
 
295
        return home
170
296
    # try for HOME env variable
171
297
    home = os.path.expanduser('~')
172
298
    if home != '~':
183
309
    """Return user name as login name.
184
310
    If name cannot be obtained return None.
185
311
 
186
 
    Returned value can be unicode or plain sring.
 
312
    Returned value can be unicode or plain string.
187
313
    To convert plain string to unicode use
188
 
    s.decode(bzrlib.user_encoding)
 
314
    s.decode(osutils.get_user_encoding())
189
315
    """
190
316
    if has_ctypes:
191
317
        try:
202
328
    return os.environ.get('USERNAME', None)
203
329
 
204
330
 
 
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
 
205
335
def get_host_name():
206
336
    """Return host machine name.
207
337
    If name cannot be obtained return None.
208
338
 
209
 
    Returned value can be unicode or plain sring.
210
 
    To convert plain string to unicode use
211
 
    s.decode(bzrlib.user_encoding)
 
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.
212
341
    """
 
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
213
348
    if has_ctypes:
214
349
        try:
215
350
            kernel32 = ctypes.windll.kernel32
216
 
            GetComputerName = getattr(kernel32, 'GetComputerName'+suffix)
217
351
        except AttributeError:
218
 
            pass
 
352
            pass # Missing the module we need
219
353
        else:
220
354
            buf = create_buffer(MAX_COMPUTERNAME_LENGTH+1)
221
355
            n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH+1)
222
 
            if GetComputerName(buf, ctypes.byref(n)):
223
 
                return buf.value
224
 
    # otherwise try env variables
225
 
    return os.environ.get('COMPUTERNAME', None)
 
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
226
383
 
227
384
 
228
385
def _ensure_unicode(s):
 
386
    from bzrlib import osutils
229
387
    if s and type(s) != unicode:
230
 
        import bzrlib
231
 
        s = s.decode(bzrlib.user_encoding)
 
388
        from bzrlib import osutils
 
389
        s = s.decode(osutils.get_user_encoding())
232
390
    return s
233
 
    
 
391
 
234
392
 
235
393
def get_appdata_location_unicode():
236
394
    return _ensure_unicode(get_appdata_location())
250
408
        return u'./' + path, True
251
409
    else:
252
410
        return path, False
253
 
    
 
411
 
254
412
def _undo_ensure_with_dir(path, corrected):
255
413
    if corrected:
256
414
        return path[2:]
275
433
    import glob
276
434
    expanded_file_list = []
277
435
    for possible_glob in file_list:
278
 
        
279
436
        # work around bugs in glob.glob()
280
437
        # - Python bug #1001604 ("glob doesn't return unicode with ...")
281
438
        # - failing expansion for */* with non-iso-8859-* chars
290
447
        else:
291
448
            glob_files = [_undo_ensure_with_dir(elem, corrected) for elem in glob_files]
292
449
            expanded_file_list += glob_files
293
 
            
294
 
    return [elem.replace(u'\\', u'/') for elem in expanded_file_list] 
 
450
 
 
451
    return [elem.replace(u'\\', u'/') for elem in expanded_file_list]
295
452
 
296
453
 
297
454
def get_app_path(appname):
298
455
    """Look up in Windows registry for full path to application executable.
299
 
    Typicaly, applications create subkey with their basename
 
456
    Typically, applications create subkey with their basename
300
457
    in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
301
458
 
302
459
    :param  appname:    name of application (if no filename extension
330
487
    """Set file attributes to hidden if possible"""
331
488
    if has_win32file:
332
489
        win32file.SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
 
490
 
 
491
 
 
492
if has_ctypes and winver != 'Windows 98':
 
493
    def get_unicode_argv():
 
494
        LPCWSTR = ctypes.c_wchar_p
 
495
        INT = ctypes.c_int
 
496
        POINTER = ctypes.POINTER
 
497
        prototype = ctypes.WINFUNCTYPE(LPCWSTR)
 
498
        GetCommandLine = prototype(("GetCommandLineW",
 
499
                                    ctypes.windll.kernel32))
 
500
        prototype = ctypes.WINFUNCTYPE(POINTER(LPCWSTR), LPCWSTR, POINTER(INT))
 
501
        CommandLineToArgv = prototype(("CommandLineToArgvW",
 
502
                                       ctypes.windll.shell32))
 
503
        c = INT(0)
 
504
        pargv = CommandLineToArgv(GetCommandLine(), ctypes.byref(c))
 
505
        # Skip the first argument, since we only care about parameters
 
506
        argv = [pargv[i] for i in range(1, c.value)]
 
507
        if getattr(sys, 'frozen', None) is None:
 
508
            # Invoked via 'python.exe' which takes the form:
 
509
            #   python.exe [PYTHON_OPTIONS] C:\Path\bzr [BZR_OPTIONS]
 
510
            # we need to get only BZR_OPTIONS part,
 
511
            # so let's using sys.argv[1:] as reference to get the tail
 
512
            # of unicode argv
 
513
            tail_len = len(sys.argv[1:])
 
514
            ix = len(argv) - tail_len
 
515
            argv = argv[ix:]
 
516
        return argv
 
517
else:
 
518
    get_unicode_argv = None