← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Wouter van Heyst
  • Date: 2006-06-07 16:05:27 UTC
  • mto: This revision was merged to the branch mainline in revision 1752.
  • Revision ID: larstiq@larstiq.dyndns.org-20060607160527-2b3649154d0e2e84
more code cleanup

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commands.py
1
 
# Copyright (C) 2006 Canonical Ltd
 
1
# Copyright (C) 2006 by 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
28
28
# TODO: "--profile=cum", to change sort order.  Is there any value in leaving
29
29
# the profile output behind so it can be interactively examined?
30
30
 
 
31
import sys
31
32
import os
32
 
import sys
33
 
 
34
 
from bzrlib.lazy_import import lazy_import
35
 
lazy_import(globals(), """
 
33
from warnings import warn
 
34
import errno
36
35
import codecs
37
 
import errno
38
 
from warnings import warn
39
36
 
40
37
import bzrlib
41
 
from bzrlib import (
42
 
    debug,
43
 
    errors,
44
 
    option,
45
 
    osutils,
46
 
    trace,
47
 
    win32utils,
48
 
    )
49
 
""")
50
 
 
51
 
from bzrlib.symbol_versioning import (
52
 
    deprecated_function,
53
 
    deprecated_method,
54
 
    zero_eight,
55
 
    zero_eleven,
56
 
    )
57
 
# Compatibility
 
38
from bzrlib.errors import (BzrError,
 
39
                           BzrCheckError,
 
40
                           BzrCommandError,
 
41
                           BzrOptionError,
 
42
                           NotBranchError)
58
43
from bzrlib.option import Option
59
 
 
 
44
from bzrlib.revisionspec import RevisionSpec
 
45
from bzrlib.symbol_versioning import *
 
46
import bzrlib.trace
 
47
from bzrlib.trace import mutter, note, log_error, warning, be_quiet
60
48
 
61
49
plugin_cmds = {}
62
50
 
75
63
        k_unsquished = _unsquish_command_name(k)
76
64
    else:
77
65
        k_unsquished = k
78
 
    if k_unsquished not in plugin_cmds:
 
66
    if not plugin_cmds.has_key(k_unsquished):
79
67
        plugin_cmds[k_unsquished] = cmd
80
 
        ## trace.mutter('registered plugin command %s', k_unsquished)
 
68
        mutter('registered plugin command %s', k_unsquished)
81
69
        if decorate and k_unsquished in builtin_command_names():
82
70
            return _builtin_commands()[k_unsquished]
83
71
    elif decorate:
85
73
        plugin_cmds[k_unsquished] = cmd
86
74
        return result
87
75
    else:
88
 
        trace.log_error('Two plugins defined the same command: %r' % k)
89
 
        trace.log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
 
76
        log_error('Two plugins defined the same command: %r' % k)
 
77
        log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
90
78
 
91
79
 
92
80
def _squish_command_name(cmd):
138
126
    plugins_override
139
127
        If true, plugin commands can override builtins.
140
128
    """
141
 
    try:
142
 
        return _get_cmd_object(cmd_name, plugins_override)
143
 
    except KeyError:
144
 
        raise errors.BzrCommandError('unknown command "%s"' % cmd_name)
145
 
 
146
 
 
147
 
def _get_cmd_object(cmd_name, plugins_override=True):
148
 
    """Worker for get_cmd_object which raises KeyError rather than BzrCommandError."""
149
129
    from bzrlib.externalcommand import ExternalCommand
150
130
 
151
 
    # We want only 'ascii' command names, but the user may have typed
152
 
    # in a Unicode name. In that case, they should just get a
153
 
    # 'command not found' error later.
154
 
    # In the future, we may actually support Unicode command names.
 
131
    cmd_name = str(cmd_name)            # not unicode
155
132
 
156
133
    # first look up this command under the specified name
157
134
    cmds = _get_cmd_dict(plugins_override=plugins_override)
168
145
    cmd_obj = ExternalCommand.find_command(cmd_name)
169
146
    if cmd_obj:
170
147
        return cmd_obj
171
 
    raise KeyError
 
148
 
 
149
    raise BzrCommandError("unknown command %r" % cmd_name)
172
150
 
173
151
 
174
152
class Command(object):
222
200
            replace - put in a bogus character (typically '?')
223
201
            exact - do not encode sys.stdout
224
202
 
225
 
            NOTE: by default on Windows, sys.stdout is opened as a text
226
 
            stream, therefore LF line-endings are converted to CRLF.
227
 
            When a command uses encoding_type = 'exact', then
228
 
            sys.stdout is forced to be a binary stream, and line-endings
229
 
            will not mangled.
230
 
 
231
203
    """
