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
38
from bzrlib.trace import mutter, note, log_error, warning, be_quiet
39
from bzrlib.errors import (BzrError,
44
from bzrlib.revisionspec import RevisionSpec
45
from bzrlib.option import Option
50
def register_command(cmd, decorate=False):
51
"Utility function to help register a command"
54
if k.startswith("cmd_"):
55
k_unsquished = _unsquish_command_name(k)
58
if not plugin_cmds.has_key(k_unsquished):
59
plugin_cmds[k_unsquished] = cmd
60
mutter('registered plugin command %s', k_unsquished)
61
if decorate and k_unsquished in builtin_command_names():
62
return _builtin_commands()[k_unsquished]
64
result = plugin_cmds[k_unsquished]
65
plugin_cmds[k_unsquished] = cmd
68
log_error('Two plugins defined the same command: %r' % k)
69
log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
72
def _squish_command_name(cmd):
73
return 'cmd_' + cmd.replace('-', '_')
76
def _unsquish_command_name(cmd):
77
assert cmd.startswith("cmd_")
78
return cmd[4:].replace('_','-')
81
def _builtin_commands():
82
import bzrlib.builtins
84
builtins = bzrlib.builtins.__dict__
86
if name.startswith("cmd_"):
87
real_name = _unsquish_command_name(name)
88
r[real_name] = builtins[name]
93
def builtin_command_names():
94
"""Return list of builtin command names."""
95
return _builtin_commands().keys()
98
def plugin_command_names():
99
return plugin_cmds.keys()
102
def _get_cmd_dict(plugins_override=True):
103
"""Return name->class mapping for all commands."""
104
d = _builtin_commands()
106
d.update(plugin_cmds)
110
def get_all_cmds(plugins_override=True):
111
"""Return canonical name and class for all registered commands."""
112
for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
116
def get_cmd_object(cmd_name, plugins_override=True):
117
"""Return the canonical name and command class for a command.
120
If true, plugin commands can override builtins.
122
from bzrlib.externalcommand import ExternalCommand
124
cmd_name = str(cmd_name) # not unicode
126
# first look up this command under the specified name
127
cmds = _get_cmd_dict(plugins_override=plugins_override)
129
return cmds[cmd_name]()
133
# look for any command which claims this as an alias
134
for real_cmd_name, cmd_class in cmds.iteritems():
135
if cmd_name in cmd_class.aliases:
138
cmd_obj = ExternalCommand.find_command(cmd_name)
142
raise BzrCommandError("unknown command %r" % cmd_name)
145
class Command(object):
146
"""Base class for commands.
148
Commands are the heart of the command-line bzr interface.
150
The command object mostly handles the mapping of command-line
151
parameters into one or more bzrlib operations, and of the results
154
Commands normally don't have any state. All their arguments are
155
passed in to the run method. (Subclasses may take a different
156
policy if the behaviour of the instance needs to depend on e.g. a
157
shell plugin and not just its Python class.)
159
The docstring for an actual command should give a single-line
160
summary, then a complete description of the command. A grammar
161
description will be inserted.
164
Other accepted names for this command.
167
List of argument forms, marked with whether they are optional,
172
['to_location', 'from_branch?', 'file*']
174
'to_location' is required
175
'from_branch' is optional
176
'file' can be specified 0 or more times
179
List of options that may be given for this command. These can
180
be either strings, referring to globally-defined options,
181
or option objects. Retrieve through options().
184
If true, this command isn't advertised. This is typically
185
for commands intended for expert users.
194
"""Construct an instance of this command."""
195
if self.__doc__ == Command.__doc__:
196
warn("No help message set for %r" % self)
199
"""Return dict of valid options for this command.
201
Maps from long option name to option object."""
203
r['help'] = Option.OPTIONS['help']
204
for o in self.takes_options:
205
if not isinstance(o, Option):
206
o = Option.OPTIONS[o]
210
def run_argv(self, argv, alias_argv=None):
211
"""Parse command line and run."""
212
args, opts = parse_args(self, argv, alias_argv)
213
if 'help' in opts: # e.g. bzr add --help
214
from bzrlib.help import help_on_command
215
help_on_command(self.name())
217
# XXX: This should be handled by the parser
218
allowed_names = self.options().keys()
220
if oname not in allowed_names:
221
raise BzrCommandError("option '--%s' is not allowed for command %r"
222
% (oname, self.name()))
223
# mix arguments and options into one dictionary
224
cmdargs = _match_argform(self.name(), self.takes_args, args)
226
for k, v in opts.items():
227
cmdopts[k.replace('-', '_')] = v
229
all_cmd_args = cmdargs.copy()
230
all_cmd_args.update(cmdopts)
232
return self.run(**all_cmd_args)
235
"""Actually run the command.
237
This is invoked with the options and arguments bound to
240
Return 0 or None if the command was successful, or a non-zero
241
shell error code if not. It's OK for this method to allow
242
an exception to raise up.
244
raise NotImplementedError()
248
"""Return help message for this class."""
249
if self.__doc__ is Command.__doc__:
254
return _unsquish_command_name(self.__class__.__name__)
257
def parse_spec(spec):
263
>>> parse_spec("../@")
265
>>> parse_spec("../f/@35")
267
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
268
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
273
parsed = spec.split('/@')
274
assert len(parsed) == 2
279
parsed[1] = int(parsed[1])
281
pass # We can allow stuff like ./@revid:blahblahblah
285
parsed = [spec, None]
288
def parse_args(command, argv, alias_argv=None):
289
"""Parse command line.
291
Arguments and options are parsed at this level before being passed
292
down to specific command handlers. This routine knows, from a
293
lookup table, something about the available options, what optargs
294
they take, and which commands will accept them.
296
# TODO: chop up this beast; make it a method of the Command
301
cmd_options = command.options()
303
proc_aliasarg = True # Are we processing alias_argv now?
304
for proc_argv in alias_argv, argv:
311
# We've received a standalone -- No more flags
315
# option names must not be unicode
319
mutter(" got option %r", a)
321
optname, optarg = a[2:].split('=', 1)
324
if optname not in cmd_options:
325
raise BzrOptionError('unknown long option %r for command %s'
326
% (a, command.name()))
329
if shortopt in Option.SHORT_OPTIONS:
330
# Multi-character options must have a space to delimit
332
# ^^^ what does this mean? mbp 20051014
333
optname = Option.SHORT_OPTIONS[shortopt].name
335
# Single character short options, can be chained,
336
# and have their value appended to their name
338
if shortopt not in Option.SHORT_OPTIONS:
339
# We didn't find the multi-character name, and we
340
# didn't find the single char name
341
raise BzrError('unknown short option %r' % a)
342
optname = Option.SHORT_OPTIONS[shortopt].name
345
# There are extra things on this option
346
# see if it is the value, or if it is another
348
optargfn = Option.OPTIONS[optname].type
350
# This option does not take an argument, so the
351
# next entry is another short option, pack it back
353
proc_argv.insert(0, '-' + a[2:])
355
# This option takes an argument, so pack it
359
if optname not in cmd_options:
360
raise BzrOptionError('unknown short option %r for command'
361
' %s' % (shortopt, command.name()))
363
# XXX: Do we ever want to support this, e.g. for -r?
365
raise BzrError('repeated option %r' % a)
366
elif optname in alias_opts:
367
# Replace what's in the alias with what's in the real argument
368
del alias_opts[optname]
370
proc_argv.insert(0, a)
373
raise BzrError('repeated option %r' % a)
375
option_obj = cmd_options[optname]
376
optargfn = option_obj.type
380
raise BzrError('option %r needs an argument' % a)
382
optarg = proc_argv.pop(0)
383
opts[optname] = optargfn(optarg)
385
alias_opts[optname] = optargfn(optarg)
388
raise BzrError('option %r takes no argument' % optname)
391
alias_opts[optname] = True
394
proc_aliasarg = False # Done with alias argv
398
def _match_argform(cmd, takes_args, args):
401
# step through args and takes_args, allowing appropriate 0-many matches
402
for ap in takes_args:
406
argdict[argname] = args.pop(0)
407
elif ap[-1] == '*': # all remaining arguments
409
argdict[argname + '_list'] = args[:]
412
argdict[argname + '_list'] = None
415
raise BzrCommandError("command %r needs one or more %s"
416
% (cmd, argname.upper()))
418
argdict[argname + '_list'] = args[:]
420
elif ap[-1] == '$': # all but one
422
raise BzrCommandError("command %r needs one or more %s"
423
% (cmd, argname.upper()))
424
argdict[argname + '_list'] = args[:-1]
430
raise BzrCommandError("command %r requires argument %s"
431
% (cmd, argname.upper()))
433
argdict[argname] = args.pop(0)
436
raise BzrCommandError("extra argument to command %s: %s"
443
def apply_profiled(the_callable, *args, **kwargs):
447
pffileno, pfname = tempfile.mkstemp()
449
prof = hotshot.Profile(pfname)
451
ret = prof.runcall(the_callable, *args, **kwargs) or 0
454
stats = hotshot.stats.load(pfname)
456
stats.sort_stats('cum') # 'time'
457
## XXX: Might like to write to stderr or the trace file instead but
458
## print_stats seems hardcoded to stdout
459
stats.print_stats(20)
466
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
467
from bzrlib.lsprof import profile
469
ret, stats = profile(the_callable, *args, **kwargs)
475
cPickle.dump(stats, open(filename, 'w'), 2)
476
print 'Profile data written to %r.' % filename
481
"""if an alias for cmd exists, returns the expanded command
484
alias = bzrlib.config.GlobalConfig().get_alias(cmd)
486
return alias.split(' ')
491
"""Execute a command.
493
This is similar to main(), but without all the trappings for
494
logging and error handling.
497
The command-line arguments, without the program name from argv[0]
499
Returns a command status or raises an exception.
501
Special master options: these must come before the command because
502
they control how the command is interpreted.
505
Do not load plugin modules at all
511
Only use builtin commands. (Plugins are still allowed to change
515
Run under the Python hotshot profiler.
518
Run under the Python lsprof profiler.
520
argv = [a.decode(bzrlib.user_encoding) for a in argv]
522
opt_lsprof = opt_profile = opt_no_plugins = opt_builtin = \
523
opt_no_aliases = False
524
opt_lsprof_file = None
526
# --no-plugins is handled specially at a very early stage. We need
527
# to load plugins before doing other command parsing so that they
528
# can override commands, but this needs to happen first.
536
elif a == '--lsprof':
538
elif a == '--lsprof-file':
539
opt_lsprof_file = argv[i + 1]
541
elif a == '--no-plugins':
542
opt_no_plugins = True
543
elif a == '--no-aliases':
544
opt_no_aliases = True
545
elif a == '--builtin':
547
elif a in ('--quiet', '-q'):
554
if (not argv) or (argv[0] == '--help'):
555
from bzrlib.help import help
562
if argv[0] == '--version':
563
from bzrlib.builtins import show_version
567
if not opt_no_plugins:
568
from bzrlib.plugin import load_plugins
571
from bzrlib.plugin import disable_plugins
574
if not opt_no_aliases:
575
alias_argv = get_alias(argv[0])
577
alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
578
argv[0] = alias_argv.pop(0)
580
cmd = str(argv.pop(0))
582
cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
586
ret = apply_lsprofiled(opt_lsprof_file, cmd_obj.run_argv, argv, alias_argv)
588
ret = apply_profiled(cmd_obj.run_argv, argv, alias_argv)
590
ret = cmd_obj.run_argv(argv, alias_argv)
593
# reset, in case we may do other commands later within the same process
596
def display_command(func):
597
"""Decorator that suppresses pipe/interrupt errors."""
598
def ignore_pipe(*args, **kwargs):
600
result = func(*args, **kwargs)
604
if not hasattr(e, 'errno'):
606
if e.errno != errno.EPIPE:
609
except KeyboardInterrupt:
616
from bzrlib.ui.text import TextUIFactory
617
## bzrlib.trace.enable_default_logging()
618
bzrlib.trace.log_startup(argv)
619
bzrlib.ui.ui_factory = TextUIFactory()
620
ret = run_bzr_catch_errors(argv[1:])
621
mutter("return code %d", ret)
625
def run_bzr_catch_errors(argv):
630
# do this here inside the exception wrappers to catch EPIPE
633
# used to handle AssertionError and KeyboardInterrupt
634
# specially here, but hopefully they're handled ok by the logger now
636
if (isinstance(e, IOError)
637
and hasattr(e, 'errno')
638
and e.errno == errno.EPIPE):
639
bzrlib.trace.note('broken pipe')
642
bzrlib.trace.log_exception()
643
if os.environ.get('BZR_PDB'):
644
print '**** entering debugger'
646
pdb.post_mortem(sys.exc_traceback)
649
if __name__ == '__main__':
650
sys.exit(main(sys.argv))
added
removed
bzrlib/commands.py
