← 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-06-20 03:50:35 UTC
  • mfrom: (1740.5.9 bzr.mbp.traceback)
  • Revision ID: pqm@pqm.ubuntu.com-20060620035035-a9a7dc096fed5060
(mbp) show traceback on stderr on unexpected errors

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commands.py
1
 
# Copyright (C) 2004, 2005 by Canonical Ltd
2
 
 
 
1
# Copyright (C) 2006 by Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
18
# TODO: probably should say which arguments are candidates for glob
19
19
# expansion on windows and do that at the command level.
20
20
 
21
 
# TODO: Help messages for options.
22
 
 
23
21
# TODO: Define arguments by objects, rather than just using names.
24
22
# Those objects can specify the expected type of the argument, which
25
 
# would help with validation and shell completion.
 
23
# would help with validation and shell completion.  They could also provide
 
24
# help/explanation for that argument in a structured way.
 
25
 
 
26
# TODO: Specific "examples" property on commands for consistent formatting.
26
27
 
27
28
# TODO: "--profile=cum", to change sort order.  Is there any value in leaving
28
29
# the profile output behind so it can be interactively examined?
30
31
import sys
31
32
import os
32
33
from warnings import warn
33
 
from inspect import getdoc
34
34
import errno
 
35
import codecs
35
36
 
36
37
import bzrlib
37
 
import bzrlib.trace
38
 
from bzrlib.trace import mutter, note, log_error, warning, be_quiet
39
 