232
204
    aliases = []
233
205
    takes_args = []
241
213
        if self.__doc__ == Command.__doc__:
242
214
            warn("No help message set for %r" % self)
243
215
 
244
 
    def _maybe_expand_globs(self, file_list):
245
 
        """Glob expand file_list if the platform does not do that itself.
246
 
        
247
 
        :return: A possibly empty list of unicode paths.
248
 
 
249
 
        Introduced in bzrlib 0.18.
250
 
        """
251
 
        if not file_list:
252
 
            file_list = []
253
 
        if sys.platform == 'win32':
254
 
            file_list = win32utils.glob_expand(file_list)
255
 
        return list(file_list)
256
 
 
257
 
    def _usage(self):
258
 
        """Return single-line grammar for this command.
259
 
 
260
 
        Only describes arguments, not options.
261
 
        """
262
 
        s = 'bzr ' + self.name() + ' '
263
 
        for aname in self.takes_args:
264
 
            aname = aname.upper()
265
 
            if aname[-1] in ['$', '+']:
266
 
                aname = aname[:-1] + '...'
267
 
            elif aname[-1] == '?':
268
 
                aname = '[' + aname[:-1] + ']'
269
 
            elif aname[-1] == '*':
270
 
                aname = '[' + aname[:-1] + '...]'
271
 
            s += aname + ' '
272
 
                
273
 
        assert s[-1] == ' '
274
 
        s = s[:-1]
275
 
        return s
276
 
 
277
 
    def get_help_text(self, additional_see_also=None):
278
 
        """Return a text string with help for this command.
279
 
        
280
 
        :param additional_see_also: Additional help topics to be
281
 
            cross-referenced.
282
 
        """
283
 
        doc = self.help()
284
 
        if doc is None:
285
 
            raise NotImplementedError("sorry, no detailed help yet for %r" % self.name())
286
 
 
287
 
        result = ""
288
 
        result += 'usage: %s\n' % self._usage()
289
 
 
290
 
        if self.aliases:
291
 
            result += 'aliases: '
292
 
            result += ', '.join(self.aliases) + '\n'
293
 
 
294
 
        result += '\n'
295
 
 
296
 
        plugin_name = self.plugin_name()
297
 
        if plugin_name is not None:
298
 
            result += '(From plugin "%s")' % plugin_name
299
 
            result += '\n\n'
300
 
 
301
 
        result += doc
302
 
        if result[-1] != '\n':
303
 
            result += '\n'
304
 
        result += '\n'
305
 
        result += option.get_optparser(self.options()).format_option_help()
306
 
        see_also = self.get_see_also(additional_see_also)
307
 
        if see_also:
308
 
            result += '\nSee also: '
309
 
            result += ', '.join(see_also)
310
 
            result += '\n'
311
 
        return result
312
 
 
313
 
    def get_help_topic(self):
314
 
        """Return the commands help topic - its name."""
315
 
        return self.name()
316
 
 
317
 
    def get_see_also(self, additional_terms=None):
