/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

  • Committer: Martin
  • Date: 2010-05-03 20:57:39 UTC
  • mto: This revision was merged to the branch mainline in revision 5204.
  • Revision ID: gzlist@googlemail.com-20100503205739-n326zdvevv0rmruh
Retain original stack and error message when translating to ValueError in bencode

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
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
 
19
19
Only one dependency: ctypes should be installed.
20
20
"""
21
21
 
 
22
import glob
22
23
import os
23
24
import struct
24
25
import sys
25
26
 
 
27
from bzrlib import cmdline
26
28
 
27
29
# Windows version
28
30
if sys.platform == 'win32':
66
68
        suffix = 'W'
67
69
try:
68
70
    import win32file
 
71
    import pywintypes
69
72
    has_win32file = True
70
73
except ImportError:
71
74
    has_win32file = False
96
99
UNLEN = 256
97
100
MAX_COMPUTERNAME_LENGTH = 31
98
101
 
 
102
# Registry data type ids
 
103
REG_SZ = 1
 
104
REG_EXPAND_SZ = 2
 
105
 
 
106
 
 
107
def debug_memory_win32api(message='', short=True):
 
108
    """Use trace.note() to dump the running memory info."""
 
109
    from bzrlib import trace
 
110
    if has_ctypes:
 
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),
 
124
                       ]
 
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))
 
130
        if not ret:
 
131
            trace.note('Failed to GetProcessMemoryInfo()')
 
132
            return
 
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,
 
144
               }
 
145
    elif has_win32api:
 
146
        import win32process
 
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)
 
151
    else:
 
152
        trace.note('Cannot debug memory on win32 without ctypes'
 
153
                   ' or win32process')
 
154
        return
 
155
    if short:
 
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,
 
161
                   message)
 
162
        return
 
163
    if message:
 
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))
 
172
 
99
173
 
100
174
def get_console_size(defaultx=80, defaulty=25):
101
175
    """Return size of current console.
109
183
        return (defaultx, defaulty)
110
184
 
111
185
    # To avoid problem with redirecting output via pipe
112
 
    # need to use stderr instead of stdout
 
186
    # we need to use stderr instead of stdout
113
187
    h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
114
188
    csbi = ctypes.create_string_buffer(22)
115
189
    res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
116
190
 
117
191
    if res:
118
192
        (bufx, bufy, curx, cury, wattr,
119
 
        left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
 
193
        left, top, right, bottom, maxx, maxy) = struct.unpack(
 
194
            "hhhhHhhhhhh", csbi.raw)
120
195
        sizex = right - left + 1
121
196
        sizey = bottom - top + 1
122
197
        return (sizex, sizey)
126
201
 
127
202
def _get_sh_special_folder_path(csidl):
128
203
    """Call SHGetSpecialFolderPathW if available, or return None.
129
 
    
 
204
 
130
205
    Result is always unicode (or None).
131
206
    """
132
207
    if has_ctypes:
170
245
 
171
246
    Returned value can be unicode or plain string.
172
247
    To convert plain string to unicode use
173
 
    s.decode(bzrlib.user_encoding)
 
248
    s.decode(osutils.get_user_encoding())
