« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 567
- compare with another revision
- download diff
- download tarball
- view history from revision 567
- Committer: Martin Pool
- Date: 2005-05-26 16:58:09 UTC
- Revision ID: mbp@sourcefrog.net-20050526165809-70901dd62ebe9b91
- New form 'bzr log -r FROM:TO'
patch from John A Meinel
patch from John A Meinel
- files added:
- bzrlib/statcache.py
- files removed:
- HACKING
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- contrib/emacs
- tools
- files renamed:
- contrib/bash/bzr.simple => contrib/bash/bzr
- bzrlib/util/elementtree/ => elementtree/
- bzrlib/util/urlgrabber/ => urlgrabber/
- files modified:
- .bzrignore
added
removed
bzrlib/commands.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
17
18
# TODO: probably should say which arguments are candidates for glob
19
# expansion on windows and do that at the command level.
20
21
# TODO: Help messages for options.
22
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.
26
27
28
# TODO: Help messages for options.
29
30
# TODO: Define arguments by objects, rather than just using names.
31
# Those objects can specify the expected type of the argument, which
32
# would help with validation and shell completion.
33
34
35
36
import sys
37
import os
38
from warnings import warn
39
from inspect import getdoc
18
19
import sys, os, time, os.path
40
20
41
21
import bzrlib
42
import bzrlib.trace
43
from bzrlib.trace import mutter, note, log_error, warning
44
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError, NotBranchError
45
from bzrlib.branch import find_branch
46
from bzrlib import BZRDIR
47
48
plugin_cmds = {}
49
50
51
def register_command(cmd):
52
"Utility function to help register a command"
53
global plugin_cmds
54
k = cmd.__name__
55
if k.startswith("cmd_"):
56
k_unsquished = _unsquish_command_name(k)
57
else:
58
k_unsquished = 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
else:
63
log_error('Two plugins defined the same command: %r' % k)
64
log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
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, \
28
format_date
29
from bzrlib import merge
65
30
66
31
67
32
def _squish_command_name(cmd):
72
37
assert cmd.startswith("cmd_")
73
38
return cmd[4:].replace('_','-')
74
39
75
76
40
def _parse_revision_str(revstr):
77
"""This handles a revision string -> revno.
78
79
This always returns a list. The list will have one element for
80
81
It supports integers directly, but everything else it
82
defers for passing to Branch.get_revision_info()
83
84
>>> _parse_revision_str('234')
85
[234]
86
>>> _parse_revision_str('234..567')
87
[234, 567]
88
>>> _parse_revision_str('..')
89
[None, None]
90
>>> _parse_revision_str('..234')
91
[None, 234]
92
>>> _parse_revision_str('234..')
93
[234, None]
94
>>> _parse_revision_str('234..456..789') # Maybe this should be an error
95
[234, 456, 789]
96
>>> _parse_revision_str('234....789') # Error?
97
[234, None, 789]
98
>>> _parse_revision_str('revid:test@other.com-234234')
99
['revid:test@other.com-234234']
100
>>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
101
['revid:test@other.com-234234', 'revid:test@other.com-234235']
102
>>> _parse_revision_str('revid:test@other.com-234234..23')
103
['revid:test@other.com-234234', 23]
104
>>> _parse_revision_str('date:2005-04-12')
105
['date:2005-04-12']
106
>>> _parse_revision_str('date:2005-04-12 12:24:33')
107
['date:2005-04-12 12:24:33']
108
>>> _parse_revision_str('date:2005-04-12T12:24:33')
109
['date:2005-04-12T12:24:33']
110
>>> _parse_revision_str('date:2005-04-12,12:24:33')
111
['date:2005-04-12,12:24:33']
112
>>> _parse_revision_str('-5..23')
113
[-5, 23]
114
>>> _parse_revision_str('-5')
115
[-5]
116
>>> _parse_revision_str('123a')
117
['123a']
118
>>> _parse_revision_str('abc')
119
['abc']
41
"""This handles a revision string -> revno.
42
43
There are several possibilities:
44
45
'234' -> 234
46
'234:345' -> [234, 345]
47
':234' -> [None, 234]
48
'234:' -> [234, None]
49
50
In the future we will also support:
51
'uuid:blah-blah-blah' -> ?
52
'hash:blahblahblah' -> ?
53
potentially:
54
'tag:mytag' -> ?
120
55
"""
121
import re
122
old_format_re = re.compile('\d*:\d*')
123
m = old_format_re.match(revstr)
124
if m:
125
warning('Colon separator for revision numbers is deprecated.'
126
' Use .. instead')
127
revs = []
128
for rev in revstr.split(':'):
129
if rev:
130
revs.append(int(rev))
131
else:
132
revs.append(None)
133
return revs
134
revs = []
135
for x in revstr.split('..'):
136
if not x:
137
revs.append(None)
138
else:
139
try:
140
revs.append(int(x))
141
except ValueError:
142
revs.append(x)
56
if revstr.find(':') != -1:
57
revs = revstr.split(':')
58
if len(revs) > 2:
59
raise ValueError('More than 2 pieces not supported for --revision: %r' % revstr)
60
61
if not revs[0]:
62
revs[0] = None
63
else:
64
revs[0] = int(revs[0])
65
66
if not revs[1]:
67
revs[1] = None
68
else:
69
revs[1] = int(revs[1])
70
else:
71
revs = int(revstr)
143
72
return revs
144
73
145
146
def get_merge_type(typestring):
147
"""Attempt to find the merge class/factory associated with a string."""
148
from merge import merge_types
149
try:
150
return merge_types[typestring][0]
151
except KeyError:
152
templ = '%s%%7s: %%s' % (' '*12)
153
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
154
type_list = '\n'.join(lines)
155
msg = "No known merge type %s. Supported types are:\n%s" %\
156
(typestring, type_list)
157
raise BzrCommandError(msg)
158
159
160
def _builtin_commands():
161
import bzrlib.builtins
162
r = {}
163
builtins = bzrlib.builtins.__dict__
164
for name in builtins:
165
if name.startswith("cmd_"):
166
real_name = _unsquish_command_name(name)
167
r[real_name] = builtins[name]
168
return r
169
170
171
172
def builtin_command_names():
173
"""Return list of builtin command names."""
174
return _builtin_commands().keys()
175
176
177
def plugin_command_names():
178
return plugin_cmds.keys()
179
180
181
def _get_cmd_dict(plugins_override=True):
182
"""Return name->class mapping for all commands."""
183
d = _builtin_commands()
184
if plugins_override:
185
d.update(plugin_cmds)
186
return d
187
188
189
def get_all_cmds(plugins_override=True):
74
def get_all_cmds():
190
75
"""Return canonical name and class for all registered commands."""
191
for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
192
yield k,v
193
194
195
def get_cmd_object(cmd_name, plugins_override=True):
76
for k, v in globals().iteritems():
77
if k.startswith("cmd_"):
78
yield _unsquish_command_name(k), v
79
80
def get_cmd_class(cmd):
196
81
"""Return the canonical name and command class for a command.
197
198
plugins_override
199
If true, plugin commands can override builtins.
200
82
"""
201
from bzrlib.externalcommand import ExternalCommand
202
203
cmd_name = str(cmd_name) # not unicode
83
cmd = str(cmd) # not unicode
204
84
205
85
# first look up this command under the specified name
206
cmds = _get_cmd_dict(plugins_override=plugins_override)
207
86
try:
208
return cmds[cmd_name]()
87
return cmd, globals()[_squish_command_name(cmd)]
209
88
except KeyError:
210
89
pass
211
90
212
91
# look for any command which claims this as an alias
213
for real_cmd_name, cmd_class in cmds.iteritems():
214
if cmd_name in cmd_class.aliases:
215
return cmd_class()
216
217
cmd_obj = ExternalCommand.find_command(cmd_name)
218
if cmd_obj:
219
return cmd_obj
220
221
raise BzrCommandError("unknown command %r" % cmd_name)
92
for cmdname, cmdclass in get_all_cmds():
93
if cmd in cmdclass.aliases:
94
return cmdname, cmdclass
95
96
cmdclass = ExternalCommand.find_command(cmd)
97
if cmdclass:
98
return cmd, cmdclass
99
100
raise BzrCommandError("unknown command %r" % cmd)
222
101
223
102
224
103
class Command(object):
225
104
"""Base class for commands.
226
105
227
Commands are the heart of the command-line bzr interface.
228
229
The command object mostly handles the mapping of command-line
230
parameters into one or more bzrlib operations, and of the results
231
into textual output.
232
233
Commands normally don't have any state. All their arguments are
234
passed in to the run method. (Subclasses may take a different
235
policy if the behaviour of the instance needs to depend on e.g. a
236
shell plugin and not just its Python class.)
237
238
106
The docstring for an actual command should give a single-line
239
107
summary, then a complete description of the command. A grammar
240
108
description will be inserted.
241
109
242
aliases
243
Other accepted names for this command.
244
245
110
takes_args
246
111
List of argument forms, marked with whether they are optional,
247
112
repeated, etc.
250
115
List of options that may be given for this command.
251
116
252
117
hidden
253
If true, this command isn't advertised. This is typically
254
for commands intended for expert users.
118
If true, this command isn't advertised.
255
119
"""
256
120
aliases = []
257
121
260
124
261
125
hidden = False
262
126
263
def __init__(self):
264
"""Construct an instance of this command."""
265
if self.__doc__ == Command.__doc__:
266
warn("No help message set for %r" % self)
267
268
269
def run_argv(self, argv):
270
"""Parse command line and run."""
271
args, opts = parse_args(argv)
272
273
if 'help' in opts: # e.g. bzr add --help
274
from bzrlib.help import help_on_command
275
help_on_command(self.name())
276
return 0
277
278
# check options are reasonable
279
allowed = self.takes_options
280
for oname in opts:
281
if oname not in allowed:
282
raise BzrCommandError("option '--%s' is not allowed for command %r"
283
% (oname, self.name()))
284
285
# mix arguments and options into one dictionary
286
cmdargs = _match_argform(self.name(), self.takes_args, args)
287
cmdopts = {}
288
for k, v in opts.items():
289
cmdopts[k.replace('-', '_')] = v
290
291
all_cmd_args = cmdargs.copy()
292
all_cmd_args.update(cmdopts)
293
294
return self.run(**all_cmd_args)
127
def __init__(self, options, arguments):
128
"""Construct and run the command.
129
130
Sets self.status to the return value of run()."""
131
assert isinstance(options, dict)
132
assert isinstance(arguments, dict)
133
cmdargs = options.copy()
134
cmdargs.update(arguments)
135
assert self.__doc__ != Command.__doc__, \
136
("No help message set for %r" % self)
137
self.status = self.run(**cmdargs)
295
138
296
139
297
140
def run(self):
298
"""Actually run the command.
141
"""Override this in sub-classes.
299
142
300
143
This is invoked with the options and arguments bound to
301
144
keyword parameters.
302
145
303
Return 0 or None if the command was successful, or a non-zero
304
shell error code if not. It's OK for this method to allow
305
an exception to raise up.
146
Return 0 or None if the command was successful, or a shell
147
error code if not.
306
148
"""
307
raise NotImplementedError()
308
309
310
def help(self):
311
"""Return help message for this class."""
312
if self.__doc__ is Command.__doc__:
313
return None
314
return getdoc(self)
315
316
def name(self):
317
return _unsquish_command_name(self.__class__.__name__)
318
149
return 0
150
151
152
class ExternalCommand(Command):
153
"""Class to wrap external commands.
154
155
We cheat a little here, when get_cmd_class() calls us we actually give it back
156
an object we construct that has the appropriate path, help, options etc for the
157
specified command.
158
159
When run_bzr() tries to instantiate that 'class' it gets caught by the __call__
160
method, which we override to call the Command.__init__ method. That then calls
161
our run method which is pretty straight forward.
162
163
The only wrinkle is that we have to map bzr's dictionary of options and arguments
164
back into command line options and arguments for the script.
165
"""
166
167
def find_command(cls, cmd):
168
bzrpath = os.environ.get('BZRPATH', '')
169
170
for dir in bzrpath.split(':'):
171
path = os.path.join(dir, cmd)
172
if os.path.isfile(path):
173
return ExternalCommand(path)
174
175
return None
176
177
find_command = classmethod(find_command)
178
179
def __init__(self, path):
180
self.path = path
181
182
# TODO: If either of these fail, we should detect that and
183
# assume that path is not really a bzr plugin after all.
184
185
pipe = os.popen('%s --bzr-usage' % path, 'r')
186
self.takes_options = pipe.readline().split()
187
self.takes_args = pipe.readline().split()
188
pipe.close()
189
190
pipe = os.popen('%s --bzr-help' % path, 'r')
191
self.__doc__ = pipe.read()
192
pipe.close()
193
194
def __call__(self, options, arguments):
195
Command.__init__(self, options, arguments)
196
return self
197
198
def run(self, **kargs):
199
opts = []
200
args = []
201
202
keys = kargs.keys()
203
keys.sort()
204
for name in keys:
205
value = kargs[name]
206
if OPTIONS.has_key(name):
207
# it's an option
208
opts.append('--%s' % name)
209
if value is not None and value is not True:
210
opts.append(str(value))
211
else:
212
# it's an arg, or arg list
213
if type(value) is not list:
214
value = [value]
215
for v in value:
216
if v is not None:
217
args.append(str(v))
218
219
self.status = os.spawnv(os.P_WAIT, self.path, [self.path] + opts + args)
220
return self.status
221
222
223
class cmd_status(Command):
224
"""Display status summary.
225
226
This reports on versioned and unknown files, reporting them
227
grouped by state. Possible states are:
228
229
added
230
Versioned in the working copy but not in the previous revision.
231
232
removed
233
Versioned in the previous revision but removed or deleted
234
in the working copy.
235
236
renamed
237
Path of this file changed from the previous revision;
238
the text may also have changed. This includes files whose
239
parent directory was renamed.
240
241
modified
242
Text has changed since the previous revision.
243
244
unchanged
245
Nothing about this file has changed since the previous revision.
246
Only shown with --all.
247
248
unknown
249
Not versioned and not matching an ignore pattern.
250
251
To see ignored files use 'bzr ignored'. For details in the
252
changes to file texts, use 'bzr diff'.
253
254
If no arguments are specified, the status of the entire working
255
directory is shown. Otherwise, only the status of the specified
256
files or directories is reported. If a directory is given, status
257
is reported for everything inside that directory.
258
"""
259
takes_args = ['file*']
260
takes_options = ['all', 'show-ids']
261
aliases = ['st', 'stat']
262
263
def run(self, all=False, show_ids=False, file_list=None):
264
if file_list:
265
b = Branch(file_list[0], lock_mode='r')
266
file_list = [b.relpath(x) for x in file_list]
267
# special case: only one path was given and it's the root
268
# of the branch
269
if file_list == ['']:
270
file_list = None
271
else:
272
b = Branch('.', lock_mode='r')
273
import status
274
status.show_status(b, show_unchanged=all, show_ids=show_ids,
275
specific_files=file_list)
276
277
278
class cmd_cat_revision(Command):
279
"""Write out metadata for a revision."""
280
281
hidden = True
282
takes_args = ['revision_id']
283
284
def run(self, revision_id):
285
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
286
287
288
class cmd_revno(Command):
289
"""Show current revision number.
290
291
This is equal to the number of revisions on this branch."""
292
def run(self):
293
print Branch('.').revno()
294
295
296
class cmd_add(Command):
297
"""Add specified files or directories.
298
299
In non-recursive mode, all the named items are added, regardless
300
of whether they were previously ignored. A warning is given if
301
any of the named files are already versioned.
302
303
In recursive mode (the default), files are treated the same way
304
but the behaviour for directories is different. Directories that
305
are already versioned do not give a warning. All directories,
306
whether already versioned or not, are searched for files or
307
subdirectories that are neither versioned or ignored, and these
308
are added. This search proceeds recursively into versioned
309
directories.
310
311
Therefore simply saying 'bzr add .' will version all files that
312
are currently unknown.
313
314
TODO: Perhaps adding a file whose directly is not versioned should
315
recursively add that parent, rather than giving an error?
316
"""
317
takes_args = ['file+']
318
takes_options = ['verbose']
319
320
def run(self, file_list, verbose=False):
321
bzrlib.add.smart_add(file_list, verbose)
322
323
324
class cmd_relpath(Command):
325
"""Show path of a file relative to root"""
326
takes_args = ['filename']
327
328
def run(self, filename):
329
print Branch(filename).relpath(filename)
330
331
332
333
class cmd_inventory(Command):
334
"""Show inventory of the current working copy or a revision."""
335
takes_options = ['revision']
336
337
def run(self, revision=None):
338
b = Branch('.')
339
if revision == None:
340
inv = b.read_working_inventory()
341
else:
342
inv = b.get_revision_inventory(b.lookup_revision(revision))
343
344
for path, entry in inv.entries():
345
print '%-50s %s' % (entry.file_id, path)
346
347
348
class cmd_move(Command):
349
"""Move files to a different directory.
350
351
examples:
352
bzr move *.txt doc
353
354
The destination must be a versioned directory in the same branch.
355
"""
356
takes_args = ['source$', 'dest']
357
def run(self, source_list, dest):
358
b = Branch('.')
359
360
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
361
362
363
class cmd_rename(Command):
364
"""Change the name of an entry.
365
366
examples:
367
bzr rename frob.c frobber.c
368
bzr rename src/frob.c lib/frob.c
369
370
It is an error if the destination name exists.
371
372
See also the 'move' command, which moves files into a different
373
directory without changing their name.
374
375
TODO: Some way to rename multiple files without invoking bzr for each
376
one?"""
377
takes_args = ['from_name', 'to_name']
378
379
def run(self, from_name, to_name):
380
b = Branch('.')
381
b.rename_one(b.relpath(from_name), b.relpath(to_name))
382
383
384
385
class cmd_renames(Command):
386
"""Show list of renamed files.
387
388
TODO: Option to show renames between two historical versions.
389
390
TODO: Only show renames under dir, rather than in the whole branch.
391
"""
392
takes_args = ['dir?']
393
394
def run(self, dir='.'):
395
b = Branch(dir)
396
old_inv = b.basis_tree().inventory
397
new_inv = b.read_working_inventory()
398
399
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
400
renames.sort()
401
for old_name, new_name in renames:
402
print "%s => %s" % (old_name, new_name)
403
404
405
class cmd_info(Command):
406
"""Show statistical information about a branch."""
407
takes_args = ['branch?']
408
409
def run(self, branch=None):
410
import info
411
412
from branch import find_branch
413
b = find_branch(branch)
414
info.show_info(b)
415
416
417
class cmd_remove(Command):
418
"""Make a file unversioned.
419
420
This makes bzr stop tracking changes to a versioned file. It does
421
not delete the working copy.
422
"""
423
takes_args = ['file+']
424
takes_options = ['verbose']
425
426
def run(self, file_list, verbose=False):
427
b = Branch(file_list[0])
428
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
429
430
431
class cmd_file_id(Command):
432
"""Print file_id of a particular file or directory.
433
434
The file_id is assigned when the file is first added and remains the
435
same through all revisions where the file exists, even when it is
436
moved or renamed.
437
"""
438
hidden = True
439
takes_args = ['filename']
440
def run(self, filename):
441
b = Branch(filename)
442
i = b.inventory.path2id(b.relpath(filename))
443
if i == None:
444
bailout("%r is not a versioned file" % filename)
445
else:
446
print i
447
448
449
class cmd_file_path(Command):
450
"""Print path of file_ids to a file or directory.
451
452
This prints one line for each directory down to the target,
453
starting at the branch root."""
454
hidden = True
455
takes_args = ['filename']
456
def run(self, filename):
457
b = Branch(filename)
458
inv = b.inventory
459
fid = inv.path2id(b.relpath(filename))
460
if fid == None:
461
bailout("%r is not a versioned file" % filename)
462
for fip in inv.get_idpath(fid):
463
print fip
464
465
466
class cmd_revision_history(Command):
467
"""Display list of revision ids on this branch."""
468
def run(self):
469
for patchid in Branch('.').revision_history():
470
print patchid
471
472
473
class cmd_directories(Command):
474
"""Display list of versioned directories in this branch."""
475
def run(self):
476
for name, ie in Branch('.').read_working_inventory().directories():
477
if name == '':
478
print '.'
479
else:
480
print name
481
482
483
class cmd_init(Command):
484
"""Make a directory into a versioned branch.
485
486
Use this to create an empty branch, or before importing an
487
existing project.
488
489
Recipe for importing a tree of files:
490
cd ~/project
491
bzr init
492
bzr add -v .
493
bzr status
494
bzr commit -m 'imported project'
495
"""
496
def run(self):
497
Branch('.', init=True)
498
499
500
class cmd_diff(Command):
501
"""Show differences in working tree.
502
503
If files are listed, only the changes in those files are listed.
504
Otherwise, all changes for the tree are listed.
505
506
TODO: Given two revision arguments, show the difference between them.
507
508
TODO: Allow diff across branches.
509
510
TODO: Option to use external diff command; could be GNU diff, wdiff,
511
or a graphical diff.
512
513
TODO: Python difflib is not exactly the same as unidiff; should
514
either fix it up or prefer to use an external diff.
515
516
TODO: If a directory is given, diff everything under that.
517
518
TODO: Selected-file diff is inefficient and doesn't show you
519
deleted files.
520
521
TODO: This probably handles non-Unix newlines poorly.
522
"""
523
524
takes_args = ['file*']
525
takes_options = ['revision']
526
aliases = ['di']
527
528
def run(self, revision=None, file_list=None):
529
from bzrlib.diff import show_diff
530
from bzrlib import find_branch
531
532
if file_list:
533
b = find_branch(file_list[0], lock_mode='r')
534
file_list = [b.relpath(f) for f in file_list]
535
if file_list == ['']:
536
# just pointing to top-of-tree
537
file_list = None
538
else:
539
b = Branch('.', lock_mode='r')
540
541
show_diff(b, revision, specific_files=file_list)
542
543
544
545
546
547
class cmd_deleted(Command):
548
"""List files deleted in the working tree.
549
550
TODO: Show files deleted since a previous revision, or between two revisions.
551
"""
552
def run(self, show_ids=False):
553
b = Branch('.')
554
old = b.basis_tree()
555
new = b.working_tree()
556
557
## TODO: Much more efficient way to do this: read in new
558
## directories with readdir, rather than stating each one. Same
559
## level of effort but possibly much less IO. (Or possibly not,
560
## if the directories are very large...)
561
562
for path, ie in old.inventory.iter_entries():
563
if not new.has_id(ie.file_id):
564
if show_ids:
565
print '%-50s %s' % (path, ie.file_id)
566
else:
567
print path
568
569
570
class cmd_modified(Command):
571
"""List files modified in working tree."""
572
hidden = True
573
def run(self):
574
import statcache
575
b = Branch('.')
576
inv = b.read_working_inventory()
577
sc = statcache.update_cache(b, inv)
578
basis = b.basis_tree()
579
basis_inv = basis.inventory
580
581
# We used to do this through iter_entries(), but that's slow
582
# when most of the files are unmodified, as is usually the
583
# case. So instead we iterate by inventory entry, and only
584
# calculate paths as necessary.
585
586
for file_id in basis_inv:
587
cacheentry = sc.get(file_id)
588
if not cacheentry: # deleted
589
continue
590
ie = basis_inv[file_id]
591
if cacheentry[statcache.SC_SHA1] != ie.text_sha1:
592
path = inv.id2path(file_id)
593
print path
594
595
596
597
class cmd_added(Command):
598
"""List files added in working tree."""
599
hidden = True
600
def run(self):
601
b = Branch('.')
602
wt = b.working_tree()
603
basis_inv = b.basis_tree().inventory
604
inv = wt.inventory
605
for file_id in inv:
606
if file_id in basis_inv:
607
continue
608
path = inv.id2path(file_id)
609
if not os.access(b.abspath(path), os.F_OK):
610
continue
611
print path
612
613
614
615
class cmd_root(Command):
616
"""Show the tree root directory.
617
618
The root is the nearest enclosing directory with a .bzr control
619
directory."""
620
takes_args = ['filename?']
621
def run(self, filename=None):
622
"""Print the branch root."""
623
from branch import find_branch
624
b = find_branch(filename)
625
print getattr(b, 'base', None) or getattr(b, 'baseurl')
626
627
628
class cmd_log(Command):
629
"""Show log of this branch.
630
631
To request a range of logs, you can use the command -r begin:end
632
-r revision requests a specific revision, -r :end or -r begin: are
633
also valid.
634
635
TODO: Make --revision support uuid: and hash: [future tag:] notation.
636
637
"""
638
639
takes_args = ['filename?']
640
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision']
641
642
def run(self, filename=None, timezone='original',
643
verbose=False,
644
show_ids=False,
645
forward=False,
646
revision=None):
647
from bzrlib import show_log, find_branch
648
import codecs
649
650
direction = (forward and 'forward') or 'reverse'
651
652
if filename:
653
b = find_branch(filename, lock_mode='r')
654
fp = b.relpath(filename)
655
if fp:
656
file_id = b.read_working_inventory().path2id(fp)
657
else:
658
file_id = None # points to branch root
659
else:
660
b = find_branch('.', lock_mode='r')
661
file_id = None
662
663
if revision == None:
664
revision = [None, None]
665
elif isinstance(revision, int):
666
revision = [revision, revision]
667
else:
668
# pair of revisions?
669
pass
670
671
assert len(revision) == 2
672
673
mutter('encoding log as %r' % bzrlib.user_encoding)
674
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout)
675
676
show_log(b, file_id,
677
show_timezone=timezone,
678
verbose=verbose,
679
show_ids=show_ids,
680
to_file=outf,
681
direction=direction,
682
start_revision=revision[0],
683
end_revision=revision[1])
684
685
686
687
class cmd_touching_revisions(Command):
688
"""Return revision-ids which affected a particular file.
689
690
A more user-friendly interface is "bzr log FILE"."""
691
hidden = True
692
takes_args = ["filename"]
693
def run(self, filename):
694
b = Branch(filename, lock_mode='r')
695
inv = b.read_working_inventory()
696
file_id = inv.path2id(b.relpath(filename))
697
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
698
print "%6d %s" % (revno, what)
699
700
701
class cmd_ls(Command):
702
"""List files in a tree.
703
704
TODO: Take a revision or remote path and list that tree instead.
705
"""
706
hidden = True
707
def run(self, revision=None, verbose=False):
708
b = Branch('.')
709
if revision == None:
710
tree = b.working_tree()
711
else:
712
tree = b.revision_tree(b.lookup_revision(revision))
713
714
for fp, fc, kind, fid in tree.list_files():
715
if verbose:
716
if kind == 'directory':
717
kindch = '/'
718
elif kind == 'file':
719
kindch = ''
720
else:
721
kindch = '???'
722
723
print '%-8s %s%s' % (fc, fp, kindch)
724
else:
725
print fp
726
727
728
729
class cmd_unknowns(Command):
730
"""List unknown files"""
731
def run(self):
732
for f in Branch('.').unknowns():
733
print quotefn(f)
734
735
736
737
class cmd_ignore(Command):
738
"""Ignore a command or pattern
739
740
To remove patterns from the ignore list, edit the .bzrignore file.
741
742
If the pattern contains a slash, it is compared to the whole path
743
from the branch root. Otherwise, it is comapred to only the last
744
component of the path.
745
746
Ignore patterns are case-insensitive on case-insensitive systems.
747
748
Note: wildcards must be quoted from the shell on Unix.
749
750
examples:
751
bzr ignore ./Makefile
752
bzr ignore '*.class'
753
"""
754
takes_args = ['name_pattern']
755
756
def run(self, name_pattern):
757
from bzrlib.atomicfile import AtomicFile
758
import codecs
759
760
b = Branch('.')
761
ifn = b.abspath('.bzrignore')
762
763
if os.path.exists(ifn):
764
f = open(ifn, 'rt')
765
try:
766
igns = f.read().decode('utf-8')
767
finally:
768
f.close()
769
else:
770
igns = ''
771
772
if igns and igns[-1] != '\n':
773
igns += '\n'
774
igns += name_pattern + '\n'
775
776
try:
777
f = AtomicFile(ifn, 'wt')
778
f.write(igns.encode('utf-8'))
779
f.commit()
780
finally:
781
f.close()
782
783
inv = b.working_tree().inventory
784
if inv.path2id('.bzrignore'):
785
mutter('.bzrignore is already versioned')
786
else:
787
mutter('need to make new .bzrignore file versioned')
788
b.add(['.bzrignore'])
789
790
791
792
class cmd_ignored(Command):
793
"""List ignored files and the patterns that matched them.
794
795
See also: bzr ignore"""
796
def run(self):
797
tree = Branch('.').working_tree()
798
for path, file_class, kind, file_id in tree.list_files():
799
if file_class != 'I':
800
continue
801
## XXX: Slightly inefficient since this was already calculated
802
pat = tree.is_ignored(path)
803
print '%-50s %s' % (path, pat)
804
805
806
class cmd_lookup_revision(Command):
807
"""Lookup the revision-id from a revision-number
808
809
example:
810
bzr lookup-revision 33
811
"""
812
hidden = True
813
takes_args = ['revno']
814
815
def run(self, revno):
816
try:
817
revno = int(revno)
818
except ValueError:
819
raise BzrCommandError("not a valid revision-number: %r" % revno)
820
821
print Branch('.').lookup_revision(revno)
822
823
824
class cmd_export(Command):
825
"""Export past revision to destination directory.
826
827
If no revision is specified this exports the last committed revision."""
828
takes_args = ['dest']
829
takes_options = ['revision']
830
def run(self, dest, revision=None):
831
b = Branch('.')
832
if revision == None:
833
rh = b.revision_history()[-1]
834
else:
835
rh = b.lookup_revision(int(revision))
836
t = b.revision_tree(rh)
837
t.export(dest)
838
839
840
class cmd_cat(Command):
841
"""Write a file's text from a previous revision."""
842
843
takes_options = ['revision']
844
takes_args = ['filename']
845
846
def run(self, filename, revision=None):
847
if revision == None:
848
raise BzrCommandError("bzr cat requires a revision number")
849
b = Branch('.')
850
b.print_file(b.relpath(filename), int(revision))
851
852
853
class cmd_local_time_offset(Command):
854
"""Show the offset in seconds from GMT to local time."""
855
hidden = True
856
def run(self):
857
print bzrlib.osutils.local_time_offset()
858
859
860
861
class cmd_commit(Command):
862
"""Commit changes into a new revision.
863
864
If selected files are specified, only changes to those files are
865
committed. If a directory is specified then its contents are also
866
committed.
867
868
A selected-file commit may fail in some cases where the committed
869
tree would be invalid, such as trying to commit a file in a
870
newly-added directory that is not itself committed.
871
872
TODO: Run hooks on tree to-be-committed, and after commit.
873
874
TODO: Strict commit that fails if there are unknown or deleted files.
875
"""
876
takes_args = ['selected*']
877
takes_options = ['message', 'file', 'verbose']
878
aliases = ['ci', 'checkin']
879
880
def run(self, message=None, file=None, verbose=True, selected_list=None):
881
from bzrlib.commit import commit
882
883
## Warning: shadows builtin file()
884
if not message and not file:
885
raise BzrCommandError("please specify a commit message",
886
["use either --message or --file"])
887
elif message and file:
888
raise BzrCommandError("please specify either --message or --file")
889
890
if file:
891
import codecs
892
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
893
894
b = Branch('.')
895
commit(b, message, verbose=verbose, specific_files=selected_list)
896
897
898
class cmd_check(Command):
899
"""Validate consistency of branch history.
900
901
This command checks various invariants about the branch storage to
902
detect data corruption or bzr bugs.
903
"""
904
takes_args = ['dir?']
905
def run(self, dir='.'):
906
import bzrlib.check
907
bzrlib.check.check(Branch(dir))
908
909
910
911
class cmd_whoami(Command):
912
"""Show bzr user id."""
913
takes_options = ['email']
914
915
def run(self, email=False):
916
if email:
917
print bzrlib.osutils.user_email()
918
else:
919
print bzrlib.osutils.username()
920
921
922
class cmd_selftest(Command):
923
"""Run internal test suite"""
924
hidden = True
925
def run(self):
926
failures, tests = 0, 0
927
928
import doctest, bzrlib.store
929
bzrlib.trace.verbose = False
930
931
for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \
932
bzrlib.tree, bzrlib.commands, bzrlib.add:
933
mf, mt = doctest.testmod(m)
934
failures += mf
935
tests += mt
936
print '%-40s %3d tests' % (m.__name__, mt),
937
if mf:
938
print '%3d FAILED!' % mf
939
else:
940
print
941
942
print '%-40s %3d tests' % ('total', tests),
943
if failures:
944
print '%3d FAILED!' % failures
945
return 1
946
else:
947
print
948
return 0
949
950
951
952
class cmd_version(Command):
953
"""Show version of bzr"""
954
def run(self):
955
show_version()
956
957
def show_version():
958
print "bzr (bazaar-ng) %s" % bzrlib.__version__
959
print bzrlib.__copyright__
960
print "http://bazaar-ng.org/"
961
print
962
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
963
print "you may use, modify and redistribute it under the terms of the GNU"
964
print "General Public License version 2 or later."
965
966
967
class cmd_rocks(Command):
968
"""Statement of optimism."""
969
hidden = True
970
def run(self):
971
print "it sure does!"
319
972
320
973
def parse_spec(spec):
321
"""
322
>>> parse_spec(None)
323
[None, None]
324
>>> parse_spec("./")
325
['./', None]
326
>>> parse_spec("../@")
327
['..', -1]
328
>>> parse_spec("../f/@35")
329
['../f', 35]
330
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
331
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
332
"""
333
if spec is None:
334
return [None, None]
335
974
if '/@' in spec:
336
975
parsed = spec.split('/@')
337
976
assert len(parsed) == 2
338
977
if parsed[1] == "":
339
978
parsed[1] = -1
340
979
else:
341
try:
342
parsed[1] = int(parsed[1])
343
except ValueError:
344
pass # We can allow stuff like ./@revid:blahblahblah
345
else:
346
assert parsed[1] >=0
980
parsed[1] = int(parsed[1])
981
assert parsed[1] >=0
347
982
else:
348
983
parsed = [spec, None]
349
984
return parsed
350
985
986
class cmd_merge(Command):
987
"""Perform a three-way merge of trees."""
988
takes_args = ['other_spec', 'base_spec']
989
990
def run(self, other_spec, base_spec):
991
merge.merge(parse_spec(other_spec), parse_spec(base_spec))
992
993
class cmd_assert_fail(Command):
994
"""Test reporting of assertion failures"""
995
hidden = True
996
def run(self):
997
assert False, "always fails"
998
999
1000
class cmd_help(Command):
1001
"""Show help on a command or other topic.
1002
1003
For a list of all available commands, say 'bzr help commands'."""
1004
takes_args = ['topic?']
1005
aliases = ['?']
1006
1007
def run(self, topic=None):
1008
import help
1009
help.help(topic)
1010
1011
1012
class cmd_update_stat_cache(Command):
1013
"""Update stat-cache mapping inodes to SHA-1 hashes.
1014
1015
For testing only."""
1016
hidden = True
1017
def run(self):
1018
import statcache
1019
b = Branch('.')
1020
statcache.update_cache(b.base, b.read_working_inventory())
1021
1022
1023
######################################################################
1024
# main routine
1025
351
1026
352
1027
# list of all available options; the rhs can be either None for an
353
1028
# option that takes no argument, or a constructor function that checks
354
1029
# the type.
355
1030
OPTIONS = {
356
1031
'all': None,
357
'diff-options': str,
358
1032
'help': None,
359
1033
'file': unicode,
360
'force': None,
361
'format': unicode,
362
1034
'forward': None,
363
1035
'message': unicode,
364
'no-recurse': None,
365
1036
'profile': None,
366
1037
'revision': _parse_revision_str,
367
'short': None,
368
1038
'show-ids': None,
369
1039
'timezone': str,
370
1040
'verbose': None,
371
1041
'version': None,
372
1042
'email': None,
373
'unchanged': None,
374
'update': None,
375
'long': None,
376
'root': str,
377
'no-backup': None,
378
'merge-type': get_merge_type,
379
'pattern': str,
380
1043
}
381
1044
382
1045
SHORT_OPTIONS = {
1046
'm': 'message',
383
1047
'F': 'file',
384
'h': 'help',
385
'm': 'message',
386
1048
'r': 'revision',
387
1049
'v': 'verbose',
388
'l': 'long',
389
1050
}
390
1051
391
1052
399
1060
400
1061
>>> parse_args('--help'.split())
401
1062
([], {'help': True})
402
>>> parse_args('help -- --invalidcmd'.split())
403
(['help', '--invalidcmd'], {})
404
1063
>>> parse_args('--version'.split())
405
1064
([], {'version': True})
406
1065
>>> parse_args('status --all'.split())
407
1066
(['status'], {'all': True})
408
1067
>>> parse_args('commit --message=biter'.split())
409
1068
(['commit'], {'message': u'biter'})
410
>>> parse_args('log -r 500'.split())
411
(['log'], {'revision': [500]})
412
>>> parse_args('log -r500..600'.split())
413
(['log'], {'revision': [500, 600]})
414
>>> parse_args('log -vr500..600'.split())
415
(['log'], {'verbose': True, 'revision': [500, 600]})
416
>>> parse_args('log -rv500..600'.split()) #the r takes an argument
417
(['log'], {'revision': ['v500', 600]})
418
1069
"""
419
1070
args = []
420
1071
opts = {}
421
1072
422
argsover = False
1073
# TODO: Maybe handle '--' to end options?
1074
423
1075
while argv:
424
1076
a = argv.pop(0)
425
if not argsover and a[0] == '-':
1077
if a[0] == '-':
426
1078
# option names must not be unicode
427
1079
a = str(a)
428
1080
optarg = None
429
1081
if a[1] == '-':
430
if a == '--':
431
# We've received a standalone -- No more flags
432
argsover = True
433
continue
434
1082
mutter(" got option %r" % a)
435
1083
if '=' in a:
436
1084
optname, optarg = a[2:].split('=', 1)
437
1085
else:
438
1086
optname = a[2:]
439
1087
if optname not in OPTIONS:
440
raise BzrError('unknown long option %r' % a)
1088
bailout('unknown long option %r' % a)
441
1089
else:
442
1090
shortopt = a[1:]
443
if shortopt in SHORT_OPTIONS:
444
# Multi-character options must have a space to delimit
445
# their value
446
optname = SHORT_OPTIONS[shortopt]
447
else:
448
# Single character short options, can be chained,
449
# and have their value appended to their name
450
shortopt = a[1:2]
451
if shortopt not in SHORT_OPTIONS:
452
# We didn't find the multi-character name, and we
453
# didn't find the single char name
454
raise BzrError('unknown short option %r' % a)
455
optname = SHORT_OPTIONS[shortopt]
456
457
if a[2:]:
458
# There are extra things on this option
459
# see if it is the value, or if it is another
460
# short option
461
optargfn = OPTIONS[optname]
462
if optargfn is None:
463
# This option does not take an argument, so the
464
# next entry is another short option, pack it back
465
# into the list
466
argv.insert(0, '-' + a[2:])
467
else:
468
# This option takes an argument, so pack it
469
# into the array
470
optarg = a[2:]
1091
if shortopt not in SHORT_OPTIONS:
1092
bailout('unknown short option %r' % a)
1093
optname = SHORT_OPTIONS[shortopt]
471
1094
472
1095
if optname in opts:
473
1096
# XXX: Do we ever want to support this, e.g. for -r?
474
raise BzrError('repeated option %r' % a)
1097
bailout('repeated option %r' % a)
475
1098
476
1099
optargfn = OPTIONS[optname]
477
1100
if optargfn:
478
1101
if optarg == None:
479
1102
if not argv:
480
raise BzrError('option %r needs an argument' % a)
1103
bailout('option %r needs an argument' % a)
481
1104
else:
482
1105
optarg = argv.pop(0)
483
1106
opts[optname] = optargfn(optarg)
484
1107
else:
485
1108
if optarg != None:
486
raise BzrError('option %r takes no argument' % optname)
1109
bailout('option %r takes no argument' % optname)
487
1110
opts[optname] = True
488
1111
else:
489
1112
args.append(a)
538
1161
539
1162
540
1163
541
def apply_profiled(the_callable, *args, **kwargs):
542
import hotshot
543
import tempfile
544
pffileno, pfname = tempfile.mkstemp()
545
try:
546
prof = hotshot.Profile(pfname)
547
try:
548
ret = prof.runcall(the_callable, *args, **kwargs) or 0
549
finally:
550
prof.close()
551
552
import hotshot.stats
553
stats = hotshot.stats.load(pfname)
554
#stats.strip_dirs()
555
stats.sort_stats('time')
556
## XXX: Might like to write to stderr or the trace file instead but
557
## print_stats seems hardcoded to stdout
558
stats.print_stats(20)
559
560
return ret
561
finally:
562
os.close(pffileno)
563
os.remove(pfname)
564
565
566
1164
def run_bzr(argv):
567
1165
"""Execute a command.
568
1166
569
1167
This is similar to main(), but without all the trappings for
570
1168
logging and error handling.
571
572
argv
573
The command-line arguments, without the program name from argv[0]
574
575
Returns a command status or raises an exception.
576
577
Special master options: these must come before the command because
578
they control how the command is interpreted.
579
580
--no-plugins
581
Do not load plugin modules at all
582
583
--builtin
584
Only use builtin commands. (Plugins are still allowed to change
585
other behaviour.)
586
587
--profile
588
Run under the Python profiler.
589
1169
"""
590
591
1170
argv = [a.decode(bzrlib.user_encoding) for a in argv]
592
593
opt_profile = opt_no_plugins = opt_builtin = False
594
595
# --no-plugins is handled specially at a very early stage. We need
596
# to load plugins before doing other command parsing so that they
597
# can override commands, but this needs to happen first.
598
599
for a in argv:
600
if a == '--profile':
601
opt_profile = True
602
elif a == '--no-plugins':
603
opt_no_plugins = True
604
elif a == '--builtin':
605
opt_builtin = True
606
else:
607
break
608
argv.remove(a)
609
610
if (not argv) or (argv[0] == '--help'):
611
from bzrlib.help import help
612
if len(argv) > 1:
613
help(argv[1])
614
else:
615
help()
616
return 0
617
618
if argv[0] == '--version':
619
from bzrlib.builtins import show_version
620
show_version()
621
return 0
622
623
if not opt_no_plugins:
624
from bzrlib.plugin import load_plugins
625
load_plugins()
626
627
cmd = str(argv.pop(0))
628
629
cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
630
631
if opt_profile:
632
ret = apply_profiled(cmd_obj.run_argv, argv)
633
else:
634
ret = cmd_obj.run_argv(argv)
635
return ret or 0
1171
1172
try:
1173
args, opts = parse_args(argv[1:])
1174
if 'help' in opts:
1175
import help
1176
if args:
1177
help.help(args[0])
1178
else:
1179
help.help()
1180
return 0
1181
elif 'version' in opts:
1182
show_version()
1183
return 0
1184
cmd = str(args.pop(0))
1185
except IndexError:
1186
import help
1187
help.help()
1188
return 1
1189
1190
1191
canonical_cmd, cmd_class = get_cmd_class(cmd)
1192
1193
# global option
1194
if 'profile' in opts:
1195
profile = True
1196
del opts['profile']
1197
else:
1198
profile = False
1199
1200
# check options are reasonable
1201
allowed = cmd_class.takes_options
1202
for oname in opts:
1203
if oname not in allowed:
1204
raise BzrCommandError("option '--%s' is not allowed for command %r"
1205
% (oname, cmd))
1206
1207
# mix arguments and options into one dictionary
1208
cmdargs = _match_argform(cmd, cmd_class.takes_args, args)
1209
cmdopts = {}
1210
for k, v in opts.items():
1211
cmdopts[k.replace('-', '_')] = v
1212
1213
if profile:
1214
import hotshot, tempfile
1215
pffileno, pfname = tempfile.mkstemp()
1216
try:
1217
prof = hotshot.Profile(pfname)
1218
ret = prof.runcall(cmd_class, cmdopts, cmdargs) or 0
1219
prof.close()
1220
1221
import hotshot.stats
1222
stats = hotshot.stats.load(pfname)
1223
#stats.strip_dirs()
1224
stats.sort_stats('time')
1225
## XXX: Might like to write to stderr or the trace file instead but
1226
## print_stats seems hardcoded to stdout
1227
stats.print_stats(20)
1228
1229
return ret.status
1230
1231
finally:
1232
os.close(pffileno)
1233
os.remove(pfname)
1234
else:
1235
return cmd_class(cmdopts, cmdargs).status
1236
1237
1238
def _report_exception(summary, quiet=False):
1239
import traceback
1240
log_error('bzr: ' + summary)
1241
bzrlib.trace.log_exception()
1242
1243
if not quiet:
1244
tb = sys.exc_info()[2]
1245
exinfo = traceback.extract_tb(tb)
1246
if exinfo:
1247
sys.stderr.write(' at %s:%d in %s()\n' % exinfo[-1][:3])
1248
sys.stderr.write(' see ~/.bzr.log for debug information\n')
1249
636
1250
637
1251
638
1252
def main(argv):
639
import bzrlib.ui
640
bzrlib.trace.log_startup(argv)
641
bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
1253
import errno
1254
1255
bzrlib.open_tracefile(argv)
642
1256
643
1257
try:
644
1258
try:
645
1259
try:
646
return run_bzr(argv[1:])
1260
return run_bzr(argv)
647
1261
finally:
648
1262
# do this here inside the exception wrappers to catch EPIPE
649
1263
sys.stdout.flush()
650
#wrap common errors as CommandErrors.
651
except (NotBranchError,), e:
652
raise BzrCommandError(str(e))
653
except BzrCommandError, e:
654
# command line syntax error, etc
655
log_error(str(e))
656
return 1
657
except BzrError, e:
658
bzrlib.trace.log_exception()
659
return 1
660
except AssertionError, e:
661
bzrlib.trace.log_exception('assertion failed: ' + str(e))
662
return 3
663
except KeyboardInterrupt, e:
664
bzrlib.trace.note('interrupted')
665
return 2
666
except Exception, e:
667
import errno
668
if (isinstance(e, IOError)
669
and hasattr(e, 'errno')
670
and e.errno == errno.EPIPE):
671
bzrlib.trace.note('broken pipe')
672
return 2
673
else:
674
bzrlib.trace.log_exception()
675
return 2
1264
except BzrError, e:
1265
quiet = isinstance(e, (BzrCommandError))
1266
_report_exception('error: ' + e.args[0], quiet=quiet)
1267
if len(e.args) > 1:
1268
for h in e.args[1]:
1269
# some explanation or hints
1270
log_error(' ' + h)
1271
return 1
1272
except AssertionError, e:
1273
msg = 'assertion failed'
1274
if str(e):
1275
msg += ': ' + str(e)
1276
_report_exception(msg)
1277
return 2
1278
except KeyboardInterrupt, e:
1279
_report_exception('interrupted', quiet=True)
1280
return 2
1281
except Exception, e:
1282
quiet = False
1283
if (isinstance(e, IOError)
1284
and hasattr(e, 'errno')
1285
and e.errno == errno.EPIPE):
1286
quiet = True
1287
msg = 'broken pipe'
1288
else:
1289
msg = str(e).rstrip('\n')
1290
_report_exception(msg, quiet)
1291
return 2
1292
finally:
1293
bzrlib.trace.close_trace()
676
1294
677
1295
678
1296
if __name__ == '__main__':
Loggerhead is a web-based interface for Breezy
Version: 2.0.1