318
 
        """Return a list of help topics that are related to this ommand.
319
 
        
320
 
        The list is derived from the content of the _see_also attribute. Any
321
 
        duplicates are removed and the result is in lexical order.
322
 
        :param additional_terms: Additional help topics to cross-reference.
323
 
        :return: A list of help topics.
324
 
        """
325
 
        see_also = set(getattr(self, '_see_also', []))
326
 
        if additional_terms:
327
 
            see_also.update(additional_terms)
328
 
        return sorted(see_also)
329
 
 
330
216
    def options(self):
331
217
        """Return dict of valid options for this command.
332
218
 
333
219
        Maps from long option name to option object."""
334
220
        r = dict()
335
 
        r['help'] = option.Option.OPTIONS['help']
 
221
        r['help'] = Option.OPTIONS['help']
336
222
        for o in self.takes_options:
337
 
            if isinstance(o, basestring):
338
 
                o = option.Option.OPTIONS[o]
 
223
            if not isinstance(o, Option):
 
224
                o = Option.OPTIONS[o]
339
225
            r[o.name] = o
340
226
        return r
341
227
 
342
 
    def _setup_outf(self):
 
228
    def _setup_stdout(self):
343
229
        """Return a file linked to stdout, which has proper encoding."""
344
230
        assert self.encoding_type in ['strict', 'exact', 'replace']
345
231
 
346
232
        # Originally I was using self.stdout, but that looks
347
233
        # *way* too much like sys.stdout
348
234
        if self.encoding_type == 'exact':
349
 
            # force sys.stdout to be binary stream on win32
350
 
            if sys.platform == 'win32':
351
 
                fileno = getattr(sys.stdout, 'fileno', None)
352
 
                if fileno:
353
 
                    import msvcrt
354
 
                    msvcrt.setmode(fileno(), os.O_BINARY)
355
235
            self.outf = sys.stdout
356
236
            return
357
237
 
358
 
        output_encoding = osutils.get_terminal_encoding()
 
238
        output_encoding = getattr(sys.stdout, 'encoding', None)
 
239
        if not output_encoding:
 
240
            output_encoding = bzrlib.user_encoding
 
241
            mutter('encoding stdout bzrlib.user_encoding %r', output_encoding)
 
242
        else:
 
243
            mutter('encoding stdout log as sys.stdout encoding %r', output_encoding)
359
244
 
360
245
        # use 'replace' so that we don't abort if trying to write out
361
246
        # in e.g. the default C locale.
362
247
        self.outf = codecs.getwriter(output_encoding)(sys.stdout, errors=self.encoding_type)
363
 
        # For whatever reason codecs.getwriter() does not advertise its encoding
364
 
        # it just returns the encoding of the wrapped file, which is completely
365
 
        # bogus. So set the attribute, so we can find the correct encoding later.
366
 
        self.outf.encoding = output_encoding
 
248
 
 
249
    @deprecated_method(zero_eight)
 
250
    def run_argv(self, argv):
 
251
        """Parse command line and run.
 
252
        
 
253
        See run_argv_aliases for the 0.8 and beyond api.
 
254
        """
 
255
        return self.run_argv_aliases(argv)
367
256
 
368
257
    def run_argv_aliases(self, argv, alias_argv=None):
369
258
        """Parse the command line and run with extra aliases in alias_argv."""
370
 
        if argv is None:
371
 
            warn("Passing None for [] is deprecated from bzrlib 0.10",
372
 
                 DeprecationWarning, stacklevel=2)
373
 
            argv = []
374
259
        args, opts = parse_args(self, argv, alias_argv)
375
260
        if 'help' in opts:  # e.g. bzr add --help
376
 
            sys.stdout.write(self.get_help_text())
 
261
            from bzrlib.help import help_on_command
 
262
            help_on_command(self.name())
377
263
            return 0
 
264
        # XXX: This should be handled by the parser
 
265
        allowed_names = self.options().keys()
 
266
        for oname in opts:
 
267
            if oname not in allowed_names:
 
268
                raise BzrCommandError("option '--%s' is not allowed for"
 
269
                                      " command %r" % (oname, self.name()))
