100
92
MAX_COMPUTERNAME_LENGTH = 31
102
# Registry data type ids
107
def debug_memory_win32api(message='', short=True):
108
"""Use trace.note() to dump the running memory info."""
109
from bzrlib import trace
111
class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):
112
"""Used by GetProcessMemoryInfo"""
113
_fields_ = [('cb', ctypes.c_ulong),
114
('PageFaultCount', ctypes.c_ulong),
115
('PeakWorkingSetSize', ctypes.c_size_t),
116
('WorkingSetSize', ctypes.c_size_t),
117
('QuotaPeakPagedPoolUsage', ctypes.c_size_t),
118
('QuotaPagedPoolUsage', ctypes.c_size_t),
119
('QuotaPeakNonPagedPoolUsage', ctypes.c_size_t),
120
('QuotaNonPagedPoolUsage', ctypes.c_size_t),
121
('PagefileUsage', ctypes.c_size_t),
122
('PeakPagefileUsage', ctypes.c_size_t),
123
('PrivateUsage', ctypes.c_size_t),
125
cur_process = ctypes.windll.kernel32.GetCurrentProcess()
126
mem_struct = PROCESS_MEMORY_COUNTERS_EX()
127
ret = ctypes.windll.psapi.GetProcessMemoryInfo(cur_process,
128
ctypes.byref(mem_struct),
129
ctypes.sizeof(mem_struct))
131
trace.note('Failed to GetProcessMemoryInfo()')
133
info = {'PageFaultCount': mem_struct.PageFaultCount,
134
'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,
135
'WorkingSetSize': mem_struct.WorkingSetSize,
136
'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
137
'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
138
'QuotaPeakNonPagedPoolUsage':
139
mem_struct.QuotaPeakNonPagedPoolUsage,
140
'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
141
'PagefileUsage': mem_struct.PagefileUsage,
142
'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
143
'PrivateUsage': mem_struct.PrivateUsage,
147
# win32process does not return PrivateUsage, because it doesn't use
148
# PROCESS_MEMORY_COUNTERS_EX (it uses the one without _EX).
149
proc = win32process.GetCurrentProcess()
150
info = win32process.GetProcessMemoryInfo(proc)
152
trace.note('Cannot debug memory on win32 without ctypes'
156
# using base-2 units (see HACKING.txt).
157
trace.note('WorkingSize %7dKiB'
158
'\tPeakWorking %7dKiB\t%s',
159
info['WorkingSetSize'] / 1024,
160
info['PeakWorkingSetSize'] / 1024,
164
trace.note('%s', message)
165
trace.note('WorkingSize %8d KiB', info['WorkingSetSize'] / 1024)
166
trace.note('PeakWorking %8d KiB', info['PeakWorkingSetSize'] / 1024)
167
trace.note('PagefileUsage %8d KiB', info.get('PagefileUsage', 0) / 1024)
168
trace.note('PeakPagefileUsage %8d KiB',
169
info.get('PeakPagefileUsage', 0) / 1024)
170
trace.note('PrivateUsage %8d KiB', info.get('PrivateUsage', 0) / 1024)
171
trace.note('PageFaultCount %8d', info.get('PageFaultCount', 0))
174
95
def get_console_size(defaultx=80, defaulty=25):
175
96
"""Return size of current console.
183
104
return (defaultx, defaulty)
185
106
# To avoid problem with redirecting output via pipe
186
# we need to use stderr instead of stdout
107
# need to use stderr instead of stdout
187
108
h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
188
109
csbi = ctypes.create_string_buffer(22)
189
110
res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
192
113
(bufx, bufy, curx, cury, wattr,
193
left, top, right, bottom, maxx, maxy) = struct.unpack(
194
"hhhhHhhhhhh", csbi.raw)
114
left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
195
115
sizex = right - left + 1
196
116
sizey = bottom - top + 1
197
117
return (sizex, sizey)
199
119
return (defaultx, defaulty)
202
def _get_sh_special_folder_path(csidl):
203
"""Call SHGetSpecialFolderPathW if available, or return None.
205
Result is always unicode (or None).
209
SHGetSpecialFolderPath = \
210
ctypes.windll.shell32.SHGetSpecialFolderPathW
211
except AttributeError:
214
buf = ctypes.create_unicode_buffer(MAX_PATH)
215
if SHGetSpecialFolderPath(None,buf,csidl,0):
218
global has_win32com_shell
219
if has_win32com_shell is None:
221
from win32com.shell import shell
222
has_win32com_shell = True
224
has_win32com_shell = False
225
if has_win32com_shell:
226
# still need to bind the name locally, but this is fast.
227
from win32com.shell import shell
229
return shell.SHGetSpecialFolderPath(0, csidl, 0)
231
# possibly E_NOTIMPL meaning we can't load the function pointer,
232
# or E_FAIL meaning the function failed - regardless, just ignore it
237
122
def get_appdata_location():
238
123
"""Return Application Data location.
239
124
Return None if we cannot obtain location.
241
Windows defines two 'Application Data' folders per user - a 'roaming'
242
one that moves with the user as they logon to different machines, and
243
a 'local' one that stays local to the machine. This returns the 'roaming'
244
directory, and thus is suitable for storing user-preferences, etc.
246
Returned value can be unicode or plain string.
126
Returned value can be unicode or plain sring.
247
127
To convert plain string to unicode use
248
s.decode(osutils.get_user_encoding())
249
(XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
128
s.decode(bzrlib.user_encoding)
251
appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
132
SHGetSpecialFolderPath = \
133
ctypes.windll.shell32.SHGetSpecialFolderPathW
134
except AttributeError:
137
buf = ctypes.create_unicode_buffer(MAX_PATH)
138
if SHGetSpecialFolderPath(None,buf,CSIDL_APPDATA,0):
254
140
# from env variable
255
141
appdata = os.environ.get('APPDATA')
269
def get_local_appdata_location():
270
"""Return Local Application Data location.
271
Return the same as get_appdata_location() if we cannot obtain location.
273
Windows defines two 'Application Data' folders per user - a 'roaming'
274
one that moves with the user as they logon to different machines, and
275
a 'local' one that stays local to the machine. This returns the 'local'
276
directory, and thus is suitable for caches, temp files and other things
277
which don't need to move with the user.
279
Returned value can be unicode or plain string.
280
To convert plain string to unicode use
281
s.decode(osutils.get_user_encoding())
282
(XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
284
local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
287
# Vista supplies LOCALAPPDATA, but XP and earlier do not.
288
local = os.environ.get('LOCALAPPDATA')
291
return get_appdata_location()
294
155
def get_home_location():
295
156
"""Return user's home location.
296
157
Assume on win32 it's the <My Documents> folder.
297
158
If location cannot be obtained return system drive root,
300
Returned value can be unicode or plain string.
161
Returned value can be unicode or plain sring.
301
162
To convert plain string to unicode use
302
s.decode(osutils.get_user_encoding())
163
s.decode(bzrlib.user_encoding)
304
home = _get_sh_special_folder_path(CSIDL_PERSONAL)
167
SHGetSpecialFolderPath = \
168
ctypes.windll.shell32.SHGetSpecialFolderPathW
169
except AttributeError:
172
buf = ctypes.create_unicode_buffer(MAX_PATH)
173
if SHGetSpecialFolderPath(None,buf,CSIDL_PERSONAL,0):
307
175
# try for HOME env variable
308
176
home = os.path.expanduser('~')
462
309
if not file_list:
464
312
expanded_file_list = []
465
313
for possible_glob in file_list:
466
expanded_file_list.extend(glob_one(possible_glob))
467
return expanded_file_list
315
# work around bugs in glob.glob()
316
# - Python bug #1001604 ("glob doesn't return unicode with ...")
317
# - failing expansion for */* with non-iso-8859-* chars
318
possible_glob, corrected = _ensure_with_dir(possible_glob)
319
glob_files = glob.glob(possible_glob)
322
# special case to let the normal code path handle
323
# files that do not exists
324
expanded_file_list.append(
325
_undo_ensure_with_dir(possible_glob, corrected))
327
glob_files = [_undo_ensure_with_dir(elem, corrected) for elem in glob_files]
328
expanded_file_list += glob_files
330
return [elem.replace(u'\\', u'/') for elem in expanded_file_list]
470
333
def get_app_path(appname):
471
r"""Look up in Windows registry for full path to application executable.
472
Typically, applications create subkey with their basename
334
"""Look up in Windows registry for full path to application executable.
335
Typicaly, applications create subkey with their basename
473
336
in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
475
338
:param appname: name of application (if no filename extension
478
341
or appname itself if nothing found.
345
hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
346
r'SOFTWARE\Microsoft\Windows'
347
r'\CurrentVersion\App Paths')
348
except EnvironmentError:
482
351
basename = appname
483
352
if not os.path.splitext(basename)[1]:
484
353
basename = appname + '.exe'
487
hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
488
'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
490
except EnvironmentError:
495
path, type_id = _winreg.QueryValueEx(hkey, '')
356
fullpath = _winreg.QueryValue(hkey, basename)
496
357
except WindowsError:
499
360
_winreg.CloseKey(hkey)
501
if type_id == REG_SZ:
503
if type_id == REG_EXPAND_SZ and has_win32api:
504
fullpath = win32api.ExpandEnvironmentStrings(path)
505
if len(fullpath) > 1 and fullpath[0] == '"' and fullpath[-1] == '"':
506
fullpath = fullpath[1:-1] # remove quotes around value
511
365
def set_file_attr_hidden(path):
512
366
"""Set file attributes to hidden if possible"""
513
367
if has_win32file:
514
if winver != 'Windows 98':
515
SetFileAttributes = win32file.SetFileAttributesW
517
SetFileAttributes = win32file.SetFileAttributes
519
SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
520
except pywintypes.error, e:
521
from bzrlib import trace
522
trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
525
def _command_line_to_argv(command_line, argv, single_quotes_allowed=False):
526
"""Convert a Unicode command line into a list of argv arguments.
528
It performs wildcard expansion to make wildcards act closer to how they
529
work in posix shells, versus how they work by default on Windows. Quoted
530
arguments are left untouched.
532
:param command_line: The unicode string to split into an arg list.
533
:param single_quotes_allowed: Whether single quotes are accepted as quoting
534
characters like double quotes. False by
536
:return: A list of unicode strings.
538
# First, spit the command line
539
s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
541
# Bug #587868 Now make sure that the length of s agrees with sys.argv
542
# we do this by simply counting the number of arguments in each. The counts should
543
# agree no matter what encoding sys.argv is in (AFAIK)
544
# len(arguments) < len(sys.argv) should be an impossibility since python gets
545
# args from the very same PEB as does GetCommandLineW
548
# Now shorten the command line we get from GetCommandLineW to match sys.argv
549
if len(arguments) < len(argv):
550
raise AssertionError("Split command line can't be shorter than argv")
551
arguments = arguments[len(arguments) - len(argv):]
553
# Carry on to process globs (metachars) in the command line
554
# expand globs if necessary
555
# TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
558
for is_quoted, arg in arguments:
559
if is_quoted or not glob.has_magic(arg):
562
args.extend(glob_one(arg))
566
if has_ctypes and winver != 'Windows 98':
567
def get_unicode_argv():
568
prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
569
GetCommandLineW = prototype(("GetCommandLineW",
570
ctypes.windll.kernel32))
571
command_line = GetCommandLineW()
572
if command_line is None:
573
raise ctypes.WinError()
574
# Skip the first argument, since we only care about parameters
575
argv = _command_line_to_argv(command_line, sys.argv)[1:]
578
get_unicode_argv = None
582
def _pywin32_is_local_pid_dead(pid):
583
"""True if pid doesn't correspond to live process on this machine"""
585
handle = win32api.OpenProcess(1, False, pid) # PROCESS_TERMINATE
586
except pywintypes.error, e:
587
if e[0] == 5: # ERROR_ACCESS_DENIED
588
# Probably something alive we're not allowed to kill
590
elif e[0] == 87: # ERROR_INVALID_PARAMETER
595
is_local_pid_dead = _pywin32_is_local_pid_dead
596
elif has_ctypes and sys.platform == 'win32':
597
from ctypes.wintypes import BOOL, DWORD, HANDLE
598
_kernel32 = ctypes.windll.kernel32
599
_CloseHandle = ctypes.WINFUNCTYPE(BOOL, HANDLE)(
600
("CloseHandle", _kernel32))
601
_OpenProcess = ctypes.WINFUNCTYPE(HANDLE, DWORD, BOOL, DWORD)(
602
("OpenProcess", _kernel32))
603
def _ctypes_is_local_pid_dead(pid):
604
"""True if pid doesn't correspond to live process on this machine"""
605
handle = _OpenProcess(1, False, pid) # PROCESS_TERMINATE
607
errorcode = ctypes.GetLastError()
608
if errorcode == 5: # ERROR_ACCESS_DENIED
609
# Probably something alive we're not allowed to kill
611
elif errorcode == 87: # ERROR_INVALID_PARAMETER
613
raise ctypes.WinError(errorcode)
616
is_local_pid_dead = _ctypes_is_local_pid_dead
368
win32file.SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
added
removed
bzrlib/win32utils.py
