← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-03-22 12:17:00 UTC
  • mfrom: (1616.1.10 bzr.mbp.integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060322121700-79ce0be81013aba1
(mbp) pycurl fixes, other fixes, weave commands, verbose commit changes from robert

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(), """
36
 
import codecs
 
33
from warnings import warn
37
34
import errno
38
 
from warnings import warn
39
35
 
40
36
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
 
37
from bzrlib.errors import (BzrError, 
 
38
                           BzrCheckError,
 
39
                           BzrCommandError,
 
40
                           BzrOptionError,
 
41
                           NotBranchError)
58
42
from bzrlib.option import Option
59
 
 
 
43
from bzrlib.revisionspec import RevisionSpec
 
44
from bzrlib.symbol_versioning import *
 
45
import bzrlib.trace
 
46
from bzrlib.trace import mutter, note, log_error, warning, be_quiet
60
47
 
61
48
plugin_cmds = {}
62
49
 
75
62
        k_unsquished = _unsquish_command_name(k)
76
63
    else:
77
64
        k_unsquished = k
78
 
    if k_unsquished not in plugin_cmds:
 
65
    if not plugin_cmds.has_key(k_unsquished):
79
66
        plugin_cmds[k_unsquished] = cmd
80
 
        ## trace.mutter('registered plugin command %s', k_unsquished)
 
67
        mutter('registered plugin command %s', k_unsquished)
81
68
        if decorate and k_unsquished in builtin_command_names():
82
69
            return _builtin_commands()[k_unsquished]
83
70
    elif decorate:
85
72
        plugin_cmds[k_unsquished] = cmd
86
73
        return result
87
74
    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__])
 
75
        log_error('Two plugins defined the same command: %r' % k)
 
76
        log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
90
77
 
91
78
 
92
79
def _squish_command_name(cmd):
138
125
    plugins_override
139
126
        If true, plugin commands can override builtins.
140
127
    """
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
128
    from bzrlib.externalcommand import ExternalCommand
150
129
 
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.
 
130
    cmd_name = str(cmd_name)            # not unicode
155
131
 
156
132
    # first look up this command under the specified name
157
133
    cmds = _get_cmd_dict(plugins_override=plugins_override)
168
144
    cmd_obj = ExternalCommand.find_command(cmd_name)
169
145
    if cmd_obj:
170
146
        return cmd_obj
171
 
    raise KeyError
 
147
 
 
148
    raise BzrCommandError("unknown command %r" % cmd_name)
172
149
 
173
150
 
174
151
class Command(object):
212
189
    hidden
213
190
        If true, this command isn't advertised.  This is typically
214
191
        for commands intended for expert users.
215
 
 
216
 
    encoding_type
217
 
        Command objects will get a 'outf' attribute, which has been
218
 
        setup to properly handle encoding of unicode strings.
219
 
        encoding_type determines what will happen when characters cannot
220
 
        be encoded
221
 
            strict - abort if we cannot decode
222
 
            replace - put in a bogus character (typically '?')
223
 
            exact - do not encode sys.stdout
224
 
 
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
192
    """
232
193
    aliases = []
233
194
    takes_args = []
234
195
    takes_options = []
235
 
    encoding_type = 'strict'
236
196
 
237
197
    hidden = False
238
198
    
241
201
        if self.__doc__ == Command.__doc__:
242
202
            warn("No help message set for %r" % self)
243
203
 
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
204
    def options(self):
331
205
        """Return dict of valid options for this command.
332
206
 
333
207
        Maps from long option name to option object."""
334
208
        r = dict()
335
 
        r['help'] = option._help_option
 
209
        r['help'] = Option.OPTIONS['help']
336
210
        for o in self.takes_options:
337
 
            if isinstance(o, basestring):
338
 
                o = option.Option.OPTIONS[o]
 
211
            if not isinstance(o, Option):
 
212
                o = Option.OPTIONS[o]
339
213
            r[o.name] = o
340
214
        return r
341
215
 
342
 
    def _setup_outf(self):
343
 
        """Return a file linked to stdout, which has proper encoding."""
344
 
        assert self.encoding_type in ['strict', 'exact', 'replace']
345
 
 
346
 
        # Originally I was using self.stdout, but that looks
347
 
        # *way* too much like sys.stdout
348
 
        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
 
            self.outf = sys.stdout
356
 
            return
357
 
 
358
 
        output_encoding = osutils.get_terminal_encoding()
359
 
 
360
 
        # use 'replace' so that we don't abort if trying to write out
361
 
        # in e.g. the default C locale.
362
 
        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
 
216
    @deprecated_method(zero_eight)
 
217
    def run_argv(self, argv):
 
218
        """Parse command line and run.
 
219
        
 
220
        See run_argv_aliases for the 0.8 and beyond api.
 
221
        """
 
222
        return self.run_argv_aliases(argv)
367
223
 
368
224
    def run_argv_aliases(self, argv, alias_argv=None):
369
225
        """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
226
        args, opts = parse_args(self, argv, alias_argv)
375
227
        if 'help' in opts:  # e.g. bzr add --help
376
 
            sys.stdout.write(self.get_help_text())
 
228
            from bzrlib.help import help_on_command
 
229
            help_on_command(self.name())
377
230
            return 0
 
231
        # XXX: This should be handled by the parser
 
232
        allowed_names = self.options().keys()
 
233
        for oname in opts:
 
234
            if oname not in allowed_names:
 
235
                raise BzrCommandError("option '--%s' is not allowed for"
 
236
                                      " command %r" % (oname, self.name()))
378
237
        # mix arguments and options into one dictionary
379
238
        cmdargs = _match_argform(self.name(), self.takes_args, args)
380
239
        cmdopts = {}
384
243
        all_cmd_args = cmdargs.copy()
385
244
        all_cmd_args.update(cmdopts)
386
245
 
387
 
        self._setup_outf()
388
 
 
389
246
        return self.run(**all_cmd_args)
390
247
    
391
248
    def run(self):
398
255
        shell error code if not.  It's OK for this method to allow
399
256
        an exception to raise up.
400
257
        """
401
 
        raise NotImplementedError('no implementation of command %r'
 
258
        raise NotImplementedError('no implementation of command %r' 
402
259
                                  % self.name())
403
260
 
404
261
    def help(self):
411
268
    def name(self):
412
269
        return _unsquish_command_name(self.__class__.__name__)
413
270
 
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)
 
271
 
429
272
def parse_spec(spec):
430
273
    """
431
274
    >>> parse_spec(None)
465
308
    lookup table, something about the available options, what optargs
466
309
    they take, and which commands will accept them.
467
310
    """
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])
 
311
    # TODO: chop up this beast; make it a method of the Command
 
312
    args = []
 
313
    opts = {}
 
314
    alias_opts = {}
 
315
 
 
316
    cmd_options = command.options()
 
317
    argsover = False
 
318
    proc_aliasarg = True # Are we processing alias_argv now?
 
319
    for proc_argv in alias_argv, argv:
 
320
        while proc_argv:
 
321
            a = proc_argv.pop(0)
 
322
            if argsover:
 
323
                args.append(a)
 
324
                continue
 
325
            elif a == '--':
 
326
                # We've received a standalone -- No more flags
 
327
                argsover = True
 
328
                continue
 
329
            if a[0] == '-':
 
330
                # option names must not be unicode
 
331
                a = str(a)
 
332
                optarg = None
 
333
                if a[1] == '-':
 
334
                    mutter("  got option %r", a)
 
335
                    if '=' in a:
 
336
                        optname, optarg = a[2:].split('=', 1)
 
337
                    else:
 
338
                        optname = a[2:]
 
339
                    if optname not in cmd_options:
 
340
                        raise BzrOptionError('unknown long option %r for'
 
341
                                             ' command %s' % 
 
342
                                             (a, command.name()))
 
343
                else:
 
344
                    shortopt = a[1:]
 
345
                    if shortopt in Option.SHORT_OPTIONS:
 
346
                        # Multi-character options must have a space to delimit
 
347
                        # their value
 
348
                        # ^^^ what does this mean? mbp 20051014
 
349
                        optname = Option.SHORT_OPTIONS[shortopt].name
 
350
                    else:
 
351
                        # Single character short options, can be chained,
 
352
                        # and have their value appended to their name
 
353
                        shortopt = a[1:2]
 
354
                        if shortopt not in Option.SHORT_OPTIONS:
 
355
                            # We didn't find the multi-character name, and we
 
356
                            # didn't find the single char name
 
357
                            raise BzrError('unknown short option %r' % a)
 
358
                        optname = Option.SHORT_OPTIONS[shortopt].name
 
359
 
 
360
                        if a[2:]:
 
361
                            # There are extra things on this option
 
362
                            # see if it is the value, or if it is another
 
363
                            # short option
 
364
                            optargfn = Option.OPTIONS[optname].type
 
365
                            if optargfn is None:
 
366
                                # This option does not take an argument, so the
 
367
                                # next entry is another short option, pack it
 
368
                                # back into the list
 
369
                                proc_argv.insert(0, '-' + a[2:])
 
370
                            else:
 
371
                                # This option takes an argument, so pack it
 
372
                                # into the array
 
373
                                optarg = a[2:]
 
374
                
 
375
                    if optname not in cmd_options:
 
376
                        raise BzrOptionError('unknown short option %r for'
 
377
                                             ' command %s' % 
 
378
                                             (shortopt, command.name()))
 
379
                if optname in opts:
 
380
                    # XXX: Do we ever want to support this, e.g. for -r?
 
381
                    if proc_aliasarg:
 
382
                        raise BzrError('repeated option %r' % a)
 
383
                    elif optname in alias_opts:
 
384
                        # Replace what's in the alias with what's in the real
 
385
                        # argument
 
386
                        del alias_opts[optname]
 
387
                        del opts[optname]
 
388
                        proc_argv.insert(0, a)
 
389
                        continue
 
390
                    else:
 
391
                        raise BzrError('repeated option %r' % a)
 
392
                    
 
393
                option_obj = cmd_options[optname]
 
394
                optargfn = option_obj.type
 
395
                if optargfn:
 
396
                    if optarg == None:
 
397
                        if not proc_argv:
 
398
                            raise BzrError('option %r needs an argument' % a)
 
399
                        else:
 
400
                            optarg = proc_argv.pop(0)
 
401
                    opts[optname] = optargfn(optarg)
 
402
                    if proc_aliasarg:
 
403
                        alias_opts[optname] = optargfn(optarg)
 
404
                else:
 
405
                    if optarg != None:
 
406
                        raise BzrError('option %r takes no argument' % optname)
 
407
                    opts[optname] = True
 
408
                    if proc_aliasarg:
 
409
                        alias_opts[optname] = True
 
410
            else:
 
411
                args.append(a)
 
412
        proc_aliasarg = False # Done with alias argv
478
413
    return args, opts
479
414
 
480
415
 
495
430
                argdict[argname + '_list'] = None
496
431
        elif ap[-1] == '+':
497
432
            if not args:
498
 
                raise errors.BzrCommandError("command %r needs one or more %s"
499
 
                                             % (cmd, argname.upper()))
 
433
                raise BzrCommandError("command %r needs one or more %s"
 
434
                        % (cmd, argname.upper()))
500
435
            else:
501
436
                argdict[argname + '_list'] = args[:]
502
437
                args = []
503
438
        elif ap[-1] == '$': # all but one
504
439
            if len(args) < 2:
505
 
                raise errors.BzrCommandError("command %r needs one or more %s"
506
 
                                             % (cmd, argname.upper()))
 
440
                raise BzrCommandError("command %r needs one or more %s"
 
441
                        % (cmd, argname.upper()))
507
442
            argdict[argname + '_list'] = args[:-1]
508
 
            args[:-1] = []
 
443
            args[:-1] = []                
509
444
        else:
510
445
            # just a plain arg
511
446
            argname = ap
512
447
            if not args:
513
 
                raise errors.BzrCommandError("command %r requires argument %s"
514
 
                               % (cmd, argname.upper()))
 
448
                raise BzrCommandError("command %r requires argument %s"
 
449
                        % (cmd, argname.upper()))
515
450
            else:
516
451
                argdict[argname] = args.pop(0)
517
452
            
518
453
    if args:
519
 
        raise errors.BzrCommandError("extra argument to command %s: %s"
520
 
                                     % (cmd, args[0]))
 
454
        raise BzrCommandError("extra argument to command %s: %s"
 
455
                              % (cmd, args[0]))
521
456
 
522
457
    return argdict
523
458
 
548
483
 
549
484
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
550
485
    from bzrlib.lsprof import profile
 
486
    import cPickle
551
487
    ret, stats = profile(the_callable, *args, **kwargs)
552
488
    stats.sort()
553
489
    if filename is None:
554
490
        stats.pprint()
555
491
    else:
556
 
        stats.save(filename)
557
 
        trace.note('Profile data written to "%s".', filename)
 
492
        stats.freeze()
 
493
        cPickle.dump(stats, open(filename, 'w'), 2)
 
494
        print 'Profile data written to %r.' % filename
558
495
    return ret
559
496
 
560
497
 
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)
 
498
def get_alias(cmd):
 
499
    """Return an expanded alias, or None if no alias exists"""
 
500
    import bzrlib.config
 
501
    alias = bzrlib.config.GlobalConfig().get_alias(cmd)
575
502
    if (alias):
576
 
        import shlex
577
 
        return [a.decode('utf-8') for a in shlex.split(alias.encode('utf-8'))]
 
503
        return alias.split(' ')
578
504
    return None
579
505
 
580
506
 
586
512
    
587
513
    argv
588
514
       The command-line arguments, without the program name from argv[0]
589
 
       These should already be decoded. All library/test code calling
590
 
       run_bzr should be passing valid strings (don't need decoding).
591
515
    
592
516
    Returns a command status or raises an exception.
593
517
 
610
534
    --lsprof
611
535
        Run under the Python lsprof profiler.
612
536
    """
613
 
    argv = list(argv)
614
 
    trace.mutter("bzr arguments: %r", argv)
 
537
    argv = [a.decode(bzrlib.user_encoding) for a in argv]
615
538
 
616
539
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
617
540
                opt_no_aliases = False
630
553
        elif a == '--lsprof':
631
554
            opt_lsprof = True
632
555
        elif a == '--lsprof-file':
633
 
            opt_lsprof = True
634
556
            opt_lsprof_file = argv[i + 1]
635
557
            i += 1
636
558
        elif a == '--no-plugins':
640
562
        elif a == '--builtin':
641
563
            opt_builtin = True
642
564
        elif a in ('--quiet', '-q'):
643
 
            trace.be_quiet()
644
 
        elif a.startswith('-D'):
645
 
            debug.debug_flags.add(a[2:])
 
565
            be_quiet()
646
566
        else:
647
567
            argv_copy.append(a)
648
568
        i += 1
649
569
 
650
570
    argv = argv_copy
651
 
    if (not argv):
652
 
        from bzrlib.builtins import cmd_help
653
 
        cmd_help().run_argv_aliases([])
 
571
    if (not argv) or (argv[0] == '--help'):
 
572
        from bzrlib.help import help
 
573
        if len(argv) > 1:
 
574
            help(argv[1])
 
575
        else:
 
576
            help()
654
577
        return 0
655
578
 
656
579
    if argv[0] == '--version':
657
 
        from bzrlib.version import show_version
 
580
        from bzrlib.builtins import show_version
658
581
        show_version()
659
582
        return 0
660
583
        
673
596
            alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
674
597
            argv[0] = alias_argv.pop(0)
675
598
 
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.
 
599
    cmd = str(argv.pop(0))
680
600
 
681
601
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
682
 
    run = cmd_obj.run_argv_aliases
683
 
    run_argv = [argv, alias_argv]
 
602
    if not getattr(cmd_obj.run_argv, 'is_deprecated', False):
 
603
        run = cmd_obj.run_argv
 
604
        run_argv = [argv]
 
605
    else:
 
606
        run = cmd_obj.run_argv_aliases
 
607
        run_argv = [argv, alias_argv]
684
608
 
685
609
    try:
686
610
        if opt_lsprof:
692
616
        return ret or 0
693
617
    finally:
694
618
        # reset, in case we may do other commands later within the same process
695
 
        trace.be_quiet(False)
 
619
        be_quiet(False)
696
620
 
697
621
def display_command(func):
698
622
    """Decorator that suppresses pipe/interrupt errors."""
702
626
            sys.stdout.flush()
703
627
            return result
704
628
        except IOError, e:
705
 
            if getattr(e, 'errno', None) is None:
 
629
            if not hasattr(e, 'errno'):
706
630
                raise
707
631
            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
 
632
                raise
711
633
            pass
712
634
        except KeyboardInterrupt:
713
635
            pass
717
639
def main(argv):
718
640
    import bzrlib.ui
719
641
    from bzrlib.ui.text import TextUIFactory
 
642
    ## bzrlib.trace.enable_default_logging()
 
643
    bzrlib.trace.log_startup(argv)
720
644
    bzrlib.ui.ui_factory = TextUIFactory()
721
 
    argv = [a.decode(bzrlib.user_encoding) for a in argv[1:]]
722
 
    ret = run_bzr_catch_errors(argv)
723
 
    trace.mutter("return code %d", ret)
 
645
    ret = run_bzr_catch_errors(argv[1:])
 
646
    mutter("return code %d", ret)
724
647
    return ret
725
648
 
726
649
 
727
650
def run_bzr_catch_errors(argv):
728
651
    try:
729
 
        return run_bzr(argv)
730
 
    except (KeyboardInterrupt, Exception), e:
 
652
        try:
 
653
            return run_bzr(argv)
 
654
        finally:
 
655
            # do this here inside the exception wrappers to catch EPIPE
 
656
            sys.stdout.flush()
 
657
    except Exception, e:
731
658
        # used to handle AssertionError and KeyboardInterrupt
732
659
        # 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 []
 
660
        import errno
 
661
        if (isinstance(e, IOError) 
 
662
            and hasattr(e, 'errno')
 
663
            and e.errno == errno.EPIPE):
 
664
            bzrlib.trace.note('broken pipe')
 
665
            return 3
760
666
        else:
761
 
            return [cmd]
762
 
 
 
667
            bzrlib.trace.log_exception()
 
668
            if os.environ.get('BZR_PDB'):
 
669
                print '**** entering debugger'
 
670
                import pdb
 
671
                pdb.post_mortem(sys.exc_traceback)
 
672
            return 3
763
673
 
764
674
if __name__ == '__main__':
765
675
    sys.exit(main(sys.argv))