378
270
        # mix arguments and options into one dictionary
379
271
        cmdargs = _match_argform(self.name(), self.takes_args, args)
380
272
        cmdopts = {}
384
276
        all_cmd_args = cmdargs.copy()
385
277
        all_cmd_args.update(cmdopts)
386
278
 
387
 
        self._setup_outf()
 
279
        self._setup_stdout()
388
280
 
389
281
        return self.run(**all_cmd_args)
390
282
    
398
290
        shell error code if not.  It's OK for this method to allow
399
291
        an exception to raise up.
400
292
        """
401
 
        raise NotImplementedError('no implementation of command %r'
 
293
        raise NotImplementedError('no implementation of command %r' 
402
294
                                  % self.name())
403
295
 
404
296
    def help(self):
411
303
    def name(self):
412
304
        return _unsquish_command_name(self.__class__.__name__)
413
305
 
414
 
    def plugin_name(self):
415
 
        """Get the name of the plugin that provides this command.
416
 
 
417
 
        :return: The name of the plugin or None if the command is builtin.
418
 
        """
419
 
        mod_parts = self.__module__.split('.')
420
 
        if len(mod_parts) >= 3 and mod_parts[1] == 'plugins':
421
 
            return mod_parts[2]
422
 
        else:
423
 
            return None
424
 
 
425
 
 
426
 
# Technically, this function hasn't been use in a *really* long time
427
 
# but we are only deprecating it now.
428
 
@deprecated_function(zero_eleven)
 
306
 
429
307
def parse_spec(spec):
430
308
    """
431
309
    >>> parse_spec(None)
465
343
    lookup table, something about the available options, what optargs
466
344
    they take, and which commands will accept them.