174
249
    (XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
175
250
    """
176
251
    appdata = _get_sh_special_folder_path(CSIDL_APPDATA)
203
278
 
204
279
    Returned value can be unicode or plain string.
205
280
    To convert plain string to unicode use
206
 
    s.decode(bzrlib.user_encoding)
 
281
    s.decode(osutils.get_user_encoding())
207
282
    (XXX - but see bug 262874, which asserts the correct encoding is 'mbcs')
208
283
    """
209
284
    local = _get_sh_special_folder_path(CSIDL_LOCAL_APPDATA)
222
297
    If location cannot be obtained return system drive root,
223
298
    i.e. C:\
224
299
 
225
 
    Returned value can be unicode or plain sring.
 
300
    Returned value can be unicode or plain string.
226
301
    To convert plain string to unicode use
227
 
    s.decode(bzrlib.user_encoding)
 
302
    s.decode(osutils.get_user_encoding())
228
303
    """
229
304
    home = _get_sh_special_folder_path(CSIDL_PERSONAL)
230
305
    if home:
245
320
    """Return user name as login name.
246
321
    If name cannot be obtained return None.
247
322
 
248
 
    Returned value can be unicode or plain sring.
 
323
    Returned value can be unicode or plain string.
249
324
    To convert plain string to unicode use
250
 
    s.decode(bzrlib.user_encoding)
 
325
    s.decode(osutils.get_user_encoding())
251
326
    """
252
327
    if has_ctypes:
253
328
        try:
320
395
 
321
396
def _ensure_unicode(s):
322
397
    if s and type(s) != unicode:
323
 
        import bzrlib
324
 
        s = s.decode(bzrlib.user_encoding)
 
398
        from bzrlib import osutils
 
399
        s = s.decode(osutils.get_user_encoding())
325
400
    return s
326
401
 
327
402
 
339
414
 
340
415
 
341
416
def _ensure_with_dir(path):
342
 
    if not os.path.split(path)[0] or path.startswith(u'*') or path.startswith(u'?'):
 
417
    if (not os.path.split(path)[0] or path.startswith(u'*')
 
418
        or path.startswith(u'?')):
343
419
        return u'./' + path, True
344
420
    else:
345
421
        return path, False
346
 
    
 
422
 
347
423
def _undo_ensure_with_dir(path, corrected):
348
424
    if corrected:
349
425
        return path[2:]
352
428
 
353
429
 
354
430
 
 
431
def glob_one(possible_glob):
 
432
    """Same as glob.glob().
 
433
 
 
434
    work around bugs in glob.glob()
 
435
    - Python bug #1001604 ("glob doesn't return unicode with ...")
 
436
    - failing expansion for */* with non-iso-8859-* chars
 
437
    """
 
438
    corrected_glob, corrected = _ensure_with_dir(possible_glob)
 
439
    glob_files = glob.glob(corrected_glob)
 
440
 
 
441
    if not glob_files:
 
442
        # special case to let the normal code path handle
 
443
        # files that do not exist, etc.
 
444
        glob_files = [possible_glob]
 
445
    elif corrected:
 
446
        glob_files = [_undo_ensure_with_dir(elem, corrected)
 
447
                      for elem in glob_files]
 
448
    return [elem.replace(u'\\', u'/') for elem in glob_files]
 
449
 
 
450
 
355
451
def glob_expand(file_list):
356
452
    """Replacement for glob expansion by the shell.
357
453
 
365
461
    """
366
462
    if not file_list:
367
463
        return []
368
 
    import glob
369
464
    expanded_file_list = []
370
465
    for possible_glob in file_list:
371
 
        
372
 
        # work around bugs in glob.glob()
373
 
        # - Python bug #1001604 ("glob doesn't return unicode with ...")
374
 
        # - failing expansion for */* with non-iso-8859-* chars
375
 
        possible_glob, corrected = _ensure_with_dir(possible_glob)
376
 
        glob_files = glob.glob(possible_glob)
377
 
 
378
 
        if glob_files == []:
379
 
            # special case to let the normal code path handle
380
 
            # files that do not exists
381
 
            expanded_file_list.append(
382
 
                _undo_ensure_with_dir(possible_glob, corrected))
383
 
        else:
384
 
            glob_files = [_undo_ensure_with_dir(elem, corrected) for elem in glob_files]
385
 
            expanded_file_list += glob_files
386
 
            
387
 
    return [elem.replace(u'\\', u'/') for elem in expanded_file_list] 
 
466
        expanded_file_list.extend(glob_one(possible_glob))
 
467
    return expanded_file_list
388
468
 
389
469
 
390
470
def get_app_path(appname):
391
471
    """Look up in Windows registry for full path to application executable.
392
 
    Typicaly, applications create subkey with their basename
 
472
    Typically, applications create subkey with their basename
393
473
    in HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\
394
474
 
395
475
    :param  appname:    name of application (if no filename extension
398
478
                or appname itself if nothing found.
399
479
    """
400
480
    import _winreg
 
481
 
 
482
    basename = appname
 
483
    if not os.path.splitext(basename)[1]:
 
484
        basename = appname + '.exe'
 
485
 
401
486
    try:
402
487
        hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
403
 
                               r'SOFTWARE\Microsoft\Windows'
404
 
                               r'\CurrentVersion\App Paths')
 
