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
19
import sys, os, time, os.path
22
from bzrlib.trace import mutter, note, log_error
23
from bzrlib.errors import bailout, BzrError, BzrCheckError, BzrCommandError
24
from bzrlib.osutils import quotefn, pumpfile, isdir, isfile
25
from bzrlib.tree import RevisionTree, EmptyTree, Tree
26
from bzrlib.revision import Revision
27
from bzrlib import Branch, Inventory, InventoryEntry, ScratchBranch, BZRDIR, \
29
from bzrlib import merge
32
def _squish_command_name(cmd):
33
return 'cmd_' + cmd.replace('-', '_')
36
def _unsquish_command_name(cmd):
37
assert cmd.startswith("cmd_")
38
return cmd[4:].replace('_','-')
41
"""Return canonical name and class for all registered commands."""
42
for k, v in globals().iteritems():
43
if k.startswith("cmd_"):
44
yield _unsquish_command_name(k), v
46
def get_cmd_class(cmd):
47
"""Return the canonical name and command class for a command.
49
cmd = str(cmd) # not unicode
51
# first look up this command under the specified name
53
return cmd, globals()[_squish_command_name(cmd)]
57
# look for any command which claims this as an alias
58
for cmdname, cmdclass in get_all_cmds():
59
if cmd in cmdclass.aliases:
60
return cmdname, cmdclass
62
cmdclass = ExternalCommand.find_command(cmd)
66
raise BzrCommandError("unknown command %r" % cmd)
69
class Command(object):
70
"""Base class for commands.
72
The docstring for an actual command should give a single-line
73
summary, then a complete description of the command. A grammar
74
description will be inserted.
77
List of argument forms, marked with whether they are optional,
81
List of options that may be given for this command.
84
If true, this command isn't advertised.
93
def __init__(self, options, arguments):
94
"""Construct and run the command.
96
Sets self.status to the return value of run()."""
97
assert isinstance(options, dict)
98
assert isinstance(arguments, dict)
99
cmdargs = options.copy()
100
cmdargs.update(arguments)
101
assert self.__doc__ != Command.__doc__, \
102
("No help message set for %r" % self)
103
self.status = self.run(**cmdargs)
107
"""Override this in sub-classes.
109
This is invoked with the options and arguments bound to
112
Return 0 or None if the command was successful, or a shell
118
class ExternalCommand(Command):
119
"""Class to wrap external commands.
121
We cheat a little here, when get_cmd_class() calls us we actually give it back
122
an object we construct that has the appropriate path, help, options etc for the
125
When run_bzr() tries to instantiate that 'class' it gets caught by the __call__
126
method, which we override to call the Command.__init__ method. That then calls
127
our run method which is pretty straight forward.
129
The only wrinkle is that we have to map bzr's dictionary of options and arguments
130
back into command line options and arguments for the script.
133
def find_command(cls, cmd):
134
bzrpath = os.environ.get('BZRPATH', '')
136
for dir in bzrpath.split(':'):
137
path = os.path.join(dir, cmd)
138
if os.path.isfile(path):
139
return ExternalCommand(path)
143
find_command = classmethod(find_command)
145
def __init__(self, path):
148
# TODO: If either of these fail, we should detect that and
149
# assume that path is not really a bzr plugin after all.
151
pipe = os.popen('%s --bzr-usage' % path, 'r')
152
self.takes_options = pipe.readline().split()
153
self.takes_args = pipe.readline().split()
156
pipe = os.popen('%s --bzr-help' % path, 'r')
157
self.__doc__ = pipe.read()
160
def __call__(self, options, arguments):
161
Command.__init__(self, options, arguments)
164
def run(self, **kargs):
172
if OPTIONS.has_key(name):
174
opts.append('--%s' % name)
175
if value is not None and value is not True:
176
opts.append(str(value))
178
# it's an arg, or arg list
179
if type(value) is not list:
185
self.status = os.spawnv(os.P_WAIT, self.path, [self.path] + opts + args)
189
class cmd_status(Command):
190
"""Display status summary.
192
This reports on versioned and unknown files, reporting them
193
grouped by state. Possible states are:
196
Versioned in the working copy but not in the previous revision.
199
Versioned in the previous revision but removed or deleted
203
Path of this file changed from the previous revision;
204
the text may also have changed. This includes files whose
205
parent directory was renamed.
208
Text has changed since the previous revision.
211
Nothing about this file has changed since the previous revision.
212
Only shown with --all.
215
Not versioned and not matching an ignore pattern.
217
To see ignored files use 'bzr ignored'. For details in the
218
changes to file texts, use 'bzr diff'.
220
If no arguments are specified, the status of the entire working
221
directory is shown. Otherwise, only the status of the specified
222
files or directories is reported. If a directory is given, status
223
is reported for everything inside that directory.
225
takes_args = ['file*']
226
takes_options = ['all', 'show-ids']
227
aliases = ['st', 'stat']
229
def run(self, all=False, show_ids=False, file_list=None):
231
b = Branch(file_list[0], lock_mode='r')
232
file_list = [b.relpath(x) for x in file_list]
233
# special case: only one path was given and it's the root
235
if file_list == ['']:
238
b = Branch('.', lock_mode='r')
240
status.show_status(b, show_unchanged=all, show_ids=show_ids,
241
specific_files=file_list)
244
class cmd_cat_revision(Command):
245
"""Write out metadata for a revision."""
248
takes_args = ['revision_id']
250
def run(self, revision_id):
251
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
254
class cmd_revno(Command):
255
"""Show current revision number.
257
This is equal to the number of revisions on this branch."""
259
print Branch('.').revno()
262
class cmd_add(Command):
263
"""Add specified files or directories.
265
In non-recursive mode, all the named items are added, regardless
266
of whether they were previously ignored. A warning is given if
267
any of the named files are already versioned.
269
In recursive mode (the default), files are treated the same way
270
but the behaviour for directories is different. Directories that
271
are already versioned do not give a warning. All directories,
272
whether already versioned or not, are searched for files or
273
subdirectories that are neither versioned or ignored, and these
274
are added. This search proceeds recursively into versioned
277
Therefore simply saying 'bzr add .' will version all files that
278
are currently unknown.
280
TODO: Perhaps adding a file whose directly is not versioned should
281
recursively add that parent, rather than giving an error?
283
takes_args = ['file+']
284
takes_options = ['verbose']
286
def run(self, file_list, verbose=False):
287
bzrlib.add.smart_add(file_list, verbose)
290
class cmd_relpath(Command):
291
"""Show path of a file relative to root"""
292
takes_args = ['filename']
294
def run(self, filename):
295
print Branch(filename).relpath(filename)
299
class cmd_inventory(Command):
300
"""Show inventory of the current working copy or a revision."""
301
takes_options = ['revision']
303
def run(self, revision=None):
306
inv = b.read_working_inventory()
308
inv = b.get_revision_inventory(b.lookup_revision(revision))
310
for path, entry in inv.entries():
311
print '%-50s %s' % (entry.file_id, path)
314
class cmd_move(Command):
315
"""Move files to a different directory.
320
The destination must be a versioned directory in the same branch.
322
takes_args = ['source$', 'dest']
323
def run(self, source_list, dest):
326
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
329
class cmd_rename(Command):
330
"""Change the name of an entry.
333
bzr rename frob.c frobber.c
334
bzr rename src/frob.c lib/frob.c
336
It is an error if the destination name exists.
338
See also the 'move' command, which moves files into a different
339
directory without changing their name.
341
TODO: Some way to rename multiple files without invoking bzr for each
343
takes_args = ['from_name', 'to_name']
345
def run(self, from_name, to_name):
347
b.rename_one(b.relpath(from_name), b.relpath(to_name))
351
class cmd_renames(Command):
352
"""Show list of renamed files.
354
TODO: Option to show renames between two historical versions.
356
TODO: Only show renames under dir, rather than in the whole branch.
358
takes_args = ['dir?']
360
def run(self, dir='.'):
362
old_inv = b.basis_tree().inventory
363
new_inv = b.read_working_inventory()
365
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
367
for old_name, new_name in renames:
368
print "%s => %s" % (old_name, new_name)
371
class cmd_info(Command):
372
"""Show statistical information about a branch."""
373
takes_args = ['branch?']
375
def run(self, branch=None):
378
from branch import find_branch
379
b = find_branch(branch)
383
class cmd_remove(Command):
384
"""Make a file unversioned.
386
This makes bzr stop tracking changes to a versioned file. It does
387
not delete the working copy.
389
takes_args = ['file+']
390
takes_options = ['verbose']
392
def run(self, file_list, verbose=False):
393
b = Branch(file_list[0])
394
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
397
class cmd_file_id(Command):
398
"""Print file_id of a particular file or directory.
400
The file_id is assigned when the file is first added and remains the
401
same through all revisions where the file exists, even when it is
405
takes_args = ['filename']
406
def run(self, filename):
408
i = b.inventory.path2id(b.relpath(filename))
410
bailout("%r is not a versioned file" % filename)
415
class cmd_file_path(Command):
416
"""Print path of file_ids to a file or directory.
418
This prints one line for each directory down to the target,
419
starting at the branch root."""
421
takes_args = ['filename']
422
def run(self, filename):
425
fid = inv.path2id(b.relpath(filename))
427
bailout("%r is not a versioned file" % filename)
428
for fip in inv.get_idpath(fid):
432
class cmd_revision_history(Command):
433
"""Display list of revision ids on this branch."""
435
for patchid in Branch('.').revision_history():
439
class cmd_directories(Command):
440
"""Display list of versioned directories in this branch."""
442
for name, ie in Branch('.').read_working_inventory().directories():
449
class cmd_init(Command):
450
"""Make a directory into a versioned branch.
452
Use this to create an empty branch, or before importing an
455
Recipe for importing a tree of files:
460
bzr commit -m 'imported project'
463
Branch('.', init=True)
466
class cmd_diff(Command):
467
"""Show differences in working tree.
469
If files are listed, only the changes in those files are listed.
470
Otherwise, all changes for the tree are listed.
472
TODO: Given two revision arguments, show the difference between them.
474
TODO: Allow diff across branches.
476
TODO: Option to use external diff command; could be GNU diff, wdiff,
479
TODO: Python difflib is not exactly the same as unidiff; should
480
either fix it up or prefer to use an external diff.
482
TODO: If a directory is given, diff everything under that.
484
TODO: Selected-file diff is inefficient and doesn't show you
487
TODO: This probably handles non-Unix newlines poorly.
490
takes_args = ['file*']
491
takes_options = ['revision']
494
def run(self, revision=None, file_list=None):
495
from bzrlib.diff import show_diff
496
from bzrlib import find_branch
499
b = find_branch(file_list[0], lock_mode='r')
500
file_list = [b.relpath(f) for f in file_list]
501
if file_list == ['']:
502
# just pointing to top-of-tree
505
b = Branch('.', lock_mode='r')
507
show_diff(b, revision, specific_files=file_list)
513
class cmd_deleted(Command):
514
"""List files deleted in the working tree.
516
TODO: Show files deleted since a previous revision, or between two revisions.
518
def run(self, show_ids=False):
521
new = b.working_tree()
523
## TODO: Much more efficient way to do this: read in new
524
## directories with readdir, rather than stating each one. Same
525
## level of effort but possibly much less IO. (Or possibly not,
526
## if the directories are very large...)
528
for path, ie in old.inventory.iter_entries():
529
if not new.has_id(ie.file_id):
531
print '%-50s %s' % (path, ie.file_id)
536
class cmd_modified(Command):
537
"""List files modified in working tree."""
542
inv = b.read_working_inventory()
543
sc = statcache.update_cache(b, inv)
544
basis = b.basis_tree()
545
basis_inv = basis.inventory
547
# We used to do this through iter_entries(), but that's slow
548
# when most of the files are unmodified, as is usually the
549
# case. So instead we iterate by inventory entry, and only
550
# calculate paths as necessary.
552
for file_id in basis_inv:
553
cacheentry = sc.get(file_id)
554
if not cacheentry: # deleted
556
ie = basis_inv[file_id]
557
if cacheentry[statcache.SC_SHA1] != ie.text_sha1:
558
path = inv.id2path(file_id)
563
class cmd_added(Command):
564
"""List files added in working tree."""
568
wt = b.working_tree()
569
basis_inv = b.basis_tree().inventory
572
if file_id in basis_inv:
574
path = inv.id2path(file_id)
575
if not os.access(b.abspath(path), os.F_OK):
581
class cmd_root(Command):
582
"""Show the tree root directory.
584
The root is the nearest enclosing directory with a .bzr control
586
takes_args = ['filename?']
587
def run(self, filename=None):
588
"""Print the branch root."""
589
from branch import find_branch
590
b = find_branch(filename)
591
print getattr(b, 'base', None) or getattr(b, 'baseurl')
594
class cmd_log(Command):
595
"""Show log of this branch.
597
TODO: Option to limit range.
600
takes_args = ['filename?']
601
takes_options = ['forward', 'timezone', 'verbose', 'show-ids']
603
def run(self, filename=None, timezone='original',
607
from bzrlib import show_log, find_branch
610
direction = (forward and 'forward') or 'reverse'
613
b = find_branch(filename, lock_mode='r')
614
fp = b.relpath(filename)
616
file_id = b.read_working_inventory().path2id(fp)
618
file_id = None # points to branch root
620
b = find_branch('.', lock_mode='r')
623
mutter('encoding log as %r' % bzrlib.user_encoding)
624
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout)
627
show_timezone=timezone,
635
class cmd_touching_revisions(Command):
636
"""Return revision-ids which affected a particular file.
638
A more user-friendly interface is "bzr log FILE"."""
640
takes_args = ["filename"]
641
def run(self, filename):
642
b = Branch(filename, lock_mode='r')
643
inv = b.read_working_inventory()
644
file_id = inv.path2id(b.relpath(filename))
645
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
646
print "%6d %s" % (revno, what)
649
class cmd_ls(Command):
650
"""List files in a tree.
652
TODO: Take a revision or remote path and list that tree instead.
655
def run(self, revision=None, verbose=False):
658
tree = b.working_tree()
660
tree = b.revision_tree(b.lookup_revision(revision))
662
for fp, fc, kind, fid in tree.list_files():
664
if kind == 'directory':
671
print '%-8s %s%s' % (fc, fp, kindch)
677
class cmd_unknowns(Command):
678
"""List unknown files"""
680
for f in Branch('.').unknowns():
685
class cmd_ignore(Command):
686
"""Ignore a command or pattern
688
To remove patterns from the ignore list, edit the .bzrignore file.
690
If the pattern contains a slash, it is compared to the whole path
691
from the branch root. Otherwise, it is comapred to only the last
692
component of the path.
694
Ignore patterns are case-insensitive on case-insensitive systems.
696
Note: wildcards must be quoted from the shell on Unix.
699
bzr ignore ./Makefile
702
takes_args = ['name_pattern']
704
def run(self, name_pattern):
705
from bzrlib.atomicfile import AtomicFile
709
ifn = b.abspath('.bzrignore')
711
if os.path.exists(ifn):
714
igns = f.read().decode('utf-8')
720
if igns and igns[-1] != '\n':
722
igns += name_pattern + '\n'
725
f = AtomicFile(ifn, 'wt')
726
f.write(igns.encode('utf-8'))
731
inv = b.working_tree().inventory
732
if inv.path2id('.bzrignore'):
733
mutter('.bzrignore is already versioned')
735
mutter('need to make new .bzrignore file versioned')
736
b.add(['.bzrignore'])
740
class cmd_ignored(Command):
741
"""List ignored files and the patterns that matched them.
743
See also: bzr ignore"""
745
tree = Branch('.').working_tree()
746
for path, file_class, kind, file_id in tree.list_files():
747
if file_class != 'I':
749
## XXX: Slightly inefficient since this was already calculated
750
pat = tree.is_ignored(path)
751
print '%-50s %s' % (path, pat)
754
class cmd_lookup_revision(Command):
755
"""Lookup the revision-id from a revision-number
758
bzr lookup-revision 33
761
takes_args = ['revno']
763
def run(self, revno):
767
raise BzrCommandError("not a valid revision-number: %r" % revno)
769
print Branch('.').lookup_revision(revno)
772
class cmd_export(Command):
773
"""Export past revision to destination directory.
775
If no revision is specified this exports the last committed revision."""
776
takes_args = ['dest']
777
takes_options = ['revision']
778
def run(self, dest, revision=None):
781
rh = b.revision_history()[-1]
783
rh = b.lookup_revision(int(revision))
784
t = b.revision_tree(rh)
788
class cmd_cat(Command):
789
"""Write a file's text from a previous revision."""
791
takes_options = ['revision']
792
takes_args = ['filename']
794
def run(self, filename, revision=None):
796
raise BzrCommandError("bzr cat requires a revision number")
798
b.print_file(b.relpath(filename), int(revision))
801
class cmd_local_time_offset(Command):
802
"""Show the offset in seconds from GMT to local time."""
805
print bzrlib.osutils.local_time_offset()
809
class cmd_commit(Command):
810
"""Commit changes into a new revision.
812
If selected files are specified, only changes to those files are
813
committed. If a directory is specified then its contents are also
816
A selected-file commit may fail in some cases where the committed
817
tree would be invalid, such as trying to commit a file in a
818
newly-added directory that is not itself committed.
820
TODO: Run hooks on tree to-be-committed, and after commit.
822
TODO: Strict commit that fails if there are unknown or deleted files.
824
takes_args = ['selected*']
825
takes_options = ['message', 'file', 'verbose']
826
aliases = ['ci', 'checkin']
828
def run(self, message=None, file=None, verbose=True, selected_list=None):
829
from bzrlib.commit import commit
831
## Warning: shadows builtin file()
832
if not message and not file:
833
raise BzrCommandError("please specify a commit message",
834
["use either --message or --file"])
835
elif message and file:
836
raise BzrCommandError("please specify either --message or --file")
840
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
843
commit(b, message, verbose=verbose, specific_files=selected_list)
846
class cmd_check(Command):
847
"""Validate consistency of branch history.
849
This command checks various invariants about the branch storage to
850
detect data corruption or bzr bugs.
852
takes_args = ['dir?']
853
def run(self, dir='.'):
855
bzrlib.check.check(Branch(dir))
859
class cmd_whoami(Command):
860
"""Show bzr user id."""
861
takes_options = ['email']
863
def run(self, email=False):
865
print bzrlib.osutils.user_email()
867
print bzrlib.osutils.username()
870
class cmd_selftest(Command):
871
"""Run internal test suite"""
874
failures, tests = 0, 0
876
import doctest, bzrlib.store
877
bzrlib.trace.verbose = False
879
for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \
880
bzrlib.tree, bzrlib.commands, bzrlib.add:
881
mf, mt = doctest.testmod(m)
884
print '%-40s %3d tests' % (m.__name__, mt),
886
print '%3d FAILED!' % mf
890
print '%-40s %3d tests' % ('total', tests),
892
print '%3d FAILED!' % failures
900
class cmd_version(Command):
901
"""Show version of bzr"""
906
print "bzr (bazaar-ng) %s" % bzrlib.__version__
907
print bzrlib.__copyright__
908
print "http://bazaar-ng.org/"
910
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
911
print "you may use, modify and redistribute it under the terms of the GNU"
912
print "General Public License version 2 or later."
915
class cmd_rocks(Command):
916
"""Statement of optimism."""
919
print "it sure does!"
921
def parse_spec(spec):
923
parsed = spec.split('/@')
924
assert len(parsed) == 2
928
parsed[1] = int(parsed[1])
931
parsed = [spec, None]
934
class cmd_merge(Command):
935
"""Perform a three-way merge of trees."""
936
takes_args = ['other_spec', 'base_spec']
938
def run(self, other_spec, base_spec):
939
merge.merge(parse_spec(other_spec), parse_spec(base_spec))
941
class cmd_assert_fail(Command):
942
"""Test reporting of assertion failures"""
945
assert False, "always fails"
948
class cmd_help(Command):
949
"""Show help on a command or other topic.
951
For a list of all available commands, say 'bzr help commands'."""
952
takes_args = ['topic?']
955
def run(self, topic=None):
960
class cmd_update_stat_cache(Command):
961
"""Update stat-cache mapping inodes to SHA-1 hashes.
968
statcache.update_cache(b.base, b.read_working_inventory())
971
######################################################################
975
# list of all available options; the rhs can be either None for an
976
# option that takes no argument, or a constructor function that checks
1001
def parse_args(argv):
1002
"""Parse command line.
1004
Arguments and options are parsed at this level before being passed
1005
down to specific command handlers. This routine knows, from a
1006
lookup table, something about the available options, what optargs
1007
they take, and which commands will accept them.
1009
>>> parse_args('--help'.split())
1010
([], {'help': True})
1011
>>> parse_args('--version'.split())
1012
([], {'version': True})
1013
>>> parse_args('status --all'.split())
1014
(['status'], {'all': True})
1015
>>> parse_args('commit --message=biter'.split())
1016
(['commit'], {'message': u'biter'})
1021
# TODO: Maybe handle '--' to end options?
1026
# option names must not be unicode
1030
mutter(" got option %r" % a)
1032
optname, optarg = a[2:].split('=', 1)
1035
if optname not in OPTIONS:
1036
bailout('unknown long option %r' % a)
1039
if shortopt not in SHORT_OPTIONS:
1040
bailout('unknown short option %r' % a)
1041
optname = SHORT_OPTIONS[shortopt]
1044
# XXX: Do we ever want to support this, e.g. for -r?
1045
bailout('repeated option %r' % a)
1047
optargfn = OPTIONS[optname]
1051
bailout('option %r needs an argument' % a)
1053
optarg = argv.pop(0)
1054
opts[optname] = optargfn(optarg)
1057
bailout('option %r takes no argument' % optname)
1058
opts[optname] = True
1067
def _match_argform(cmd, takes_args, args):
1070
# step through args and takes_args, allowing appropriate 0-many matches
1071
for ap in takes_args:
1075
argdict[argname] = args.pop(0)
1076
elif ap[-1] == '*': # all remaining arguments
1078
argdict[argname + '_list'] = args[:]
1081
argdict[argname + '_list'] = None
1084
raise BzrCommandError("command %r needs one or more %s"
1085
% (cmd, argname.upper()))
1087
argdict[argname + '_list'] = args[:]
1089
elif ap[-1] == '$': # all but one
1091
raise BzrCommandError("command %r needs one or more %s"
1092
% (cmd, argname.upper()))
1093
argdict[argname + '_list'] = args[:-1]
1099
raise BzrCommandError("command %r requires argument %s"
1100
% (cmd, argname.upper()))
1102
argdict[argname] = args.pop(0)
1105
raise BzrCommandError("extra argument to command %s: %s"
1113
"""Execute a command.
1115
This is similar to main(), but without all the trappings for
1116
logging and error handling.
1118
argv = [a.decode(bzrlib.user_encoding) for a in argv]
1121
args, opts = parse_args(argv[1:])
1129
elif 'version' in opts:
1132
cmd = str(args.pop(0))
1139
canonical_cmd, cmd_class = get_cmd_class(cmd)
1142
if 'profile' in opts:
1148
# check options are reasonable
1149
allowed = cmd_class.takes_options
1151
if oname not in allowed:
1152
raise BzrCommandError("option '--%s' is not allowed for command %r"
1155
# mix arguments and options into one dictionary
1156
cmdargs = _match_argform(cmd, cmd_class.takes_args, args)
1158
for k, v in opts.items():
1159
cmdopts[k.replace('-', '_')] = v
1162
import hotshot, tempfile
1163
pffileno, pfname = tempfile.mkstemp()
1165
prof = hotshot.Profile(pfname)
1166
ret = prof.runcall(cmd_class, cmdopts, cmdargs) or 0
1169
import hotshot.stats
1170
stats = hotshot.stats.load(pfname)
1172
stats.sort_stats('time')
1173
## XXX: Might like to write to stderr or the trace file instead but
1174
## print_stats seems hardcoded to stdout
1175
stats.print_stats(20)
1183
return cmd_class(cmdopts, cmdargs).status
1186
def _report_exception(summary, quiet=False):
1188
log_error('bzr: ' + summary)
1189
bzrlib.trace.log_exception()
1192
tb = sys.exc_info()[2]
1193
exinfo = traceback.extract_tb(tb)
1195
sys.stderr.write(' at %s:%d in %s()\n' % exinfo[-1][:3])
1196
sys.stderr.write(' see ~/.bzr.log for debug information\n')
1203
bzrlib.open_tracefile(argv)
1208
return run_bzr(argv)
1210
# do this here inside the exception wrappers to catch EPIPE
1213
quiet = isinstance(e, (BzrCommandError))
1214
_report_exception('error: ' + e.args[0], quiet=quiet)
1217
# some explanation or hints
1220
except AssertionError, e:
1221
msg = 'assertion failed'
1223
msg += ': ' + str(e)
1224
_report_exception(msg)
1226
except KeyboardInterrupt, e:
1227
_report_exception('interrupted', quiet=True)
1229
except Exception, e:
1231
if (isinstance(e, IOError)
1232
and hasattr(e, 'errno')
1233
and e.errno == errno.EPIPE):
1237
msg = str(e).rstrip('\n')
1238
_report_exception(msg, quiet)
1241
bzrlib.trace.close_trace()
1244
if __name__ == '__main__':
1245
sys.exit(main(sys.argv))
added
removed
bzrlib/commands.py