467
345
    """
468
 
    # TODO: make it a method of the Command?
469
 
    parser = option.get_optparser(command.options())
470
 
    if alias_argv is not None:
471
 
        args = alias_argv + argv
472
 
    else:
473
 
        args = argv
474
 
 
475
 
    options, args = parser.parse_args(args)
476
 
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if
477
 
                 v is not option.OptionParser.DEFAULT_VALUE])
 
346
    # TODO: chop up this beast; make it a method of the Command
 
347
    args = []
 
348
    opts = {}
 
349
    alias_opts = {}
 
350
 
 
351
    cmd_options = command.options()
 
352
    argsover = False
 
353
    proc_aliasarg = True # Are we processing alias_argv now?
 
354
    for proc_argv in alias_argv, argv:
 
355
        while proc_argv:
 
356
            a = proc_argv.pop(0)
 
357
            if argsover:
 
358
                args.append(a)
 
359
                continue
 
360
            elif a == '--':
 
361
                # We've received a standalone -- No more flags
 
362
                argsover = True
 
363
                continue
 
364
            if a[0] == '-':
 
365
                # option names must not be unicode
 
366
                a = str(a)
 
367
                optarg = None
 
368
                if a[1] == '-':
 
369
                    mutter("  got option %r", a)
 
370
                    if '=' in a:
 
371
                        optname, optarg = a[2:].split('=', 1)
 
372
                    else:
 
373
                        optname = a[2:]
 
374
                    if optname not in cmd_options:
 
375
                        raise BzrOptionError('unknown long option %r for'
 
376
                                             ' command %s' % 
 
377
                                             (a, command.name()))
 
378
                else:
 
379
                    shortopt = a[1:]
 
380
                    if shortopt in Option.SHORT_OPTIONS:
 
381
                        # Multi-character options must have a space to delimit
 
382
                        # their value
 
383
                        # ^^^ what does this mean? mbp 20051014
 
384
                        optname = Option.SHORT_OPTIONS[shortopt].name
 
385
                    else:
 
386
                        # Single character short options, can be chained,
 
387
                        # and have their value appended to their name
 
388
                        shortopt = a[1:2]
 
389
                        if shortopt not in Option.SHORT_OPTIONS:
 
390
                            # We didn't find the multi-character name, and we
 
391
                            # didn't find the single char name
 
392
                            raise BzrError('unknown short option %r' % a)
 
393
                        optname = Option.SHORT_OPTIONS[shortopt].name
 
394
 
 
395
                        if a[2:]:
 
396
                            # There are extra things on this option
 
397
                            # see if it is the value, or if it is another
 
398
                            # short option
 
399
                            optargfn = Option.OPTIONS[optname].type
 
400
                            if optargfn is None:
 
401
                                # This option does not take an argument, so the
 
402
                                # next entry is another short option, pack it
 
403
                                # back into the list
 
404
                                proc_argv.insert(0, '-' + a[2:])
 
405
                            else:
 
406
                                # This option takes an argument, so pack it
 
407
                                # into the array
 
408
                                optarg = a[2:]
 
409
                
 
410
                    if optname not in cmd_options:
 
411
                        raise BzrOptionError('unknown short option %r for'
 
412
                                             ' command %s' % 
 
413
                                             (shortopt, command.name()))
 
414
                if optname in opts:
 
415
                    # XXX: Do we ever want to support this, e.g. for -r?
 
416
                    if proc_aliasarg:
 
417
                        raise BzrError('repeated option %r' % a)
 
418
                    elif optname in alias_opts:
 
419
                        # Replace what's in the alias with what's in the real
 
420
                        # argument
 
421
                        del alias_opts[optname]
 
422
                        del opts[optname]
 
423
                        proc_argv.insert(0, a)
 
424
                        continue
 
425
                    else:
 
426
                        raise BzrError('repeated option %r' % a)
 
427
                    
 
428
                option_obj = cmd_options[optname]
 
429
                optargfn = option_obj.type
 
430
                if optargfn:
 
431
                    if optarg == None:
 
432
                        if not proc_argv:
 
433
                            raise BzrError('option %r needs an argument' % a)
 
434
                        else:
 
435
                            optarg = proc_argv.pop(0)
 
436
                    opts[optname] = optargfn(optarg)
 
437
                    if proc_aliasarg:
 
438
                        alias_opts[optname] = optargfn(optarg)
 
439
                else:
 
440
                    if optarg != None:
 
441
                        raise BzrError('option %r takes no argument' % optname)
 
442
                    opts[optname] = True
 
443
                    if proc_aliasarg:
 
444
                        alias_opts[optname] = True
 
445
            else:
 
446
                args.append(a)
 
447
        proc_aliasarg = False # Done with alias argv
478
448
    return args, opts
479
449
 
480
450
 
495
465
                argdict[argname + '_list'] = None
496
466
        elif ap[-1] == '+':
497
467
            if not args:
498
 
                raise errors.BzrCommandError("command %r needs one or more %s"
499
 
                                             % (cmd, argname.upper()))
 
468
                raise BzrCommandError("command %r needs one or more %s"
 
469
                        % (cmd, argname.upper()))
500
470
            else:
501
471
                argdict[argname + '_list'] = args[:]
502
472
                args = []
503
473
        elif ap[-1] == '$': # all but one
504
474
            if len(args) < 2:
505
 
                raise errors.BzrCommandError("command %r needs one or more %s"
506
 
                                             % (cmd, argname.upper()))
 
475
                raise BzrCommandError("command %r needs one or more %s"
 
476
                        % (cmd, argname.upper()))
507
477
            argdict[argname + '_list'] = args[:-1]
508
 
            args[:-1] = []
 
478
            args[:-1] = []                
509
479
        else:
510
480
            # just a plain arg
511
481
            argname = ap
512
482
            if not args:
513
 
                raise errors.BzrCommandError("command %r requires argument %s"
514
 
                               % (cmd, argname.upper()))
 
483
                raise BzrCommandError("command %r requires argument %s"
 
484
                        % (cmd, argname.upper()))
515
485
            else:
516
486
                argdict[argname] = args.pop(0)
517
487
            
518
488
    if args:
519
 
        raise errors.BzrCommandError("extra argument to command %s: %s"
520
 
                                     % (cmd, args[0]))
 
489
        raise BzrCommandError("extra argument to command %s: %s"
 
490
                              % (cmd, args[0]))
521
491
 
522
492
    return argdict
523
493
 
548
518
 
549
519
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
550
520
    from bzrlib.lsprof import profile
 
521
    import cPickle
551
522
    ret, stats = profile(the_callable, *args, **kwargs)
552
523
    stats.sort()
553
524
    if filename is None:
554
525
        stats.pprint()
555
526
    else:
556
 
        stats.save(filename)
557
 
        trace.note('Profile data written to "%s".', filename)
 
527
        stats.freeze()
 
528
        cPickle.dump(stats, open(filename, 'w'), 2)
 
529
        print 'Profile data written to %r.' % filename
558
530
    return ret
559
531
 
560
532
 
561
 
def get_alias(cmd, config=None):
562
 
    """Return an expanded alias, or None if no alias exists.