488
            'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\' +
 
489
            basename)
405
490
    except EnvironmentError:
406
491
        return appname
407
492
 
408
 
    basename = appname
409
 
    if not os.path.splitext(basename)[1]:
410
 
        basename = appname + '.exe'
411
493
    try:
412
494
        try:
413
 
            fullpath = _winreg.QueryValue(hkey, basename)
 
495
            path, type_id = _winreg.QueryValueEx(hkey, '')
414
496
        except WindowsError:
415
 
            fullpath = appname
 
497
            return appname
416
498
    finally:
417
499
        _winreg.CloseKey(hkey)
418
500
 
419
 
    return fullpath
 
501
    if type_id == REG_SZ:
 
502
        return path
 
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
 
507
        return fullpath
 
508
    return appname
420
509
 
421
510
 
422
511
def set_file_attr_hidden(path):
423
512
    """Set file attributes to hidden if possible"""
424
513
    if has_win32file:
425
 
        win32file.SetFileAttributes(path, win32file.FILE_ATTRIBUTE_HIDDEN)
 
514
        if winver != 'Windows 98':
 
515
            SetFileAttributes = win32file.SetFileAttributesW
 
516
        else:
 
517
            SetFileAttributes = win32file.SetFileAttributes
 
518
        try:
 
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)
 
523
 
 
524
 
 
525
def _command_line_to_argv(command_line, single_quotes_allowed=False):
 
526
    """Convert a Unicode command line into a list of argv arguments.
 
527
 
 
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.
 
531
 
 
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
 
535
                                  default.
 
536
    :return: A list of unicode strings.
 
537
    """
 
538
    s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
 
539
    # Now that we've split the content, expand globs if necessary
 
540
    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
 
541
    #       '**/' style globs
 
542
    args = []
 
543
    for is_quoted, arg in s:
 
544
        if is_quoted or not glob.has_magic(arg):
 
545
            args.append(arg)
 
546
        else:
 
547
            args.extend(glob_one(arg))
 
548
    return args
 
549
 
 
550
 
 
551
if has_ctypes and winver != 'Windows 98':
 
552
    def get_unicode_argv():
 
553
        prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
 
554
        GetCommandLineW = prototype(("GetCommandLineW",
 
555
                                     ctypes.windll.kernel32))
 
556
        command_line = GetCommandLineW()
 
557
        if command_line is None:
 
558
            raise ctypes.WinError()
 
559
        # Skip the first argument, since we only care about parameters
 
560
        argv = _command_line_to_argv(command_line)[1:]
 
561
        if getattr(sys, 'frozen', None) is None:
 
562
            # Invoked via 'python.exe' which takes the form:
 
563
            #   python.exe [PYTHON_OPTIONS] C:\Path\bzr [BZR_OPTIONS]
 
564
            # we need to get only BZR_OPTIONS part,
 
565
            # We already removed 'python.exe' so we remove everything up to and
 
566
            # including the first non-option ('-') argument.
 
567
            for idx in xrange(len(argv)):
 
568
                if argv[idx][:1] != '-':
 
569
                    break
 
570
            argv = argv[idx+1:]
 
571
        return argv
 
572
else:
 
573
    get_unicode_argv = None