from bzrlib.errors import (BzrError, 
 
38
import bzrlib.errors as errors
 
39
from bzrlib.errors import (BzrError,
 
40
                           BzrCommandError,
40
41
                           BzrCheckError,
41
 
                           BzrCommandError,
42
 
                           BzrOptionError,
43
42
                           NotBranchError)
 
43
from bzrlib.option import Option
 
44
import bzrlib.osutils
44
45
from bzrlib.revisionspec import RevisionSpec
45
 
from bzrlib import BZRDIR
46
 
from bzrlib.option import Option
 
46
from bzrlib.symbol_versioning import *
 
47
import bzrlib.trace
 
48
from bzrlib.trace import mutter, note, log_error, warning, be_quiet
47
49
 
48
50
plugin_cmds = {}
49
51
 
50
52
 
51
53
def register_command(cmd, decorate=False):
52
 
    "Utility function to help register a command"
 
54
    """Utility function to help register a command
 
55
 
 
56
    :param cmd: Command subclass to register
 
57
    :param decorate: If true, allow overriding an existing command
 
58
        of the same name; the old command is returned by this function.
 
59
        Otherwise it is an error to try to override an existing command.
 
60
    """
53
61
    global plugin_cmds
54
62
    k = cmd.__name__
55
63
    if k.startswith("cmd_"):
58
66
        k_unsquished = k
59
67
    if not plugin_cmds.has_key(k_unsquished):
60
68
        plugin_cmds[k_unsquished] = cmd
61
 
        mutter('registered plugin command %s', k_unsquished)      
 
69
        mutter('registered plugin command %s', k_unsquished)
62
70
        if decorate and k_unsquished in builtin_command_names():
63
71
            return _builtin_commands()[k_unsquished]
64
72
    elif decorate:
85
93
    builtins = bzrlib.builtins.__dict__
86
94
    for name in builtins:
87
95
        if name.startswith("cmd_"):
88
 
            real_name = _unsquish_command_name(name)        
 
96
            real_name = _unsquish_command_name(name)
89
97
            r[real_name] = builtins[name]
90
98
    return r
91
 
 
92
99
            
93
100
 
94
101
def builtin_command_names():
140
147
    if cmd_obj:
141
148
        return cmd_obj
142
149
 
143
 
    raise BzrCommandError("unknown command %r" % cmd_name)
 
150
    raise BzrCommandError('unknown command "%s"' % cmd_name)
144
151
 
145
152
 
146
153
class Command(object):
168
175
        List of argument forms, marked with whether they are optional,
169
176
        repeated, etc.
170
177
 
171
 
                Examples:
172
 
 
173
 
                ['to_location', 'from_branch?', 'file*']
174
 
 
175
 
                'to_location' is required
176
 
                'from_branch' is optional
177
 
                'file' can be specified 0 or more times
 
178
                Examples:
 
179
 
 
180
                ['to_location', 'from_branch?', 'file*']
 
181
 
 
182
                'to_location' is required
 
183
                'from_branch' is optional
 
184
                'file' can be specified 0 or more times
178
185
 
179
186
    takes_options
180
187
        List of options that may be given for this command.  These can
184
191
    hidden
185
192
        If true, this command isn't advertised.  This is typically
186
193
        for commands intended for expert users.
 
194
 
 
195
    encoding_type
 
196
        Command objects will get a 'outf' attribute, which has been
 
197
        setup to properly handle encoding of unicode strings.
 
198
        encoding_type determines what will happen when characters cannot
 
199
        be encoded
 
200
            strict - abort if we cannot decode
 
201
            replace - put in a bogus character (typically '?')
 
202
            exact - do not encode sys.stdout
 
203
 
187
204
    """
188
205
    aliases = []
189
206
    takes_args = []
190
207
    takes_options = []
 
208
    encoding_type = 'strict'
191
209
 
192
210
    hidden = False
193
211
    
208
226
            r[o.name] = o
209
227
        return r
210
228
 
 
229
    def _setup_outf(self):
 
230
        """Return a file linked to stdout, which has proper encoding."""
 
231
        assert self.encoding_type in ['strict', 'exact', 'replace']
 
232
 
 
233
        # Originally I was using self.stdout, but that looks
 
234
        # *way* too much like sys.stdout
 
235
        if self.encoding_type == 'exact':
 
236
            self.outf = sys.stdout
 
237
            return
 
238
 
 
239
        output_encoding = bzrlib.osutils.get_terminal_encoding()
 
240
 
 
241
        # use 'replace' so that we don't abort if trying to write out
 
242
        # in e.g. the default C locale.
 
243
        self.outf = codecs.getwriter(output_encoding)(sys.stdout, errors=self.encoding_type)
 
244
        # For whatever reason codecs.getwriter() does not advertise its encoding
 
245
        # it just returns the encoding of the wrapped file, which is completely
 
246
        # bogus. So set the attribute, so we can find the correct encoding later.
 
247
        self.outf.encoding = output_encoding
 
248
 
 
249
    @deprecated_method(zero_eight)
211
250
    def run_argv(self, argv):
212
 
        """Parse command line and run."""
213
 
        args, opts = parse_args(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)
 
256
 
 
257
    def run_argv_aliases(self, argv, alias_argv=None):
 
258
        """Parse the command line and run with extra aliases in alias_argv."""
 
259
        args, opts = parse_args(self, argv, alias_argv)
214
260
        if 'help' in opts:  # e.g. bzr add --help
215
261
            from bzrlib.help import help_on_command
216
262
            help_on_command(self.name())
219
265
        allowed_names = self.options().keys()
220
266
        for oname in opts:
221
267
            if oname not in allowed_names:
222
 
                raise BzrCommandError("option '--%s' is not allowed for command %r"
223
 
                                      % (oname, self.name()))
 
268
                raise BzrOptionError("option '--%s' is not allowed for"
 
269
                                " command %r" % (oname, self.name()))
224
270
        # mix arguments and options into one dictionary
225
271
        cmdargs = _match_argform(self.name(), self.takes_args, args)
226
272
        cmdopts = {}
230
276
        all_cmd_args = cmdargs.copy()
231
277
        all_cmd_args.update(cmdopts)
232
278
 
 
279
        self._setup_outf()
 
280
 
233
281
        return self.run(**all_cmd_args)
234
282
    
235
283
    def run(self):
242
290
        shell error code if not.  It's OK for this method to allow
243
291
        an exception to raise up.
244
292
        """
245
 
        raise NotImplementedError()
246
 
 
 
293
        raise NotImplementedError('no implementation of command %r' 
 
294
                                  % self.name())
247
295
 
248
296
    def help(self):
249
297
        """Return help message for this class."""
 
298
        from inspect import getdoc
250
299
        if self.__doc__ is Command.__doc__:
251
300
            return None
252
301
        return getdoc(self)
254
303
    def name(self):
255
304
        return _unsquish_command_name(self.__class__.__name__)
256
305
 
 
306
    def plugin_name(self):
 
307
        """Get the name of the plugin that provides this command.
 
308
 
 
309
        :return: The name of the plugin or None if the command is builtin.
 
310
        """
 
311
        mod_parts = self.__module__.split('.')
 
312
        if len(mod_parts) >= 3 and mod_parts[1] == 'plugins':
 
313
            return mod_parts[2]
 
314
        else:
 
315
            return None
 
316
 
257
317
 
258
318
def parse_spec(spec):
259
319
    """
286
346
        parsed = [spec, None]
287
347
    return parsed
288
348
 
289
 
def parse_args(command, argv):
 
349
def parse_args(command, argv, alias_argv=None):
290
350
    """Parse command line.
291
351
    
292
352
    Arguments and options are parsed at this level before being passed
297
357
    # TODO: chop up this beast; make it a method of the Command
298
358
    args = []
299
359
    opts = {}
 
360
    alias_opts = {}
300
361
 
301
362
    cmd_options = command.options()
302
363
    argsover = False
303
 
    while argv:
304
 
        a = argv.pop(0)
305
 
        if argsover:
306
 
            args.append(a)
307
 
            continue
308
 
        elif a == '--':
309
 
            # We've received a standalone -- No more flags
310
 
            argsover = True
311
 
            continue
312
 
        if a[0] == '-':
313
 
            # option names must not be unicode
314
 
            a = str(a)
315
 
            optarg = None
316
 
            if a[1] == '-':
317
 
                mutter("  got option %r", a)
318
 
                if '=' in a:
319
 
                    optname, optarg = a[2:].split('=', 1)
320
 
                else:
321
 
                    optname = a[2:]
322
 
                if optname not in cmd_options:
323
 
                    raise BzrOptionError('unknown long option %r for command %s'
324
 
                        % (a, command.name()))
325
 
            else:
326
 
                shortopt = a[1:]
327
 
                if shortopt in Option.SHORT_OPTIONS:
328
 
                    # Multi-character options must have a space to delimit
329
 
                    # their value
330
 
                    # ^^^ what does this mean? mbp 20051014
331
 
                    optname = Option.SHORT_OPTIONS[shortopt].name
332
 
                else:
333
 
                    # Single character short options, can be chained,
334
 
                    # and have their value appended to their name
335
 
                    shortopt = a[1:2]
336
 
                    if shortopt not in Option.SHORT_OPTIONS:
337
 
                        # We didn't find the multi-character name, and we
338
 
                        # didn't find the single char name
339
 
                        raise BzrError('unknown short option %r' % a)
340
 
                    optname = Option.SHORT_OPTIONS[shortopt].name
 
364
    proc_aliasarg = True # Are we processing alias_argv now?
 
365
    for proc_argv in alias_argv, argv:
 
366
        while proc_argv:
 
367
            a = proc_argv.pop(0)
 
368
            if argsover:
 
369
                args.append(a)
 
370
                continue
 
371
            elif a == '--':
 
372
                # We've received a standalone -- No more flags
 
373
                argsover = True
 
374
                continue
 
375
            if a[0] == '-':
 
376
                # option names must not be unicode
 
377
                a = str(a)
 
378
                optarg = None
 
379
                if a[1] == '-':
 
380
                    mutter("  got option %r", a)
 
381
                    if '=' in a:
 
382
                        optname, optarg = a[2:].split('=', 1)
 
383
                    else:
 
384
                        optname = a[2:]
 
385
                    if optname not in cmd_options:
 
386
                        raise BzrCommandError('unknown option "%s"' % a)
 
387
                else:
 
388
                    shortopt = a[1:]
 
389
                    if shortopt in Option.SHORT_OPTIONS:
 
390
                        # Multi-character options must have a space to delimit
 
391
                        # their value
 
392
                        # ^^^ what does this mean? mbp 20051014
 
393
                        optname = Option.SHORT_OPTIONS[shortopt].name
 
394
                    else:
 
395
                        # Single character short options, can be chained,
 
396
                        # and have their value appended to their name
 
397
                        shortopt = a[1:2]
 
398
                        if shortopt not in Option.SHORT_OPTIONS:
 
399
                            # We didn't find the multi-character name, and we
 
400
                            # didn't find the single char name
 
401
                            raise BzrCommandError('unknown option "%s"' % a)
 
402
                        optname = Option.SHORT_OPTIONS[shortopt].name
341
403
 
342
 
                    if a[2:]:
343
 
                        # There are extra things on this option
344
 
                        # see if it is the value, or if it is another
345
 
                        # short option
346
 
                        optargfn = Option.OPTIONS[optname].type
347
 
                        if optargfn is None:
348
 
                            # This option does not take an argument, so the
349
 
                            # next entry is another short option, pack it back
350
 
                            # into the list
351
 
                            argv.insert(0, '-' + a[2:])
 
404
                        if a[2:]:
 
405
                            # There are extra things on this option
 
406
                            # see if it is the value, or if it is another
 
407
                            # short option
 
408
                            optargfn = Option.OPTIONS[optname].type
 
409
                            if optargfn is None:
 
410
                                # This option does not take an argument, so the
 
411
                                # next entry is another short option, pack it
 
412
                                # back into the list
 
413
                                proc_argv.insert(0, '-' + a[2:])
 
414
                            else:
 
415
                                # This option takes an argument, so pack it
 
416
                                # into the array
 
417
                                optarg = a[2:]
 
418
                    if optname not in cmd_options:
 
419
                        raise BzrCommandError('unknown option "%s"' % shortopt)
 
420
                if optname in opts:
 
421
                    # XXX: Do we ever want to support this, e.g. for -r?
 
422
                    if proc_aliasarg:
 
423
                        raise BzrCommandError('repeated option %r' % a)
 
424
                    elif optname in alias_opts:
 
425
                        # Replace what's in the alias with what's in the real
 
426
                        # argument
 
427
                        del alias_opts[optname]
 
428
                        del opts[optname]
 
429
                        proc_argv.insert(0, a)
 
430
                        continue
 
431
                    else:
 
432
                        raise BzrCommandError('repeated option %r' % a)
 
433
                    
 
434
                option_obj = cmd_options[optname]
 
435
                optargfn = option_obj.type
 
436
                if optargfn:
 
437
                    if optarg == None:
 
438
                        if not proc_argv:
 
439
                            raise BzrCommandError('option %r needs an argument' % a)
352
440
                        else:
353
 
                            # This option takes an argument, so pack it
354
 
                            # into the array
355
 
                            optarg = a[2:]
356
 
            
357
 
                if optname not in cmd_options:
358
 
                    raise BzrOptionError('unknown short option %r for command'
359
 
                        ' %s' % (shortopt, command.name()))
360
 
            if optname in opts:
361
 
                # XXX: Do we ever want to support this, e.g. for -r?
362
 
                raise BzrError('repeated option %r' % a)
363
 
                
364
 
            option_obj = cmd_options[optname]
365
 
            optargfn = option_obj.type
366
 
            if optargfn:
367
 
                if optarg == None:
368
 
                    if not argv:
369
 
                        raise BzrError('option %r needs an argument' % a)
370
 
                    else:
371
 
                        optarg = argv.pop(0)
372
 
                opts[optname] = optargfn(optarg)
 
441
                            optarg = proc_argv.pop(0)
 
442
                    opts[optname] = optargfn(optarg)
 
443
                    if proc_aliasarg:
 
444
                        alias_opts[optname] = optargfn(optarg)
 
445
                else:
 
446
                    if optarg != None:
 
447
                        raise BzrCommandError('option %r takes no argument' % optname)
 
448
                    opts[optname] = True
 
449
                    if proc_aliasarg:
 
450
                        alias_opts[optname] = True
373
451
            else:
374
 
                if optarg != None:
375
 
                    raise BzrError('option %r takes no argument' % optname)
376
 
                opts[optname] = True
377
 
        else:
378
 
            args.append(a)
 
452
                args.append(a)
 
453
        proc_aliasarg = False # Done with alias argv
379
454
    return args, opts
380
455
 
381
456
 
406
481
                raise BzrCommandError("command %r needs one or more %s"
407
482
                        % (cmd, argname.upper()))
408
483
            argdict[argname + '_list'] = args[:-1]
409
 
            args[:-1] = []                
 
484
            args[:-1] = []
410
485
        else:
411
486
            # just a plain arg
412
487
            argname = ap
447
522
        os.remove(pfname)
448
523
 
449
524
 
450
 
def apply_lsprofiled(the_callable, *args, **kwargs):
 
525
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
451
526
    from bzrlib.lsprof import profile
452
 
    ret,stats = profile(the_callable,*args,**kwargs)
 
527
    import cPickle
 
528
    ret, stats = profile(the_callable, *args, **kwargs)
453
529
    stats.sort()
454
 
    stats.pprint()
 
530
    if filename is None:
 
531
        stats.pprint()
 
532
    else:
 
533
        stats.freeze()
 
534
        cPickle.dump(stats, open(filename, 'w'), 2)
 
535
        print 'Profile data written to %r.' % filename
455
536
    return ret
456
537
 
 
538
 
 
539
def get_alias(cmd):
 
540
    """Return an expanded alias, or None if no alias exists"""
 
541
    import bzrlib.config
 
542
    alias = bzrlib.config.GlobalConfig().get_alias(cmd)
 
543
    if (alias):
 
544
        return alias.split(' ')
 
545
    return None
 
546
 
 
547
 
457
548
def run_bzr(argv):
458
549
    """Execute a command.
459
550
 
462
553
    
463
554
    argv
464
555
       The command-line arguments, without the program name from argv[0]
 
556
       These should already be decoded. All library/test code calling
 
557
       run_bzr should be passing valid strings (don't need decoding).
465
558
    
466
559
    Returns a command status or raises an exception.
467
560
 
471
564
    --no-plugins
472
565
        Do not load plugin modules at all
473
566
 
 
567
    --no-aliases
 
568
        Do not allow aliases
 
569
 
474
570
    --builtin
475
571
        Only use builtin commands.  (Plugins are still allowed to change
476
572
        other behaviour.)
481
577
    --lsprof
482
578
        Run under the Python lsprof profiler.
483
579
    """
484
 
    argv = [a.decode(bzrlib.user_encoding) for a in argv]
 
580
    argv = list(argv)
485
581
 
486
 
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin = False
 
582
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
 
583
                opt_no_aliases = False
 
584
    opt_lsprof_file = None
487
585
 
488
586
    # --no-plugins is handled specially at a very early stage. We need
489
587
    # to load plugins before doing other command parsing so that they
490
588
    # can override commands, but this needs to happen first.
491
589
 
492
 
    for a in argv:
 
590
    argv_copy = []
 
591
    i = 0
 
592
    while i < len(argv):
 
593
        a = argv[i]
493
594
        if a == '--profile':
494
595
            opt_profile = True
495
596
        elif a == '--lsprof':
496
597
            opt_lsprof = True
 
598
        elif a == '--lsprof-file':
 
599
            opt_lsprof_file = argv[i + 1]
 
600
            i += 1
497
601
        elif a == '--no-plugins':
498
602
            opt_no_plugins = True
 
603
        elif a == '--no-aliases':
 
604
            opt_no_aliases = True
499
605
        elif a == '--builtin':
500
606
            opt_builtin = True
501
607
        elif a in ('--quiet', '-q'):
502
608
            be_quiet()
503
609
        else:
504
 
            continue
505
 
        argv.remove(a)
 
610
            argv_copy.append(a)
 
611
        i += 1
506
612
 
507
 
    if (not argv) or (argv[0] == '--help'):
508
 
        from bzrlib.help import help
509
 
        if len(argv) > 1:
510
 
            help(argv[1])
511
 
        else:
512
 
            help()
 
613
    argv = argv_copy
 
614
    if (not argv):
 
615
        from bzrlib.builtins import cmd_help
 
616
        cmd_help().run_argv_aliases([])
513
617
        return 0
514
618
 
515
619
    if argv[0] == '--version':
520
624
    if not opt_no_plugins:
521
625
        from bzrlib.plugin import load_plugins
522
626
        load_plugins()
 
627
    else:
 
628
        from bzrlib.plugin import disable_plugins
 
629
        disable_plugins()
 
630
 
 
631
    alias_argv = None
 
632
 
 
633
    if not opt_no_aliases:
 
634
        alias_argv = get_alias(argv[0])
 
635
        if alias_argv:
 
636
            alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
 
637
            argv[0] = alias_argv.pop(0)
523
638
 
524
639
    cmd = str(argv.pop(0))
525
640
 
526
641
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
 
642
    if not getattr(cmd_obj.run_argv, 'is_deprecated', False):
 
643
        run = cmd_obj.run_argv
 
644
        run_argv = [argv]
 
645
    else:
 
646
        run = cmd_obj.run_argv_aliases
 
647
        run_argv = [argv, alias_argv]
527
648
 
528
649
    try:
529
650
        if opt_lsprof:
530
 
            ret = apply_lsprofiled(cmd_obj.run_argv, argv)
 
651
            ret = apply_lsprofiled(opt_lsprof_file, run, *run_argv)
531
652
        elif opt_profile:
532
 
            ret = apply_profiled(cmd_obj.run_argv, argv)
 
653
            ret = apply_profiled(run, *run_argv)
533
654
        else:
534
 
            ret = cmd_obj.run_argv(argv)
 
655
            ret = run(*run_argv)
535
656
        return ret or 0
536
657
    finally:
537
658
        # reset, in case we may do other commands later within the same process
559
680
    import bzrlib.ui
560
681
    from bzrlib.ui.text import TextUIFactory
561
682
    ## bzrlib.trace.enable_default_logging()
562
 
    bzrlib.trace.log_startup(argv)
563
683
    bzrlib.ui.ui_factory = TextUIFactory()
564
 
    ret = run_bzr_catch_errors(argv[1:])
 
684
 
 
685
    argv = [a.decode(bzrlib.user_encoding) for a in argv[1:]]
 
686
    ret = run_bzr_catch_errors(argv)
565
687
    mutter("return code %d", ret)
566
688
    return ret
567
689
 
576
698
    except Exception, e:
577
699
        # used to handle AssertionError and KeyboardInterrupt
578
700
        # specially here, but hopefully they're handled ok by the logger now
579
 
        import errno
580
 
        if (isinstance(e, IOError) 
581
 
            and hasattr(e, 'errno')
582
 
            and e.errno == errno.EPIPE):
583
 
            bzrlib.trace.note('broken pipe')
584
 
            return 3
585
 
        else:
586
 
            bzrlib.trace.log_exception()
587
 
            if os.environ.get('BZR_PDB'):
588
 
                print '**** entering debugger'
589
 
                import pdb
590
 
                pdb.post_mortem(sys.exc_traceback)
591
 
            return 3
 
701
        bzrlib.trace.report_exception(sys.exc_info(), sys.stderr)
 
702
        if os.environ.get('BZR_PDB'):
 
703
            print '**** entering debugger'
 
704
            import pdb
 
705
            pdb.post_mortem(sys.exc_traceback)
 
706
        return 3
592
707
 
593
708
if __name__ == '__main__':
594
709
    sys.exit(main(sys.argv))