563
 
 
564
 
    cmd
565
 
        Command to be checked for an alias.
566
 
    config
567
 
        Used to specify an alternative config to use,
568
 
        which is especially useful for testing.
569
 
        If it is unspecified, the global config will be used.
570
 
    """
571
 
    if config is None:
572
 
        import bzrlib.config
573
 
        config = bzrlib.config.GlobalConfig()
574
 
    alias = config.get_alias(cmd)
 
533
def get_alias(cmd):
 
534
    """Return an expanded alias, or None if no alias exists"""
 
535
    import bzrlib.config
 
536
    alias = bzrlib.config.GlobalConfig().get_alias(cmd)
575
537
    if (alias):
576
 
        import shlex
577
 
        return [a.decode('utf-8') for a in shlex.split(alias.encode('utf-8'))]
 
538
        return alias.split(' ')
578
539
    return None
579
540
 
580
541
 
611
572
        Run under the Python lsprof profiler.
612
573
    """
613
574
    argv = list(argv)
614
 
    trace.mutter("bzr arguments: %r", argv)
615
575
 
616
576
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
617
577
                opt_no_aliases = False
630
590
        elif a == '--lsprof':
631
591
            opt_lsprof = True
632
592
        elif a == '--lsprof-file':
633
 
            opt_lsprof = True
634
593
            opt_lsprof_file = argv[i + 1]
635
594
            i += 1
636
595
        elif a == '--no-plugins':
640
599
        elif a == '--builtin':
641
600
            opt_builtin = True
642
601
        elif a in ('--quiet', '-q'):
643
 
            trace.be_quiet()
644
 
        elif a.startswith('-D'):
645
 
            debug.debug_flags.add(a[2:])
 
602
            be_quiet()
646
603
        else:
647
604
            argv_copy.append(a)
648
605
        i += 1
654
611
        return 0
655
612
 
656
613
    if argv[0] == '--version':
657
 
        from bzrlib.version import show_version
 
614
        from bzrlib.builtins import show_version
658
615
        show_version()
659
616
        return 0
660
617
        
673
630
            alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
674
631
            argv[0] = alias_argv.pop(0)
675
632
 
676
 
    cmd = argv.pop(0)
677
 
    # We want only 'ascii' command names, but the user may have typed
678
 
    # in a Unicode name. In that case, they should just get a
679
 
    # 'command not found' error later.
 
633
    cmd = str(argv.pop(0))
680
634
 
681
635
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
682
 
    run = cmd_obj.run_argv_aliases
683
 
    run_argv = [argv, alias_argv]
 
636
    if not getattr(cmd_obj.run_argv, 'is_deprecated', False):
 
637
        run = cmd_obj.run_argv
 
638
        run_argv = [argv]
 
639
    else:
 
