« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 545
- compare with another revision
- download diff
- download tarball
- view history from revision 545
- Committer: Martin Pool
- Date: 2005-05-19 11:11:53 UTC
- Revision ID: mbp@sourcefrog.net-20050519111153-7f799c5987a540c7
- --forward option for log
- files added:
- .rsyncexclude
- contrib
- contrib/bash
- contrib/zsh
- patches
- urlgrabber
- files removed:
- bzrlib/tests.py
- files modified:
- .bzrignore
added
removed
bzrlib/commands.py
1
# Copyright (C) 2004, 2005 by Martin Pool
2
# Copyright (C) 2005 by Canonical Ltd
3
1
# Copyright (C) 2004, 2005 by Canonical Ltd
4
2
5
3
# This program is free software; you can redistribute it and/or modify
6
4
# it under the terms of the GNU General Public License as published by
16
14
# along with this program; if not, write to the Free Software
17
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
16
19
"""Bazaar-NG -- a free distributed version-control tool
20
21
**WARNING: THIS IS AN UNSTABLE DEVELOPMENT VERSION**
22
23
Current limitation include:
24
25
* Metadata format is not stable yet -- you may need to
26
discard history in the future.
27
28
* Insufficient error handling.
29
30
* Many commands unimplemented or partially implemented.
31
32
* Space-inefficient storage.
33
34
* No merge operators yet.
35
36
Interesting commands::
37
38
bzr help [COMMAND]
39
Show help screen
40
bzr version
41
Show software version/licence/non-warranty.
42
bzr init
43
Start versioning the current directory
44
bzr add FILE...
45
Make files versioned.
46
bzr log
47
Show revision history.
48
bzr diff
49
Show changes from last revision to working copy.
50
bzr commit -m 'MESSAGE'
51
Store current state as new revision.
52
bzr export REVNO DESTINATION
53
Export the branch state at a previous version.
54
bzr status
55
Show summary of pending changes.
56
bzr remove FILE...
57
Make a file not versioned.
58
bzr info
59
Show statistics about this branch.
60
"""
61
62
63
64
65
import sys, os, random, time, sha, sets, types, re, shutil, tempfile
66
import traceback, socket, fnmatch, difflib
67
from os import path
68
from sets import Set
69
from pprint import pprint
70
from stat import *
71
from glob import glob
17
18
19
import sys, os, time, os.path
72
20
73
21
import bzrlib
74
from bzrlib.store import ImmutableStore
75
22
from bzrlib.trace import mutter, note, log_error
76
from bzrlib.errors import bailout, BzrError
23
from bzrlib.errors import bailout, BzrError, BzrCheckError, BzrCommandError
77
24
from bzrlib.osutils import quotefn, pumpfile, isdir, isfile
78
from bzrlib.tree import RevisionTree, EmptyTree, WorkingTree, Tree
25
from bzrlib.tree import RevisionTree, EmptyTree, Tree
79
26
from bzrlib.revision import Revision
80
27
from bzrlib import Branch, Inventory, InventoryEntry, ScratchBranch, BZRDIR, \
81
28
format_date
82
83
BZR_DIFF_FORMAT = "## Bazaar-NG diff, format 0 ##\n"
84
BZR_PATCHNAME_FORMAT = 'cset:sha1:%s'
85
86
## standard representation
87
NONE_STRING = '(none)'
88
EMPTY = 'empty'
89
90
91
## TODO: Perhaps a different version of inventory commands that
92
## returns iterators...
93
94
## TODO: Perhaps an AtomicFile class that writes to a temporary file and then renames.
95
96
## TODO: Some kind of locking on branches. Perhaps there should be a
97
## parameter to the branch object saying whether we want a read or
98
## write lock; release it from destructor. Perhaps don't even need a
99
## read lock to look at immutable objects?
100
101
## TODO: Perhaps make UUIDs predictable in test mode to make it easier
102
## to compare output?
103
104
## TODO: Some kind of global code to generate the right Branch object
105
## to work on. Almost, but not quite all, commands need one, and it
106
## can be taken either from their parameters or their working
107
## directory.
108
109
## TODO: rename command, needed soon: check destination doesn't exist
110
## either in working copy or tree; move working copy; update
111
## inventory; write out
112
113
## TODO: move command; check destination is a directory and will not
114
## clash; move it.
115
116
## TODO: command to show renames, one per line, as to->from
117
118
119
120
121
def cmd_status(all=False):
29
from bzrlib import merge
30
31
32
def _squish_command_name(cmd):
33
return 'cmd_' + cmd.replace('-', '_')
34
35
36
def _unsquish_command_name(cmd):
37
assert cmd.startswith("cmd_")
38
return cmd[4:].replace('_','-')
39
40
def get_all_cmds():
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
45
46
def get_cmd_class(cmd):
47
"""Return the canonical name and command class for a command.
48
"""
49
cmd = str(cmd) # not unicode
50
51
# first look up this command under the specified name
52
try:
53
return cmd, globals()[_squish_command_name(cmd)]
54
except KeyError:
55
pass
56
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
61
62
cmdclass = ExternalCommand.find_command(cmd)
63
if cmdclass:
64
return cmd, cmdclass
65
66
raise BzrCommandError("unknown command %r" % cmd)
67
68
69
class Command:
70
"""Base class for commands.
71
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.
75
76
takes_args
77
List of argument forms, marked with whether they are optional,
78
repeated, etc.
79
80
takes_options
81
List of options that may be given for this command.
82
83
hidden
84
If true, this command isn't advertised.
85
"""
86
aliases = []
87
88
takes_args = []
89
takes_options = []
90
91
hidden = False
92
93
def __init__(self, options, arguments):
94
"""Construct and run the command.
95
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)
104
105
106
def run(self):
107
"""Override this in sub-classes.
108
109
This is invoked with the options and arguments bound to
110
keyword parameters.
111
112
Return 0 or None if the command was successful, or a shell
113
error code if not.
114
"""
115
return 0
116
117
118
class ExternalCommand(Command):
119
"""Class to wrap external commands.
120
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
123
specified command.
124
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.
128
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.
131
"""
132
133
def find_command(cls, cmd):
134
bzrpath = os.environ.get('BZRPATH', '')
135
136
for dir in bzrpath.split(':'):
137
path = os.path.join(dir, cmd)
138
if os.path.isfile(path):
139
return ExternalCommand(path)
140
141
return None
142
143
find_command = classmethod(find_command)
144
145
def __init__(self, path):
146
self.path = path
147
148
# TODO: If either of these fail, we should detect that and
149
# assume that path is not really a bzr plugin after all.
150
151
pipe = os.popen('%s --bzr-usage' % path, 'r')
152
self.takes_options = pipe.readline().split()
153
self.takes_args = pipe.readline().split()
154
pipe.close()
155
156
pipe = os.popen('%s --bzr-help' % path, 'r')
157
self.__doc__ = pipe.read()
158
pipe.close()
159
160
def __call__(self, options, arguments):
161
Command.__init__(self, options, arguments)
162
return self
163
164
def run(self, **kargs):
165
opts = []
166
args = []
167
168
keys = kargs.keys()
169
keys.sort()
170
for name in keys:
171
value = kargs[name]
172
if OPTIONS.has_key(name):
173
# it's an option
174
opts.append('--%s' % name)
175
if value is not None and value is not True:
176
opts.append(str(value))
177
else:
178
# it's an arg, or arg list
179
if type(value) is not list:
180
value = [value]
181
for v in value:
182
if v is not None:
183
args.append(str(v))
184
185
self.status = os.spawnv(os.P_WAIT, self.path, [self.path] + opts + args)
186
return self.status
187
188
189
class cmd_status(Command):
122
190
"""Display status summary.
123
191
124
For each file there is a single line giving its file state and name.
125
The name is that in the current revision unless it is deleted or
126
missing, in which case the old name is shown.
127
128
:todo: Don't show unchanged files unless ``--all`` is given?
192
This reports on versioned and unknown files, reporting them
193
grouped by state. Possible states are:
194
195
added
196
Versioned in the working copy but not in the previous revision.
197
198
removed
199
Versioned in the previous revision but removed or deleted
200
in the working copy.
201
202
renamed
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.
206
207
modified
208
Text has changed since the previous revision.
209
210
unchanged
211
Nothing about this file has changed since the previous revision.
212
Only shown with --all.
213
214
unknown
215
Not versioned and not matching an ignore pattern.
216
217
To see ignored files use 'bzr ignored'. For details in the
218
changes to file texts, use 'bzr diff'.
219
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.
129
224
"""
130
Branch('.').show_status(show_all=all)
131
132
133
134
######################################################################
135
# examining history
136
def cmd_get_revision(revision_id):
137
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
138
139
140
def cmd_get_file_text(text_id):
141
"""Get contents of a file by hash."""
142
sf = Branch('.').text_store[text_id]
143
pumpfile(sf, sys.stdout)
144
145
146
147
######################################################################
148
# commands
149
150
151
def cmd_revno():
152
"""Show number of revisions on this branch"""
153
print Branch('.').revno()
154
155
156
157
def cmd_add(file_list, verbose=False):
225
takes_args = ['file*']
226
takes_options = ['all', 'show-ids']
227
aliases = ['st', 'stat']
228
229
def run(self, all=False, show_ids=False, file_list=None):
230
if file_list:
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
234
# of the branch
235
if file_list == ['']:
236
file_list = None
237
else:
238
b = Branch('.', lock_mode='r')
239
import status
240
status.show_status(b, show_unchanged=all, show_ids=show_ids,
241
specific_files=file_list)
242
243
244
class cmd_cat_revision(Command):
245
"""Write out metadata for a revision."""
246
247
hidden = True
248
takes_args = ['revision_id']
249
250
def run(self, revision_id):
251
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
252
253
254
class cmd_revno(Command):
255
"""Show current revision number.
256
257
This is equal to the number of revisions on this branch."""
258
def run(self):
259
print Branch('.').revno()
260
261
262
class cmd_add(Command):
158
263
"""Add specified files or directories.
159
264
160
265
In non-recursive mode, all the named items are added, regardless
171
276
172
277
Therefore simply saying 'bzr add .' will version all files that
173
278
are currently unknown.
174
"""
175
bzrlib.add.smart_add(file_list, verbose)
176
177
178
def cmd_relpath(filename):
179
"""Show path of file relative to root"""
180
print Branch(filename).relpath(filename)
181
182
183
def cmd_inventory(revision=None):
184
"""Show inventory of the current working copy."""
185
## TODO: Also optionally show a previous inventory
186
## TODO: Format options
187
b = Branch('.')
188
if revision == None:
279
280
TODO: Perhaps adding a file whose directly is not versioned should
281
recursively add that parent, rather than giving an error?
282
"""
283
takes_args = ['file+']
284
takes_options = ['verbose']
285
286
def run(self, file_list, verbose=False):
287
bzrlib.add.smart_add(file_list, verbose)
288
289
290
class cmd_relpath(Command):
291
"""Show path of a file relative to root"""
292
takes_args = ['filename']
293
294
def run(self, filename):
295
print Branch(filename).relpath(filename)
296
297
298
299
class cmd_inventory(Command):
300
"""Show inventory of the current working copy or a revision."""
301
takes_options = ['revision']
302
303
def run(self, revision=None):
304
b = Branch('.')
305
if revision == None:
306
inv = b.read_working_inventory()
307
else:
308
inv = b.get_revision_inventory(b.lookup_revision(revision))
309
310
for path, entry in inv.iter_entries():
311
print '%-50s %s' % (entry.file_id, path)
312
313
314
class cmd_move(Command):
315
"""Move files to a different directory.
316
317
examples:
318
bzr move *.txt doc
319
320
The destination must be a versioned directory in the same branch.
321
"""
322
takes_args = ['source$', 'dest']
323
def run(self, source_list, dest):
324
b = Branch('.')
325
326
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
327
328
329
class cmd_rename(Command):
330
"""Change the name of an entry.
331
332
examples:
333
bzr rename frob.c frobber.c
334
bzr rename src/frob.c lib/frob.c
335
336
It is an error if the destination name exists.
337
338
See also the 'move' command, which moves files into a different
339
directory without changing their name.
340
341
TODO: Some way to rename multiple files without invoking bzr for each
342
one?"""
343
takes_args = ['from_name', 'to_name']
344
345
def run(self, from_name, to_name):
346
b = Branch('.')
347
b.rename_one(b.relpath(from_name), b.relpath(to_name))
348
349
350
351
class cmd_renames(Command):
352
"""Show list of renamed files.
353
354
TODO: Option to show renames between two historical versions.
355
356
TODO: Only show renames under dir, rather than in the whole branch.
357
"""
358
takes_args = ['dir?']
359
360
def run(self, dir='.'):
361
b = Branch(dir)
362
old_inv = b.basis_tree().inventory
363
new_inv = b.read_working_inventory()
364
365
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
366
renames.sort()
367
for old_name, new_name in renames:
368
print "%s => %s" % (old_name, new_name)
369
370
371
class cmd_info(Command):
372
"""Show statistical information about a branch."""
373
takes_args = ['branch?']
374
375
def run(self, branch=None):
376
import info
377
378
from branch import find_branch
379
b = find_branch(branch)
380
info.show_info(b)
381
382
383
class cmd_remove(Command):
384
"""Make a file unversioned.
385
386
This makes bzr stop tracking changes to a versioned file. It does
387
not delete the working copy.
388
"""
389
takes_args = ['file+']
390
takes_options = ['verbose']
391
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)
395
396
397
class cmd_file_id(Command):
398
"""Print file_id of a particular file or directory.
399
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
402
moved or renamed.
403
"""
404
hidden = True
405
takes_args = ['filename']
406
def run(self, filename):
407
b = Branch(filename)
408
i = b.inventory.path2id(b.relpath(filename))
409
if i == None:
410
bailout("%r is not a versioned file" % filename)
411
else:
412
print i
413
414
415
class cmd_file_path(Command):
416
"""Print path of file_ids to a file or directory.
417
418
This prints one line for each directory down to the target,
419
starting at the branch root."""
420
hidden = True
421
takes_args = ['filename']
422
def run(self, filename):
423
b = Branch(filename)
424
inv = b.inventory
425
fid = inv.path2id(b.relpath(filename))
426
if fid == None:
427
bailout("%r is not a versioned file" % filename)
428
for fip in inv.get_idpath(fid):
429
print fip
430
431
432
class cmd_revision_history(Command):
433
"""Display list of revision ids on this branch."""
434
def run(self):
435
for patchid in Branch('.').revision_history():
436
print patchid
437
438
439
class cmd_directories(Command):
440
"""Display list of versioned directories in this branch."""
441
def run(self):
442
for name, ie in Branch('.').read_working_inventory().directories():
443
if name == '':
444
print '.'
445
else:
446
print name
447
448
449
class cmd_init(Command):
450
"""Make a directory into a versioned branch.
451
452
Use this to create an empty branch, or before importing an
453
existing project.
454
455
Recipe for importing a tree of files:
456
cd ~/project
457
bzr init
458
bzr add -v .
459
bzr status
460
bzr commit -m 'imported project'
461
"""
462
def run(self):
463
Branch('.', init=True)
464
465
466
class cmd_diff(Command):
467
"""Show differences in working tree.
468
469
If files are listed, only the changes in those files are listed.
470
Otherwise, all changes for the tree are listed.
471
472
TODO: Given two revision arguments, show the difference between them.
473
474
TODO: Allow diff across branches.
475
476
TODO: Option to use external diff command; could be GNU diff, wdiff,
477
or a graphical diff.
478
479
TODO: Python difflib is not exactly the same as unidiff; should
480
either fix it up or prefer to use an external diff.
481
482
TODO: If a directory is given, diff everything under that.
483
484
TODO: Selected-file diff is inefficient and doesn't show you
485
deleted files.
486
487
TODO: This probably handles non-Unix newlines poorly.
488
"""
489
490
takes_args = ['file*']
491
takes_options = ['revision']
492
aliases = ['di']
493
494
def run(self, revision=None, file_list=None):
495
from bzrlib.diff import show_diff
496
497
show_diff(Branch('.'), revision, specific_files=file_list)
498
499
500
501
502
503
class cmd_deleted(Command):
504
"""List files deleted in the working tree.
505
506
TODO: Show files deleted since a previous revision, or between two revisions.
507
"""
508
def run(self, show_ids=False):
509
b = Branch('.')
510
old = b.basis_tree()
511
new = b.working_tree()
512
513
## TODO: Much more efficient way to do this: read in new
514
## directories with readdir, rather than stating each one. Same
515
## level of effort but possibly much less IO. (Or possibly not,
516
## if the directories are very large...)
517
518
for path, ie in old.inventory.iter_entries():
519
if not new.has_id(ie.file_id):
520
if show_ids:
521
print '%-50s %s' % (path, ie.file_id)
522
else:
523
print path
524
525
526
class cmd_modified(Command):
527
"""List files modified in working tree."""
528
hidden = True
529
def run(self):
530
import statcache
531
b = Branch('.')
189
532
inv = b.read_working_inventory()
190
else:
191
inv = b.get_revision_inventory(b.lookup_revision(revision))
192
193
for path, entry in inv.iter_entries():
194
print '%-50s %s' % (entry.file_id, path)
195
196
197
198
def cmd_info():
199
import info
200
info.show_info(Branch('.'))
201
202
203
204
def cmd_remove(file_list, verbose=False):
205
b = Branch(file_list[0])
206
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
207
208
209
210
def cmd_file_id(filename):
211
b = Branch(filename)
212
i = b.inventory.path2id(b.relpath(filename))
213
if i is None:
214
bailout("%s is not a versioned file" % filename)
215
else:
216
print i
217
218
219
def cmd_find_filename(fileid):
220
n = find_filename(fileid)
221
if n is None:
222
bailout("%s is not a live file id" % fileid)
223
else:
224
print n
225
226
227
def cmd_revision_history():
228
for patchid in Branch('.').revision_history():
229
print patchid
230
231
232
233
def cmd_init():
234
# TODO: Check we're not already in a working directory? At the
235
# moment you'll get an ugly error.
236
237
# TODO: What if we're in a subdirectory of a branch? Would like
238
# to allow that, but then the parent may need to understand that
239
# the children have disappeared, or should they be versioned in
240
# both?
241
242
# TODO: Take an argument/option for branch name.
243
Branch('.', init=True)
244
245
246
def cmd_diff(revision=None):
247
"""Show diff from basis to working copy.
248
249
:todo: Take one or two revision arguments, look up those trees,
250
and diff them.
251
252
:todo: Allow diff across branches.
253
254
:todo: Mangle filenames in diff to be more relevant.
255
256
:todo: Shouldn't be in the cmd function.
257
258
TODO: Option to use external diff command; could be GNU diff,
259
wdiff, or a graphical diff.
260
"""
261
262
b = Branch('.')
263
264
if revision == None:
265
old_tree = b.basis_tree()
266
else:
267
old_tree = b.revision_tree(b.lookup_revision(revision))
268
269
new_tree = b.working_tree()
270
old_inv = old_tree.inventory
271
new_inv = new_tree.inventory
272
273
# TODO: Options to control putting on a prefix or suffix, perhaps as a format string
274
old_label = ''
275
new_label = ''
276
277
DEVNULL = '/dev/null'
278
# Windows users, don't panic about this filename -- it is a
279
# special signal to GNU patch that the file should be created or
280
# deleted respectively.
281
282
# TODO: Generation of pseudo-diffs for added/deleted files could
283
# be usefully made into a much faster special case.
284
285
# TODO: Better to return them in sorted order I think.
286
287
for file_state, fid, old_name, new_name, kind in bzrlib.diff_trees(old_tree, new_tree):
288
d = None
289
290
# Don't show this by default; maybe do it if an option is passed
291
# idlabel = ' {%s}' % fid
292
idlabel = ''
293
294
# FIXME: Something about the diff format makes patch unhappy
295
# with newly-added files.
296
297
def diffit(*a, **kw):
298
sys.stdout.writelines(difflib.unified_diff(*a, **kw))
299
print
300
301
if file_state in ['.', '?', 'I']:
302
continue
303
elif file_state == 'A':
304
print '*** added %s %r' % (kind, new_name)
305
if kind == 'file':
306
diffit([],
307
new_tree.get_file(fid).readlines(),
308
fromfile=DEVNULL,
309
tofile=new_label + new_name + idlabel)
310
elif file_state == 'D':
311
assert isinstance(old_name, types.StringTypes)
312
print '*** deleted %s %r' % (kind, old_name)
313
if kind == 'file':
314
diffit(old_tree.get_file(fid).readlines(), [],
315
fromfile=old_label + old_name + idlabel,
316
tofile=DEVNULL)
317
elif file_state in ['M', 'R']:
318
if file_state == 'M':
319
assert kind == 'file'
320
assert old_name == new_name
321
print '*** modified %s %r' % (kind, new_name)
322
elif file_state == 'R':
323
print '*** renamed %s %r => %r' % (kind, old_name, new_name)
324
325
if kind == 'file':
326
diffit(old_tree.get_file(fid).readlines(),
327
new_tree.get_file(fid).readlines(),
328
fromfile=old_label + old_name + idlabel,
329
tofile=new_label + new_name)
330
else:
331
bailout("can't represent state %s {%s}" % (file_state, fid))
332
333
334
335
def cmd_root(filename=None):
336
"""Print the branch root."""
337
print bzrlib.branch.find_branch_root(filename)
338
339
340
def cmd_log(timezone='original'):
533
sc = statcache.update_cache(b, inv)
534
basis = b.basis_tree()
535
basis_inv = basis.inventory
536
537
# We used to do this through iter_entries(), but that's slow
538
# when most of the files are unmodified, as is usually the
539
# case. So instead we iterate by inventory entry, and only
540
# calculate paths as necessary.
541
542
for file_id in basis_inv:
543
cacheentry = sc.get(file_id)
544
if not cacheentry: # deleted
545
continue
546
ie = basis_inv[file_id]
547
if cacheentry[statcache.SC_SHA1] != ie.text_sha1:
548
path = inv.id2path(file_id)
549
print path
550
551
552
553
class cmd_added(Command):
554
"""List files added in working tree."""
555
hidden = True
556
def run(self):
557
b = Branch('.')
558
wt = b.working_tree()
559
basis_inv = b.basis_tree().inventory
560
inv = wt.inventory
561
for file_id in inv:
562
if file_id in basis_inv:
563
continue
564
path = inv.id2path(file_id)
565
if not os.access(b.abspath(path), os.F_OK):
566
continue
567
print path
568
569
570
571
class cmd_root(Command):
572
"""Show the tree root directory.
573
574
The root is the nearest enclosing directory with a .bzr control
575
directory."""
576
takes_args = ['filename?']
577
def run(self, filename=None):
578
"""Print the branch root."""
579
from branch import find_branch
580
b = find_branch(filename)
581
print getattr(b, 'base', None) or getattr(b, 'baseurl')
582
583
584
class cmd_log(Command):
341
585
"""Show log of this branch.
342
586
343
:todo: Options for utc; to show ids; to limit range; etc.
587
TODO: Option to limit range.
344
588
"""
345
Branch('.').write_log(show_timezone=timezone)
346
347
348
def cmd_ls(revision=None, verbose=False):
589
590
takes_args = ['filename?']
591
takes_options = ['forward', 'timezone', 'verbose', 'show-ids']
592
593
def run(self, filename=None, timezone='original',
594
verbose=False,
595
show_ids=False,
596
forward=False):
597
from bzrlib import show_log, find_branch
598
599
direction = (forward and 'forward') or 'reverse'
600
601
if filename:
602
b = find_branch(filename, lock_mode='r')
603
fp = b.relpath(filename)
604
if fp:
605
file_id = b.read_working_inventory().path2id(fp)
606
else:
607
file_id = None # points to branch root
608
else:
609
b = find_branch('.', lock_mode='r')
610
file_id = None
611
612
show_log(b, file_id,
613
show_timezone=timezone,
614
verbose=verbose,
615
show_ids=show_ids,
616
to_file=sys.stdout,
617
direction=direction)
618
619
620
621
class cmd_touching_revisions(Command):
622
"""Return revision-ids which affected a particular file.
623
624
A more user-friendly interface is "bzr log FILE"."""
625
hidden = True
626
takes_args = ["filename"]
627
def run(self, filename):
628
b = Branch(filename, lock_mode='r')
629
inv = b.read_working_inventory()
630
file_id = inv.path2id(b.relpath(filename))
631
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
632
print "%6d %s" % (revno, what)
633
634
635
class cmd_ls(Command):
349
636
"""List files in a tree.
350
637
351
:todo: Take a revision or remote path and list that tree instead.
638
TODO: Take a revision or remote path and list that tree instead.
352
639
"""
353
b = Branch('.')
354
if revision == None:
355
tree = b.working_tree()
356
else:
357
tree = b.revision_tree(b.lookup_revision(revision))
358
359
for fp, fc, kind, fid in tree.list_files():
360
if verbose:
361
if kind == 'directory':
362
kindch = '/'
363
elif kind == 'file':
364
kindch = ''
640
hidden = True
641
def run(self, revision=None, verbose=False):
642
b = Branch('.')
643
if revision == None:
644
tree = b.working_tree()
645
else:
646
tree = b.revision_tree(b.lookup_revision(revision))
647
648
for fp, fc, kind, fid in tree.list_files():
649
if verbose:
650
if kind == 'directory':
651
kindch = '/'
652
elif kind == 'file':
653
kindch = ''
654
else:
655
kindch = '???'
656
657
print '%-8s %s%s' % (fc, fp, kindch)
365
658
else:
366
kindch = '???'
367
368
print '%-8s %s%s' % (fc, fp, kindch)
369
else:
370
print fp
371
372
373
374
def cmd_unknowns():
659
print fp
660
661
662
663
class cmd_unknowns(Command):
375
664
"""List unknown files"""
376
for f in Branch('.').unknowns():
377
print quotefn(f)
378
379
380
def cmd_lookup_revision(revno):
381
try:
382
revno = int(revno)
383
except ValueError:
384
bailout("usage: lookup-revision REVNO",
385
["REVNO is a non-negative revision number for this branch"])
386
387
print Branch('.').lookup_revision(revno) or NONE_STRING
388
389
390
391
def cmd_export(revno, dest):
392
"""Export past revision to destination directory."""
393
b = Branch('.')
394
rh = b.lookup_revision(int(revno))
395
t = b.revision_tree(rh)
396
t.export(dest)
397
398
399
400
######################################################################
401
# internal/test commands
402
403
404
def cmd_uuid():
405
"""Print a newly-generated UUID."""
406
print bzrlib.osutils.uuid()
407
408
409
410
def cmd_local_time_offset():
411
print bzrlib.osutils.local_time_offset()
412
413
414
415
def cmd_commit(message=None, verbose=False):
416
"""Commit changes to a new revision.
417
418
--message MESSAGE
419
Description of changes in this revision; free form text.
420
It is recommended that the first line be a single-sentence
421
summary.
422
--verbose
423
Show status of changed files,
424
425
TODO: Commit only selected files.
426
427
TODO: Run hooks on tree to-be-committed, and after commit.
428
429
TODO: Strict commit that fails if there are unknown or deleted files.
430
"""
431
432
if not message:
433
bailout("please specify a commit message")
434
Branch('.').commit(message, verbose=verbose)
435
436
437
def cmd_check():
438
"""Check consistency of the branch."""
439
check()
440
441
442
def cmd_is(pred, *rest):
443
"""Test whether PREDICATE is true."""
444
try:
445
cmd_handler = globals()['assert_' + pred.replace('-', '_')]
446
except KeyError:
447
bailout("unknown predicate: %s" % quotefn(pred))
665
def run(self):
666
for f in Branch('.').unknowns():
667
print quotefn(f)
668
669
670
671
class cmd_ignore(Command):
672
"""Ignore a command or pattern
673
674
To remove patterns from the ignore list, edit the .bzrignore file.
675
676
If the pattern contains a slash, it is compared to the whole path
677
from the branch root. Otherwise, it is comapred to only the last
678
component of the path.
679
680
Ignore patterns are case-insensitive on case-insensitive systems.
681
682
Note: wildcards must be quoted from the shell on Unix.
683
684
examples:
685
bzr ignore ./Makefile
686
bzr ignore '*.class'
687
"""
688
takes_args = ['name_pattern']
689
690
def run(self, name_pattern):
691
from bzrlib.atomicfile import AtomicFile
692
import codecs
693
694
b = Branch('.')
695
ifn = b.abspath('.bzrignore')
696
697
if os.path.exists(ifn):
698
f = open(ifn, 'rt')
699
try:
700
igns = f.read().decode('utf-8')
701
finally:
702
f.close()
703
else:
704
igns = ''
705
706
if igns and igns[-1] != '\n':
707
igns += '\n'
708
igns += name_pattern + '\n'
709
710
try:
711
f = AtomicFile(ifn, 'wt')
712
f.write(igns.encode('utf-8'))
713
f.commit()
714
finally:
715
f.close()
716
717
inv = b.working_tree().inventory
718
if inv.path2id('.bzrignore'):
719
mutter('.bzrignore is already versioned')
720
else:
721
mutter('need to make new .bzrignore file versioned')
722
b.add(['.bzrignore'])
723
724
725
726
class cmd_ignored(Command):
727
"""List ignored files and the patterns that matched them.
728
729
See also: bzr ignore"""
730
def run(self):
731
tree = Branch('.').working_tree()
732
for path, file_class, kind, file_id in tree.list_files():
733
if file_class != 'I':
734
continue
735
## XXX: Slightly inefficient since this was already calculated
736
pat = tree.is_ignored(path)
737
print '%-50s %s' % (path, pat)
738
739
740
class cmd_lookup_revision(Command):
741
"""Lookup the revision-id from a revision-number
742
743
example:
744
bzr lookup-revision 33
745
"""
746
hidden = True
747
takes_args = ['revno']
748
749
def run(self, revno):
750
try:
751
revno = int(revno)
752
except ValueError:
753
raise BzrCommandError("not a valid revision-number: %r" % revno)
754
755
print Branch('.').lookup_revision(revno)
756
757
758
class cmd_export(Command):
759
"""Export past revision to destination directory.
760
761
If no revision is specified this exports the last committed revision."""
762
takes_args = ['dest']
763
takes_options = ['revision']
764
def run(self, dest, revision=None):
765
b = Branch('.')
766
if revision == None:
767
rh = b.revision_history()[-1]
768
else:
769
rh = b.lookup_revision(int(revision))
770
t = b.revision_tree(rh)
771
t.export(dest)
772
773
774
class cmd_cat(Command):
775
"""Write a file's text from a previous revision."""
776
777
takes_options = ['revision']
778
takes_args = ['filename']
779
780
def run(self, filename, revision=None):
781
if revision == None:
782
raise BzrCommandError("bzr cat requires a revision number")
783
b = Branch('.')
784
b.print_file(b.relpath(filename), int(revision))
785
786
787
class cmd_local_time_offset(Command):
788
"""Show the offset in seconds from GMT to local time."""
789
hidden = True
790
def run(self):
791
print bzrlib.osutils.local_time_offset()
792
793
794
795
class cmd_commit(Command):
796
"""Commit changes into a new revision.
797
798
If selected files are specified, only changes to those files are
799
committed. If a directory is specified then its contents are also
800
committed.
801
802
A selected-file commit may fail in some cases where the committed
803
tree would be invalid, such as trying to commit a file in a
804
newly-added directory that is not itself committed.
805
806
TODO: Run hooks on tree to-be-committed, and after commit.
807
808
TODO: Strict commit that fails if there are unknown or deleted files.
809
"""
810
takes_args = ['selected*']
811
takes_options = ['message', 'file', 'verbose']
812
aliases = ['ci', 'checkin']
813
814
def run(self, message=None, file=None, verbose=True, selected_list=None):
815
from bzrlib.commit import commit
816
817
## Warning: shadows builtin file()
818
if not message and not file:
819
raise BzrCommandError("please specify a commit message",
820
["use either --message or --file"])
821
elif message and file:
822
raise BzrCommandError("please specify either --message or --file")
448
823
449
try:
450
cmd_handler(*rest)
451
except BzrCheckError:
452
# by default we don't print the message so that this can
453
# be used from shell scripts without producing noise
454
sys.exit(1)
455
456
457
def cmd_username():
458
print bzrlib.osutils.username()
459
460
461
def cmd_user_email():
462
print bzrlib.osutils.user_email()
463
464
465
def cmd_gen_revision_id():
466
import time
467
print bzrlib.branch._gen_revision_id(time.time())
468
469
470
def cmd_selftest(verbose=False):
824
if file:
825
import codecs
826
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
827
828
b = Branch('.')
829
commit(b, message, verbose=verbose, specific_files=selected_list)
830
831
832
class cmd_check(Command):
833
"""Validate consistency of branch history.
834
835
This command checks various invariants about the branch storage to
836
detect data corruption or bzr bugs.
837
"""
838
takes_args = ['dir?']
839
def run(self, dir='.'):
840
import bzrlib.check
841
bzrlib.check.check(Branch(dir))
842
843
844
845
class cmd_whoami(Command):
846
"""Show bzr user id."""
847
takes_options = ['email']
848
849
def run(self, email=False):
850
if email:
851
print bzrlib.osutils.user_email()
852
else:
853
print bzrlib.osutils.username()
854
855
856
class cmd_selftest(Command):
471
857
"""Run internal test suite"""
472
## -v, if present, is seen by doctest; the argument is just here
473
## so our parser doesn't complain
474
475
## TODO: --verbose option
476
477
failures, tests = 0, 0
478
479
import doctest, bzrlib.store, bzrlib.tests
480
bzrlib.trace.verbose = False
481
482
for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \
483
bzrlib.tree, bzrlib.tests, bzrlib.commands, bzrlib.add:
484
mf, mt = doctest.testmod(m)
485
failures += mf
486
tests += mt
487
print '%-40s %3d tests' % (m.__name__, mt),
488
if mf:
489
print '%3d FAILED!' % mf
858
hidden = True
859
def run(self):
860
failures, tests = 0, 0
861
862
import doctest, bzrlib.store
863
bzrlib.trace.verbose = False
864
865
for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \
866
bzrlib.tree, bzrlib.commands, bzrlib.add:
867
mf, mt = doctest.testmod(m)
868
failures += mf
869
tests += mt
870
print '%-40s %3d tests' % (m.__name__, mt),
871
if mf:
872
print '%3d FAILED!' % mf
873
else:
874
print
875
876
print '%-40s %3d tests' % ('total', tests),
877
if failures:
878
print '%3d FAILED!' % failures
879
return 1
490
880
else:
491
881
print
492
493
print '%-40s %3d tests' % ('total', tests),
494
if failures:
495
print '%3d FAILED!' % failures
496
else:
497
print
498
499
500
501
# deprecated
502
cmd_doctest = cmd_selftest
503
504
505
######################################################################
506
# help
507
508
509
def cmd_help(topic=None):
510
if topic == None:
511
print __doc__
512
return
513
514
# otherwise, maybe the name of a command?
515
try:
516
cmdfn = globals()['cmd_' + topic.replace('-', '_')]
517
except KeyError:
518
bailout("no help for %r" % topic)
519
520
doc = cmdfn.__doc__
521
if doc == None:
522
bailout("sorry, no detailed help yet for %r" % topic)
523
524
print doc
525
526
527
528
529
def cmd_version():
882
return 0
883
884
885
886
class cmd_version(Command):
887
"""Show version of bzr"""
888
def run(self):
889
show_version()
890
891
def show_version():
530
892
print "bzr (bazaar-ng) %s" % bzrlib.__version__
531
893
print bzrlib.__copyright__
532
894
print "http://bazaar-ng.org/"
533
895
print
534
print \
535
"""bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and
536
you may use, modify and redistribute it under the terms of the GNU
537
General Public License version 2 or later."""
538
539
540
def cmd_rocks():
896
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
897
print "you may use, modify and redistribute it under the terms of the GNU"
898
print "General Public License version 2 or later."
899
900
901
class cmd_rocks(Command):
541
902
"""Statement of optimism."""
542
print "it sure does!"
543
903
hidden = True
904
def run(self):
905
print "it sure does!"
906
907
def parse_spec(spec):
908
if '/@' in spec:
909
parsed = spec.split('/@')
910
assert len(parsed) == 2
911
if parsed[1] == "":
912
parsed[1] = -1
913
else:
914
parsed[1] = int(parsed[1])
915
assert parsed[1] >=0
916
else:
917
parsed = [spec, None]
918
return parsed
919
920
class cmd_merge(Command):
921
"""Perform a three-way merge of trees."""
922
takes_args = ['other_spec', 'base_spec']
923
924
def run(self, other_spec, base_spec):
925
merge.merge(parse_spec(other_spec), parse_spec(base_spec))
926
927
class cmd_assert_fail(Command):
928
"""Test reporting of assertion failures"""
929
hidden = True
930
def run(self):
931
assert False, "always fails"
932
933
934
class cmd_help(Command):
935
"""Show help on a command or other topic.
936
937
For a list of all available commands, say 'bzr help commands'."""
938
takes_args = ['topic?']
939
aliases = ['?']
940
941
def run(self, topic=None):
942
import help
943
help.help(topic)
944
945
946
class cmd_update_stat_cache(Command):
947
"""Update stat-cache mapping inodes to SHA-1 hashes.
948
949
For testing only."""
950
hidden = True
951
def run(self):
952
import statcache
953
b = Branch('.')
954
statcache.update_cache(b.base, b.read_working_inventory())
544
955
545
956
546
957
######################################################################
553
964
OPTIONS = {
554
965
'all': None,
555
966
'help': None,
967
'file': unicode,
968
'forward': None,
556
969
'message': unicode,
970
'profile': None,
557
971
'revision': int,
558
972
'show-ids': None,
559
973
'timezone': str,
560
974
'verbose': None,
561
975
'version': None,
976
'email': None,
562
977
}
563
978
564
979
SHORT_OPTIONS = {
565
980
'm': 'message',
981
'F': 'file',
566
982
'r': 'revision',
567
983
'v': 'verbose',
568
984
}
569
985
570
# List of options that apply to particular commands; commands not
571
# listed take none.
572
cmd_options = {
573
'add': ['verbose'],
574
'commit': ['message', 'verbose'],
575
'diff': ['revision'],
576
'inventory': ['revision'],
577
'log': ['show-ids', 'timezone'],
578
'ls': ['revision', 'verbose'],
579
'remove': ['verbose'],
580
'status': ['all'],
581
}
582
583
584
cmd_args = {
585
'add': ['file+'],
586
'commit': [],
587
'diff': [],
588
'export': ['revno', 'dest'],
589
'file-id': ['filename'],
590
'get-file-text': ['text_id'],
591
'get-inventory': ['inventory_id'],
592
'get-revision': ['revision_id'],
593
'get-revision-inventory': ['revision_id'],
594
'help': ['topic?'],
595
'init': [],
596
'log': [],
597
'lookup-revision': ['revno'],
598
'relpath': ['filename'],
599
'remove': ['file+'],
600
'root': ['filename?'],
601
'status': [],
602
}
603
604
986
605
987
def parse_args(argv):
606
988
"""Parse command line.
627
1009
while argv:
628
1010
a = argv.pop(0)
629
1011
if a[0] == '-':
1012
# option names must not be unicode
1013
a = str(a)
630
1014
optarg = None
631
1015
if a[1] == '-':
632
1016
mutter(" got option %r" % a)
654
1038
else:
655
1039
optarg = argv.pop(0)
656
1040
opts[optname] = optargfn(optarg)
657
mutter(" option argument %r" % opts[optname])
658
1041
else:
659
1042
if optarg != None:
660
1043
bailout('option %r takes no argument' % optname)
666
1049
667
1050
668
1051
669
def _match_args(cmd, args):
670
"""Check non-option arguments match required pattern.
671
1052
672
>>> _match_args('status', ['asdasdsadasd'])
673
Traceback (most recent call last):
674
...
675
BzrError: ("extra arguments to command status: ['asdasdsadasd']", [])
676
>>> _match_args('add', ['asdasdsadasd'])
677
{'file_list': ['asdasdsadasd']}
678
>>> _match_args('add', 'abc def gj'.split())
679
{'file_list': ['abc', 'def', 'gj']}
680
"""
681
# match argument pattern
682
argform = cmd_args.get(cmd, [])
1053
def _match_argform(cmd, takes_args, args):
683
1054
argdict = {}
684
# TODO: Need a way to express 'cp SRC... DEST', where it matches
685
# all but one.
686
1055
687
# step through args and argform, allowing appropriate 0-many matches
688
for ap in argform:
1056
# step through args and takes_args, allowing appropriate 0-many matches
1057
for ap in takes_args:
689
1058
argname = ap[:-1]
690
1059
if ap[-1] == '?':
691
1060
if args:
692
1061
argdict[argname] = args.pop(0)
693
elif ap[-1] == '*':
694
assert 0
1062
elif ap[-1] == '*': # all remaining arguments
1063
if args:
1064
argdict[argname + '_list'] = args[:]
1065
args = []
1066
else:
1067
argdict[argname + '_list'] = None
695
1068
elif ap[-1] == '+':
696
1069
if not args:
697
bailout("command %r needs one or more %s"
1070
raise BzrCommandError("command %r needs one or more %s"
698
1071
% (cmd, argname.upper()))
699
1072
else:
700
1073
argdict[argname + '_list'] = args[:]
701
1074
args = []
1075
elif ap[-1] == '$': # all but one
1076
if len(args) < 2:
1077
raise BzrCommandError("command %r needs one or more %s"
1078
% (cmd, argname.upper()))
1079
argdict[argname + '_list'] = args[:-1]
1080
args[:-1] = []
702
1081
else:
703
1082
# just a plain arg
704
1083
argname = ap
705
1084
if not args:
706
bailout("command %r requires argument %s"
1085
raise BzrCommandError("command %r requires argument %s"
707
1086
% (cmd, argname.upper()))
708
1087
else:
709
1088
argdict[argname] = args.pop(0)
710
1089
711
1090
if args:
712
bailout("extra arguments to command %s: %r"
713
% (cmd, args))
1091
raise BzrCommandError("extra argument to command %s: %s"
1092
% (cmd, args[0]))
714
1093
715
1094
return argdict
716
1095
720
1099
"""Execute a command.
721
1100
722
1101
This is similar to main(), but without all the trappings for
723
logging and error handling.
1102
logging and error handling.
724
1103
"""
1104
argv = [a.decode(bzrlib.user_encoding) for a in argv]
1105
725
1106
try:
726
1107
args, opts = parse_args(argv[1:])
727
1108
if 'help' in opts:
728
# TODO: pass down other arguments in case they asked for
729
# help on a command name?
730
cmd_help()
1109
import help
1110
if args:
1111
help.help(args[0])
1112
else:
1113
help.help()
731
1114
return 0
732
1115
elif 'version' in opts:
733
cmd_version()
1116
show_version()
734
1117
return 0
735
cmd = args.pop(0)
1118
cmd = str(args.pop(0))
736
1119
except IndexError:
737
log_error('usage: bzr COMMAND\n')
738
log_error(' try "bzr help"\n')
1120
import help
1121
help.help()
739
1122
return 1
740
741
try:
742
cmd_handler = globals()['cmd_' + cmd.replace('-', '_')]
743
except KeyError:
744
bailout("unknown command " + `cmd`)
745
746
# TODO: special --profile option to turn on the Python profiler
1123
1124
1125
canonical_cmd, cmd_class = get_cmd_class(cmd)
1126
1127
# global option
1128
if 'profile' in opts:
1129
profile = True
1130
del opts['profile']
1131
else:
1132
profile = False
747
1133
748
1134
# check options are reasonable
749
allowed = cmd_options.get(cmd, [])
1135
allowed = cmd_class.takes_options
750
1136
for oname in opts:
751
1137
if oname not in allowed:
752
bailout("option %r is not allowed for command %r"
753
% (oname, cmd))
754
755
cmdargs = _match_args(cmd, args)
756
cmdargs.update(opts)
757
758
ret = cmd_handler(**cmdargs) or 0
1138
raise BzrCommandError("option '--%s' is not allowed for command %r"
1139
% (oname, cmd))
1140
1141
# mix arguments and options into one dictionary
1142
cmdargs = _match_argform(cmd, cmd_class.takes_args, args)
1143
cmdopts = {}
1144
for k, v in opts.items():
1145
cmdopts[k.replace('-', '_')] = v
1146
1147
if profile:
1148
import hotshot, tempfile
1149
pffileno, pfname = tempfile.mkstemp()
1150
try:
1151
prof = hotshot.Profile(pfname)
1152
ret = prof.runcall(cmd_class, cmdopts, cmdargs) or 0
1153
prof.close()
1154
1155
import hotshot.stats
1156
stats = hotshot.stats.load(pfname)
1157
#stats.strip_dirs()
1158
stats.sort_stats('time')
1159
## XXX: Might like to write to stderr or the trace file instead but
1160
## print_stats seems hardcoded to stdout
1161
stats.print_stats(20)
1162
1163
return ret.status
1164
1165
finally:
1166
os.close(pffileno)
1167
os.remove(pfname)
1168
else:
1169
return cmd_class(cmdopts, cmdargs).status
1170
1171
1172
def _report_exception(summary, quiet=False):
1173
import traceback
1174
log_error('bzr: ' + summary)
1175
bzrlib.trace.log_exception()
1176
1177
if not quiet:
1178
tb = sys.exc_info()[2]
1179
exinfo = traceback.extract_tb(tb)
1180
if exinfo:
1181
sys.stderr.write(' at %s:%d in %s()\n' % exinfo[-1][:3])
1182
sys.stderr.write(' see ~/.bzr.log for debug information\n')
759
1183
760
1184
761
1185
762
1186
def main(argv):
763
## TODO: Handle command-line options; probably know what options are valid for
764
## each command
765
766
## TODO: If the arguments are wrong, give a usage message rather
767
## than just a backtrace.
768
769
bzrlib.trace.create_tracefile(argv)
1187
import errno
770
1188
1189
bzrlib.open_tracefile(argv)
1190
771
1191
try:
772
ret = run_bzr(argv)
773
return ret
774
except BzrError, e:
775
log_error('bzr: error: ' + e.args[0] + '\n')
776
if len(e.args) > 1:
777
for h in e.args[1]:
778
log_error(' ' + h + '\n')
779
return 1
780
except Exception, e:
781
log_error('bzr: exception: %s\n' % e)
782
log_error(' see .bzr.log for details\n')
783
traceback.print_exc(None, bzrlib.trace._tracefile)
784
traceback.print_exc(None, sys.stderr)
785
return 1
786
787
# TODO: Maybe nicer handling of IOError?
788
1192
try:
1193
try:
1194
return run_bzr(argv)
1195
finally:
1196
# do this here inside the exception wrappers to catch EPIPE
1197
sys.stdout.flush()
1198
except BzrError, e:
1199
quiet = isinstance(e, (BzrCommandError))
1200
_report_exception('error: ' + e.args[0], quiet=quiet)
1201
if len(e.args) > 1:
1202
for h in e.args[1]:
1203
# some explanation or hints
1204
log_error(' ' + h)
1205
return 1
1206
except AssertionError, e:
1207
msg = 'assertion failed'
1208
if str(e):
1209
msg += ': ' + str(e)
1210
_report_exception(msg)
1211
return 2
1212
except KeyboardInterrupt, e:
1213
_report_exception('interrupted', quiet=True)
1214
return 2
1215
except Exception, e:
1216
quiet = False
1217
if (isinstance(e, IOError)
1218
and hasattr(e, 'errno')
1219
and e.errno == errno.EPIPE):
1220
quiet = True
1221
msg = 'broken pipe'
1222
else:
1223
msg = str(e).rstrip('\n')
1224
_report_exception(msg, quiet)
1225
return 2
1226
finally:
1227
bzrlib.trace.close_trace()
789
1228
790
1229
791
1230
if __name__ == '__main__':
792
1231
sys.exit(main(sys.argv))
793
##import profile
794
##profile.run('main(sys.argv)')
795
Loggerhead is a web-based interface for Breezy
Version: 2.0.1