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