640
        run = cmd_obj.run_argv_aliases
 
641
        run_argv = [argv, alias_argv]
684
642
 
685
643
    try:
686
644
        if opt_lsprof:
692
650
        return ret or 0
693
651
    finally:
694
652
        # reset, in case we may do other commands later within the same process
695
 
        trace.be_quiet(False)
 
653
        be_quiet(False)
696
654
 
697
655
def display_command(func):
698
656
    """Decorator that suppresses pipe/interrupt errors."""
702
660
            sys.stdout.flush()
703
661
            return result
704
662
        except IOError, e:
705
 
            if getattr(e, 'errno', None) is None:
 
663
            if not hasattr(e, 'errno'):
706
664
                raise
707
665
            if e.errno != errno.EPIPE:
708
 
                # Win32 raises IOError with errno=0 on a broken pipe
709
 
                if sys.platform != 'win32' or (e.errno not in (0, errno.EINVAL)):
710
 
                    raise
 
666
                raise
711
667
            pass
712
668
        except KeyboardInterrupt:
713
669
            pass
717
673
def main(argv):
718
674
    import bzrlib.ui
719
675
    from bzrlib.ui.text import TextUIFactory
 
676
    ## bzrlib.trace.enable_default_logging()
 
677
    bzrlib.trace.log_startup(argv)
720
678
    bzrlib.ui.ui_factory = TextUIFactory()
 
679
 
721
680
    argv = [a.decode(bzrlib.user_encoding) for a in argv[1:]]
722
681
    ret = run_bzr_catch_errors(argv)
723
 
    trace.mutter("return code %d", ret)
 
682
    mutter("return code %d", ret)
724
683
    return ret
725
684
 
726
685
 
727
686
def run_bzr_catch_errors(argv):
728
687
    try:
729
 
        return run_bzr(argv)
730
 
    except (KeyboardInterrupt, Exception), e:
 
688
        try:
 
689
            return run_bzr(argv)
 
690
        finally:
 
691
            # do this here inside the exception wrappers to catch EPIPE
 
692
            sys.stdout.flush()
 
693
    except Exception, e:
731
694
        # used to handle AssertionError and KeyboardInterrupt
732
695
        # specially here, but hopefully they're handled ok by the logger now
733
 
        trace.report_exception(sys.exc_info(), sys.stderr)
734
 
        if os.environ.get('BZR_PDB'):
735
 
            print '**** entering debugger'
736
 
            import pdb
737
 
            pdb.post_mortem(sys.exc_traceback)
738
 
        return 3
739
 
 
740
 
 
741
 
class HelpCommandIndex(object):
742
 
    """A index for bzr help that returns commands."""
743
 
 
744
 
    def __init__(self):
745
 
        self.prefix = 'commands/'
746
 
 
747
 
    def get_topics(self, topic):
748
 
        """Search for topic amongst commands.
749
 
 
750
 
        :param topic: A topic to search for.
751
 
        :return: A list which is either empty or contains a single
752
 
            Command entry.
753
 
        """
754
 
        if topic and topic.startswith(self.prefix):
755
 
            topic = topic[len(self.prefix):]
756
 
        try:
757
 
            cmd = _get_cmd_object(topic)
758
 
        except KeyError:
759
 
            return []
 
696
        import errno
 
697
        if (isinstance(e, IOError) 
 
698
            and hasattr(e, 'errno')
 
699
            and e.errno == errno.EPIPE):
 
700
            bzrlib.trace.note('broken pipe')
 
701
            return 3
760
702
        else:
761
 
            return [cmd]
762
 
 
 
703
            bzrlib.trace.log_exception()
 
704
            if os.environ.get('BZR_PDB'):
 
705
                print '**** entering debugger'
 
706
                import pdb
 
707
                pdb.post_mortem(sys.exc_traceback)
 
708
            return 3
763
709
 
764
710
if __name__ == '__main__':
765
711
    sys.exit(main(sys.argv))