1
# Copyright (C) 2004, 2005 by Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
# TODO: probably should say which arguments are candidates for glob
19
# expansion on windows and do that at the command level.
21
# TODO: Help messages for options.
23
# TODO: Define arguments by objects, rather than just using names.
24
# Those objects can specify the expected type of the argument, which
25
# would help with validation and shell completion.
27
# TODO: "--profile=cum", to change sort order. Is there any value in leaving
28
# the profile output behind so it can be interactively examined?
32
from warnings import warn
33
from inspect import getdoc
37
from bzrlib.errors import (BzrError,
42
from bzrlib.option import Option
43
from bzrlib.revisionspec import RevisionSpec
44
from bzrlib.symbol_versioning import *
46
from bzrlib.trace import mutter, note, log_error, warning, be_quiet
51
def register_command(cmd, decorate=False):
52
"Utility function to help register a command"
55
if k.startswith("cmd_"):
56
k_unsquished = _unsquish_command_name(k)
59
if not plugin_cmds.has_key(k_unsquished):
60
plugin_cmds[k_unsquished] = cmd
61
mutter('registered plugin command %s', k_unsquished)
62
if decorate and k_unsquished in builtin_command_names():
63
return _builtin_commands()[k_unsquished]
65
result = plugin_cmds[k_unsquished]
66
plugin_cmds[k_unsquished] = cmd
69
log_error('Two plugins defined the same command: %r' % k)
70
log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
73
def _squish_command_name(cmd):
74
return 'cmd_' + cmd.replace('-', '_')
77
def _unsquish_command_name(cmd):
78
assert cmd.startswith("cmd_")
79
return cmd[4:].replace('_','-')
82
def _builtin_commands():
83
import bzrlib.builtins
85
builtins = bzrlib.builtins.__dict__
87
if name.startswith("cmd_"):
88
real_name = _unsquish_command_name(name)
89
r[real_name] = builtins[name]
94
def builtin_command_names():
95
"""Return list of builtin command names."""
96
return _builtin_commands().keys()
99
def plugin_command_names():
100
return plugin_cmds.keys()
103
def _get_cmd_dict(plugins_override=True):
104
"""Return name->class mapping for all commands."""
105
d = _builtin_commands()
107
d.update(plugin_cmds)
111
def get_all_cmds(plugins_override=True):
112
"""Return canonical name and class for all registered commands."""
113
for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
117
def get_cmd_object(cmd_name, plugins_override=True):
118
"""Return the canonical name and command class for a command.
121
If true, plugin commands can override builtins.
123
from bzrlib.externalcommand import ExternalCommand
125
cmd_name = str(cmd_name) # not unicode
127
# first look up this command under the specified name
128
cmds = _get_cmd_dict(plugins_override=plugins_override)
130
return cmds[cmd_name]()
134
# look for any command which claims this as an alias
135
for real_cmd_name, cmd_class in cmds.iteritems():
136
if cmd_name in cmd_class.aliases:
139
cmd_obj = ExternalCommand.find_command(cmd_name)
143
raise BzrCommandError("unknown command %r" % cmd_name)
146
class Command(object):
147
"""Base class for commands.
149
Commands are the heart of the command-line bzr interface.
151
The command object mostly handles the mapping of command-line
152
parameters into one or more bzrlib operations, and of the results
155
Commands normally don't have any state. All their arguments are
156
passed in to the run method. (Subclasses may take a different
157
policy if the behaviour of the instance needs to depend on e.g. a
158
shell plugin and not just its Python class.)
160
The docstring for an actual command should give a single-line
161
summary, then a complete description of the command. A grammar
162
description will be inserted.
165
Other accepted names for this command.
168
List of argument forms, marked with whether they are optional,
173
['to_location', 'from_branch?', 'file*']
175
'to_location' is required
176
'from_branch' is optional
177
'file' can be specified 0 or more times
180
List of options that may be given for this command. These can
181
be either strings, referring to globally-defined options,
182
or option objects. Retrieve through options().
185
If true, this command isn't advertised. This is typically
186
for commands intended for expert users.
195
"""Construct an instance of this command."""
196
if self.__doc__ == Command.__doc__:
197
warn("No help message set for %r" % self)
200
"""Return dict of valid options for this command.
202
Maps from long option name to option object."""
204
r['help'] = Option.OPTIONS['help']
205
for o in self.takes_options:
206
if not isinstance(o, Option):
207
o = Option.OPTIONS[o]
211
@deprecated_method(zero_eight)
212
def run_argv(self, argv):
213
"""Parse command line and run.
215
See run_argv_aliases for the 0.8 and beyond api.
217
return self.run_argv_aliases(argv)
219
def run_argv_aliases(self, argv, alias_argv=None):
220
"""Parse the command line and run with extra aliases in alias_argv."""
221
args, opts = parse_args(self, argv, alias_argv)
222
if 'help' in opts: # e.g. bzr add --help
223
from bzrlib.help import help_on_command
224
help_on_command(self.name())
226
# XXX: This should be handled by the parser
227
allowed_names = self.options().keys()
229
if oname not in allowed_names:
230
raise BzrCommandError("option '--%s' is not allowed for"
231
" command %r" % (oname, self.name()))
232
# mix arguments and options into one dictionary
233
cmdargs = _match_argform(self.name(), self.takes_args, args)
235
for k, v in opts.items():
236
cmdopts[k.replace('-', '_')] = v
238
all_cmd_args = cmdargs.copy()
239
all_cmd_args.update(cmdopts)
241
return self.run(**all_cmd_args)
244
"""Actually run the command.
246
This is invoked with the options and arguments bound to
249
Return 0 or None if the command was successful, or a non-zero
250
shell error code if not. It's OK for this method to allow
251
an exception to raise up.
253
raise NotImplementedError()
257
"""Return help message for this class."""
258
if self.__doc__ is Command.__doc__:
263
return _unsquish_command_name(self.__class__.__name__)
266
def parse_spec(spec):
272
>>> parse_spec("../@")
274
>>> parse_spec("../f/@35")
276
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
277
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
282
parsed = spec.split('/@')
283
assert len(parsed) == 2
288
parsed[1] = int(parsed[1])
290
pass # We can allow stuff like ./@revid:blahblahblah
294
parsed = [spec, None]
297
def parse_args(command, argv, alias_argv=None):
298
"""Parse command line.
300
Arguments and options are parsed at this level before being passed
301
down to specific command handlers. This routine knows, from a
302
lookup table, something about the available options, what optargs
303
they take, and which commands will accept them.
305
# TODO: chop up this beast; make it a method of the Command
310
cmd_options = command.options()
312
proc_aliasarg = True # Are we processing alias_argv now?
313
for proc_argv in alias_argv, argv:
320
# We've received a standalone -- No more flags
324
# option names must not be unicode
328
mutter(" got option %r", a)
330
optname, optarg = a[2:].split('=', 1)
333
if optname not in cmd_options:
334
raise BzrOptionError('unknown long option %r for'
339
if shortopt in Option.SHORT_OPTIONS:
340
# Multi-character options must have a space to delimit
342
# ^^^ what does this mean? mbp 20051014
343
optname = Option.SHORT_OPTIONS[shortopt].name
345
# Single character short options, can be chained,
346
# and have their value appended to their name
348
if shortopt not in Option.SHORT_OPTIONS:
349
# We didn't find the multi-character name, and we
350
# didn't find the single char name
351
raise BzrError('unknown short option %r' % a)
352
optname = Option.SHORT_OPTIONS[shortopt].name
355
# There are extra things on this option
356
# see if it is the value, or if it is another
358
optargfn = Option.OPTIONS[optname].type
360
# This option does not take an argument, so the
361
# next entry is another short option, pack it
363
proc_argv.insert(0, '-' + a[2:])
365
# This option takes an argument, so pack it
369
if optname not in cmd_options:
370
raise BzrOptionError('unknown short option %r for'
372
(shortopt, command.name()))
374
# XXX: Do we ever want to support this, e.g. for -r?
376
raise BzrError('repeated option %r' % a)
377
elif optname in alias_opts:
378
# Replace what's in the alias with what's in the real
380
del alias_opts[optname]
382
proc_argv.insert(0, a)
385
raise BzrError('repeated option %r' % a)
387
option_obj = cmd_options[optname]
388
optargfn = option_obj.type
392
raise BzrError('option %r needs an argument' % a)
394
optarg = proc_argv.pop(0)
395
opts[optname] = optargfn(optarg)
397
alias_opts[optname] = optargfn(optarg)
400
raise BzrError('option %r takes no argument' % optname)
403
alias_opts[optname] = True
406
proc_aliasarg = False # Done with alias argv
410
def _match_argform(cmd, takes_args, args):
413
# step through args and takes_args, allowing appropriate 0-many matches
414
for ap in takes_args:
418
argdict[argname] = args.pop(0)
419
elif ap[-1] == '*': # all remaining arguments
421
argdict[argname + '_list'] = args[:]
424
argdict[argname + '_list'] = None
427
raise BzrCommandError("command %r needs one or more %s"
428
% (cmd, argname.upper()))
430
argdict[argname + '_list'] = args[:]
432
elif ap[-1] == '$': # all but one
434
raise BzrCommandError("command %r needs one or more %s"
435
% (cmd, argname.upper()))
436
argdict[argname + '_list'] = args[:-1]
442
raise BzrCommandError("command %r requires argument %s"
443
% (cmd, argname.upper()))
445
argdict[argname] = args.pop(0)
448
raise BzrCommandError("extra argument to command %s: %s"
455
def apply_profiled(the_callable, *args, **kwargs):
459
pffileno, pfname = tempfile.mkstemp()
461
prof = hotshot.Profile(pfname)
463
ret = prof.runcall(the_callable, *args, **kwargs) or 0
466
stats = hotshot.stats.load(pfname)
468
stats.sort_stats('cum') # 'time'
469
## XXX: Might like to write to stderr or the trace file instead but
470
## print_stats seems hardcoded to stdout
471
stats.print_stats(20)
478
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
479
from bzrlib.lsprof import profile
481
ret, stats = profile(the_callable, *args, **kwargs)
487
cPickle.dump(stats, open(filename, 'w'), 2)
488
print 'Profile data written to %r.' % filename
493
"""Return an expanded alias, or None if no alias exists"""
495
alias = bzrlib.config.GlobalConfig().get_alias(cmd)
497
return alias.split(' ')
502
"""Execute a command.
504
This is similar to main(), but without all the trappings for
505
logging and error handling.
508
The command-line arguments, without the program name from argv[0]
510
Returns a command status or raises an exception.
512
Special master options: these must come before the command because
513
they control how the command is interpreted.
516
Do not load plugin modules at all
522
Only use builtin commands. (Plugins are still allowed to change
526
Run under the Python hotshot profiler.
529
Run under the Python lsprof profiler.
531
argv = [a.decode(bzrlib.user_encoding) for a in argv]
533
opt_lsprof = opt_profile = opt_no_plugins = opt_builtin = \
534
opt_no_aliases = False
535
opt_lsprof_file = None
537
# --no-plugins is handled specially at a very early stage. We need
538
# to load plugins before doing other command parsing so that they
539
# can override commands, but this needs to happen first.
547
elif a == '--lsprof':
549
elif a == '--lsprof-file':
550
opt_lsprof_file = argv[i + 1]
552
elif a == '--no-plugins':
553
opt_no_plugins = True
554
elif a == '--no-aliases':
555
opt_no_aliases = True
556
elif a == '--builtin':
558
elif a in ('--quiet', '-q'):
565
if (not argv) or (argv[0] == '--help'):
566
from bzrlib.help import help
573
if argv[0] == '--version':
574
from bzrlib.builtins import show_version
578
if not opt_no_plugins:
579
from bzrlib.plugin import load_plugins
582
from bzrlib.plugin import disable_plugins
587
if not opt_no_aliases:
588
alias_argv = get_alias(argv[0])
590
alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
591
argv[0] = alias_argv.pop(0)
593
cmd = str(argv.pop(0))
595
cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
596
if not getattr(cmd_obj.run_argv, 'is_deprecated', False):
597
run = cmd_obj.run_argv
600
run = cmd_obj.run_argv_aliases
601
run_argv = [argv, alias_argv]
605
ret = apply_lsprofiled(opt_lsprof_file, run, *run_argv)
607
ret = apply_profiled(run, *run_argv)
612
# reset, in case we may do other commands later within the same process
615
def display_command(func):
616
"""Decorator that suppresses pipe/interrupt errors."""
617
def ignore_pipe(*args, **kwargs):
619
result = func(*args, **kwargs)
623
if not hasattr(e, 'errno'):
625
if e.errno != errno.EPIPE:
628
except KeyboardInterrupt:
635
from bzrlib.ui.text import TextUIFactory
636
## bzrlib.trace.enable_default_logging()
637
bzrlib.trace.log_startup(argv)
638
bzrlib.ui.ui_factory = TextUIFactory()
639
ret = run_bzr_catch_errors(argv[1:])
640
mutter("return code %d", ret)
644
def run_bzr_catch_errors(argv):
649
# do this here inside the exception wrappers to catch EPIPE
652
# used to handle AssertionError and KeyboardInterrupt
653
# specially here, but hopefully they're handled ok by the logger now
655
if (isinstance(e, IOError)
656
and hasattr(e, 'errno')
657
and e.errno == errno.EPIPE):
658
bzrlib.trace.note('broken pipe')
661
bzrlib.trace.log_exception()
662
if os.environ.get('BZR_PDB'):
663
print '**** entering debugger'
665
pdb.post_mortem(sys.exc_traceback)
668
if __name__ == '__main__':
669
sys.exit(main(sys.argv))
added
removed
bzrlib/commands.py
