← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/win32utils.py

  • Committer: Martin Pool
  • Date: 2010-02-27 01:34:49 UTC
  • mto: This revision was merged to the branch mainline in revision 5064.
  • Revision ID: mbp@canonical.com-20100227013449-zxostilwfoendxfv
Handle "Directory not empty" from ftp as DirectoryNotEmpty.

FtpTransport._translate_ftp_error can handle all ftp errors; there's no clear
distinction between 'temporary' and 'permament'.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/win32utils.py
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
19
19
Only one dependency: ctypes should be installed.
20
20
"""
21
21
 
 
22
import glob
22
23
import os
 
24
import re
23
25
import struct
24
26
import sys
25
27
 
 
28
from bzrlib import cmdline
26
29
 
27
30
# Windows version
28
31
if sys.platform == 'win32':
133
136
                'WorkingSetSize': mem_struct.WorkingSetSize,
134
137
                'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,
135
138
                'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,
136
 
                'QuotaPeakNonPagedPoolUsage': mem_struct.QuotaPeakNonPagedPoolUsage,
 
139
                'QuotaPeakNonPagedPoolUsage':
 
140
                    mem_struct.QuotaPeakNonPagedPoolUsage,
137
141
                'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,
138
142
                'PagefileUsage': mem_struct.PagefileUsage,
139
143
                'PeakPagefileUsage': mem_struct.PeakPagefileUsage,
150
154
                   ' or win32process')
151
155
        return
152
156
    if short:
153
 
        trace.note('WorkingSize %7dKB'
154
 
                   '\tPeakWorking %7dKB\t%s',
 
157
        # using base-2 units (see HACKING.txt).
 
158
        trace.note('WorkingSize %7dKiB'
 
159
                   '\tPeakWorking %7dKiB\t%s',
155
160
                   info['WorkingSetSize'] / 1024,
156
161
                   info['PeakWorkingSetSize'] / 1024,
157
162
                   message)
158
163
        return
159
164
    if message:
160
165
        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('WorkingSize       %8d KiB', info['WorkingSetSize'] / 1024)
 
167
    trace.note('PeakWorking       %8d KiB', info['PeakWorkingSetSize'] / 1024)
 
168
    trace.note('PagefileUsage     %8d KiB', info.get('PagefileUsage', 0) / 1024)
 
169
    trace.note('PeakPagefileUsage %8d KiB',
 
170
               info.get('PeakPagefileUsage', 0) / 1024)
 
171
    trace.note('PrivateUsage      %8d KiB', info.get('PrivateUsage', 0) / 1024)
166
172
    trace.note('PageFaultCount    %8d', info.get('PageFaultCount', 0))
167
173
 
168
174
 
178
184
        return (defaultx, defaulty)
179
185
 
180
186
    # To avoid problem with redirecting output via pipe
181
 
    # need to use stderr instead of stdout
 
187
    # we need to use stderr instead of stdout
182
188
    h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)
183
189
    csbi = ctypes.create_string_buffer(22)
184
190
    res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
185
191
 
186
192
    if res:
187
193
        (bufx, bufy, curx, cury, wattr,
188
 
        left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
 
194
        left, top, right, bottom, maxx, maxy) = struct.unpack(
 
195
            "hhhhHhhhhhh", csbi.raw)
189
196
        sizex = right - left + 1
190
197
        sizey = bottom - top + 1
191
198
        return (sizex, sizey)
388
395
 
389
396
 
390
397
def _ensure_unicode(s):
391
 
    from bzrlib import osutils
392
398
    if s and type(s) != unicode:
393
399
        from bzrlib import osutils
394
400
        s = s.decode(osutils.get_user_encoding())
409
415
 
410
416
 
411
417
def _ensure_with_dir(path):
412
 
    if not os.path.split(path)[0] or path.startswith(u'*') or path.startswith(u'?'):
 
418
    if (not os.path.split(path)[0] or path.startswith(u'*')
 
419
        or path.startswith(u'?')):
413
420
        return u'./' + path, True
414
421
    else:
415
422
        return path, False
422
429
 
423
430
 
424
431
 
 
432
def glob_one(possible_glob):
 
433
    """Same as glob.glob().
 
434
 
 
435
    work around bugs in glob.glob()
 
436
    - Python bug #1001604 ("glob doesn't return unicode with ...")
 
437
    - failing expansion for */* with non-iso-8859-* chars
 
438
    """
 
439
    corrected_glob, corrected = _ensure_with_dir(possible_glob)
 
440
    glob_files = glob.glob(corrected_glob)
 
441
 
 
442
    if not glob_files:
 
443
        # special case to let the normal code path handle
 
444
        # files that do not exist, etc.
 
445
        glob_files = [possible_glob]
 
446
    elif corrected:
 
447
        glob_files = [_undo_ensure_with_dir(elem, corrected)
 
448
                      for elem in glob_files]
 
449
    return [elem.replace(u'\\', u'/') for elem in glob_files]
 
450
 
 
451
 
425
452
def glob_expand(file_list):
426
453
    """Replacement for glob expansion by the shell.
427
454
 
435
462
    """
436
463
    if not file_list:
437
464
        return []
438
 
    import glob
439
465
    expanded_file_list = []
440
466
    for possible_glob in file_list:
441
 
        # work around bugs in glob.glob()
442
 
        # - Python bug #1001604 ("glob doesn't return unicode with ...")
443
 
        # - failing expansion for */* with non-iso-8859-* chars
444
 
        possible_glob, corrected = _ensure_with_dir(possible_glob)
445
 
        glob_files = glob.glob(possible_glob)
446
 
 
447
 
        if glob_files == []:
448
 
            # special case to let the normal code path handle
449
 
            # files that do not exists
450
 
            expanded_file_list.append(
451
 
                _undo_ensure_with_dir(possible_glob, corrected))
452
 
        else:
453
 
            glob_files = [_undo_ensure_with_dir(elem, corrected) for elem in glob_files]
454
 
            expanded_file_list += glob_files
455
 
 
456
 
    return [elem.replace(u'\\', u'/') for elem in expanded_file_list]
 
467
        expanded_file_list.extend(glob_one(possible_glob))
 
468
    return expanded_file_list
457
469
 
458
470
 
459
471
def get_app_path(appname):
511
523
            trace.mutter('Unable to set hidden attribute on %r: %s', path, e)
512
524
 
513
525
 
 
526
def _command_line_to_argv(command_line, single_quotes_allowed=False):
 
527
    """Convert a Unicode command line into a list of argv arguments.
 
528
 
 
529
    It performs wildcard expansion to make wildcards act closer to how they
 
530
    work in posix shells, versus how they work by default on Windows. Quoted
 
531
    arguments are left untouched.
 
532
 
 
533
    :param command_line: The unicode string to split into an arg list.
 
534
    :param single_quotes_allowed: Whether single quotes are accepted as quoting
 
535
                                  characters like double quotes. False by
 
536
                                  default.
 
537
    :return: A list of unicode strings.
 
538
    """
 
539
    s = cmdline.Splitter(command_line, single_quotes_allowed=single_quotes_allowed)
 
540
    # Now that we've split the content, expand globs if necessary
 
541
    # TODO: Use 'globbing' instead of 'glob.glob', this gives us stuff like
 
542
    #       '**/' style globs
 
543
    args = []
 
544
    for is_quoted, arg in s:
 
545
        if is_quoted or not glob.has_magic(arg):
 
546
            args.append(arg)
 
547
        else:
 
548
            args.extend(glob_one(arg))
 
549
    return args
 
550
 
 
551
 
514
552
if has_ctypes and winver != 'Windows 98':
515
553
    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))
 
554
        prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)
 
555
        GetCommandLineW = prototype(("GetCommandLineW",
 
556
                                     ctypes.windll.kernel32))
 
557
        command_line = GetCommandLineW()
 
558
        if command_line is None:
 
559
            raise ctypes.WinError()
527
560
        # Skip the first argument, since we only care about parameters
528
 
        argv = [pargv[i] for i in range(1, c.value)]
 
561
        argv = _command_line_to_argv(command_line)[1:]
529
562
        if getattr(sys, 'frozen', None) is None:
530
563
            # Invoked via 'python.exe' which takes the form:
531
564
            #   python.exe [PYTHON_OPTIONS] C:\Path\bzr [BZR_OPTIONS]
532
565
            # 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:]
 
566
            # We already removed 'python.exe' so we remove everything up to and
 
567
            # including the first non-option ('-') argument.
 
568
            for idx in xrange(len(argv)):
 
569
                if argv[idx][:1] != '-':
 
570
                    break
 
571
            argv = argv[idx+1:]
538
572
        return argv
539
573
else:
540
574
    get_unicode_argv = None