~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Robert Collins
  • Date: 2006-05-24 08:14:45 UTC
  • mfrom: (1725.1.1 benchmark)
  • mto: (1725.2.6 commit)
  • mto: This revision was merged to the branch mainline in revision 1729.
  • Revision ID: robertc@robertcollins.net-20060524081445-c046b4406ffc8dfa
(rbc)Merge in benchmark --lsprof-timed lsprofiling feature. (Robert Collins, Martin Pool).

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
#! /usr/bin/python
2
 
 
3
 
 
4
 
# Copyright (C) 2004, 2005 by Martin Pool
5
 
# Copyright (C) 2005 by Canonical Ltd
6
 
 
7
 
 
 
1
# Copyright (C) 2006 by Canonical Ltd
 
2
#
8
3
# This program is free software; you can redistribute it and/or modify
9
4
# it under the terms of the GNU General Public License as published by
10
5
# the Free Software Foundation; either version 2 of the License, or
11
6
# (at your option) any later version.
12
 
 
 
7
#
13
8
# This program is distributed in the hope that it will be useful,
14
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
15
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
11
# GNU General Public License for more details.
17
 
 
 
12
#
18
13
# You should have received a copy of the GNU General Public License
19
14
# along with this program; if not, write to the Free Software
20
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21
16
 
22
 
"""Bazaar-NG -- a free distributed version-control tool
23
 
 
24
 
**WARNING: THIS IS AN UNSTABLE DEVELOPMENT VERSION**
25
 
 
26
 
Current limitation include:
27
 
 
28
 
* Metadata format is not stable yet -- you may need to
29
 
  discard history in the future.
30
 
 
31
 
* No handling of subdirectories, symlinks or any non-text files.
32
 
 
33
 
* Insufficient error handling.
34
 
 
35
 
* Many commands unimplemented or partially implemented.
36
 
 
37
 
* Space-inefficient storage.
38
 
 
39
 
* No merge operators yet.
40
 
 
41
 
Interesting commands::
42
 
 
43
 
  bzr help
44
 
       Show summary help screen
45
 
  bzr version
46
 
       Show software version/licence/non-warranty.
47
 
  bzr init
48
 
       Start versioning the current directory
49
 
  bzr add FILE...
50
 
       Make files versioned.
51
 
  bzr log
52
 
       Show revision history.
53
 
  bzr diff
54
 
       Show changes from last revision to working copy.
55
 
  bzr commit -m 'MESSAGE'
56
 
       Store current state as new revision.
57
 
  bzr export REVNO DESTINATION
58
 
       Export the branch state at a previous version.
59
 
  bzr status
60
 
       Show summary of pending changes.
61
 
  bzr remove FILE...
62
 
       Make a file not versioned.
63
 
"""
64
 
 
65
 
# not currently working:
66
 
#  bzr info
67
 
#       Show some information about this branch.
68
 
 
69
 
 
70
 
 
71
 
__copyright__ = "Copyright 2005 Canonical Development Ltd."
72
 
__author__ = "Martin Pool <mbp@canonical.com>"
73
 
__docformat__ = "restructuredtext en"
74
 
__version__ = '0.0.0'
75
 
 
76
 
 
77
 
import sys, os, random, time, sha, sets, types, re, shutil, tempfile
78
 
import traceback, socket, fnmatch, difflib
79
 
from os import path
80
 
from sets import Set
81
 
from pprint import pprint
82
 
from stat import *
83
 
from glob import glob
 
17
 
 
18
# TODO: probably should say which arguments are candidates for glob
 
19
# expansion on windows and do that at the command level.
 
20
 
 
21
# TODO: Define arguments by objects, rather than just using names.
 
22
# Those objects can specify the expected type of the argument, which
 
23
# would help with validation and shell completion.  They could also provide
 
24
# help/explanation for that argument in a structured way.
 
25
 
 
26
# TODO: Specific "examples" property on commands for consistent formatting.
 
27
 
 
28
# TODO: "--profile=cum", to change sort order.  Is there any value in leaving
 
29
# the profile output behind so it can be interactively examined?
 
30
 
 
31
import sys
 
32
import os
 
33
from warnings import warn
 
34
import errno
84
35
 
85
36
import bzrlib
86
 
from bzrlib.store import ImmutableStore
87
 
from bzrlib.trace import mutter, note, log_error
88
 
from bzrlib.errors import bailout, BzrError
89
 
from bzrlib.osutils import quotefn, pumpfile, isdir, isfile
90
 
from bzrlib.tree import RevisionTree, EmptyTree, WorkingTree, Tree
91
 
from bzrlib.revision import Revision
92
 
from bzrlib import Branch, Inventory, InventoryEntry, ScratchBranch, BZRDIR, \
93
 
     format_date
94
 
 
95
 
BZR_DIFF_FORMAT = "## Bazaar-NG diff, format 0 ##\n"
96
 
BZR_PATCHNAME_FORMAT = 'cset:sha1:%s'
97
 
 
98
 
## standard representation
99
 
NONE_STRING = '(none)'
100
 
EMPTY = 'empty'
101
 
 
102
 
 
103
 
## TODO: Perhaps a different version of inventory commands that
104
 
## returns iterators...
105
 
 
106
 
## TODO: Perhaps an AtomicFile class that writes to a temporary file and then renames.
107
 
 
108
 
## TODO: Some kind of locking on branches.  Perhaps there should be a
109
 
## parameter to the branch object saying whether we want a read or
110
 
## write lock; release it from destructor.  Perhaps don't even need a
111
 
## read lock to look at immutable objects?
112
 
 
113
 
## TODO: Perhaps make UUIDs predictable in test mode to make it easier
114
 
## to compare output?
115
 
 
116
 
## TODO: Some kind of global code to generate the right Branch object
117
 
## to work on.  Almost, but not quite all, commands need one, and it
118
 
## can be taken either from their parameters or their working
119
 
## directory.
120
 
 
121
 
## TODO: rename command, needed soon: check destination doesn't exist
122
 
## either in working copy or tree; move working copy; update
123
 
## inventory; write out
124
 
 
125
 
## TODO: move command; check destination is a directory and will not
126
 
## clash; move it.
127
 
 
128
 
## TODO: command to show renames, one per line, as to->from
129
 
 
130
 
 
131
 
 
132
 
 
133
 
def cmd_status(all=False):
134
 
    """Display status summary.
135
 
 
136
 
    For each file there is a single line giving its file state and name.
137
 
    The name is that in the current revision unless it is deleted or
138
 
    missing, in which case the old name is shown.
139
 
 
140
 
    :todo: Don't show unchanged files unless ``--all`` is given?
141
 
    """
142
 
    Branch('.').show_status(show_all=all)
143
 
 
144
 
 
145
 
 
146
 
######################################################################
147
 
# examining history
148
 
def cmd_get_revision(revision_id):
149
 
    Branch('.').get_revision(revision_id).write_xml(sys.stdout)
150
 
 
151
 
 
152
 
def cmd_get_file_text(text_id):
153
 
    """Get contents of a file by hash."""
154
 
    sf = Branch('.').text_store[text_id]
155
 
    pumpfile(sf, sys.stdout)
156
 
 
157
 
 
158
 
 
159
 
######################################################################
160
 
# commands
161
 
    
162
 
 
163
 
def cmd_revno():
164
 
    """Show number of revisions on this branch"""
165
 
    print Branch('.').revno()
166
 
    
167
 
 
168
 
def cmd_add(file_list, verbose=False):
169
 
    """Add specified files.
170
 
    
171
 
    Fails if the files are already added.
172
 
    """
173
 
    Branch('.').add(file_list, verbose=verbose)
174
 
 
175
 
 
176
 
def cmd_inventory(revision=None):
177
 
    """Show inventory of the current working copy."""
178
 
    ## TODO: Also optionally show a previous inventory
179
 
    ## TODO: Format options
180
 
    b = Branch('.')
181
 
    if revision == None:
182
 
        inv = b.read_working_inventory()
183
 
    else:
184
 
        inv = b.get_revision_inventory(b.lookup_revision(revision))
185
 
        
186
 
    for path, entry in inv.iter_entries():
187
 
        print '%-50s %s' % (entry.file_id, path)
188
 
 
189
 
 
190
 
 
191
 
def cmd_info():
192
 
    b = Branch('.')
193
 
    print 'branch format:', b.controlfile('branch-format', 'r').readline().rstrip('\n')
194
 
 
195
 
    def plural(n, base='', pl=None):
196
 
        if n == 1:
197
 
            return base
198
 
        elif pl is not None:
199
 
            return pl
200
 
        else:
201
 
            return 's'
202
 
 
203
 
    count_version_dirs = 0
204
 
 
205
 
    count_status = {'A': 0, 'D': 0, 'M': 0, 'R': 0, '?': 0, 'I': 0, '.': 0}
206
 
    for st_tup in bzrlib.diff_trees(b.basis_tree(), b.working_tree()):
207
 
        fs = st_tup[0]
208
 
        count_status[fs] += 1
209
 
        if fs not in ['I', '?'] and st_tup[4] == 'directory':
210
 
            count_version_dirs += 1
211
 
 
212
 
    print
213
 
    print 'in the working tree:'
214
 
    for name, fs in (('unchanged', '.'),
215
 
                     ('modified', 'M'), ('added', 'A'), ('removed', 'D'),
216
 
                     ('renamed', 'R'), ('unknown', '?'), ('ignored', 'I'),
217
 
                     ):
218
 
        print '  %5d %s' % (count_status[fs], name)
219
 
    print '  %5d versioned subdirector%s' % (count_version_dirs,
220
 
                                             plural(count_version_dirs, 'y', 'ies'))
221
 
 
222
 
    print
223
 
    print 'branch history:'
224
 
    history = b.revision_history()
225
 
    revno = len(history)
226
 
    print '  %5d revision%s' % (revno, plural(revno))
227
 
    committers = Set()
228
 
    for rev in history:
229
 
        committers.add(b.get_revision(rev).committer)
230
 
    print '  %5d committer%s' % (len(committers), plural(len(committers)))
231
 
    if revno > 0:
232
 
        firstrev = b.get_revision(history[0])
233
 
        age = int((time.time() - firstrev.timestamp) / 3600 / 24)
234
 
        print '  %5d day%s old' % (age, plural(age))
235
 
        print '  first revision: %s' % format_date(firstrev.timestamp,
236
 
                                                 firstrev.timezone)
237
 
 
238
 
        lastrev = b.get_revision(history[-1])
239
 
        print '  latest revision: %s' % format_date(lastrev.timestamp,
240
 
                                                    lastrev.timezone)
241
 
        
242
 
    
243
 
 
244
 
 
245
 
def cmd_remove(file_list, verbose=False):
246
 
    Branch('.').remove(file_list, verbose=verbose)
247
 
 
248
 
 
249
 
 
250
 
def cmd_file_id(filename):
251
 
    i = Branch('.').read_working_inventory().path2id(filename)
252
 
    if i is None:
253
 
        bailout("%s is not a versioned file" % filename)
254
 
    else:
255
 
        print i
256
 
 
257
 
 
258
 
def cmd_find_filename(fileid):
259
 
    n = find_filename(fileid)
260
 
    if n is None:
261
 
        bailout("%s is not a live file id" % fileid)
262
 
    else:
263
 
        print n
264
 
 
265
 
 
266
 
def cmd_revision_history():
267
 
    for patchid in Branch('.').revision_history():
268
 
        print patchid
269
 
 
270
 
 
271
 
 
272
 
def cmd_init():
273
 
    # TODO: Check we're not already in a working directory?  At the
274
 
    # moment you'll get an ugly error.
275
 
    
276
 
    # TODO: What if we're in a subdirectory of a branch?  Would like
277
 
    # to allow that, but then the parent may need to understand that
278
 
    # the children have disappeared, or should they be versioned in
279
 
    # both?
280
 
 
281
 
    # TODO: Take an argument/option for branch name.
282
 
    Branch('.', init=True)
283
 
 
284
 
 
285
 
def cmd_diff(revision=None):
286
 
    """Show diff from basis to working copy.
287
 
 
288
 
    :todo: Take one or two revision arguments, look up those trees,
289
 
           and diff them.
290
 
 
291
 
    :todo: Allow diff across branches.
292
 
 
293
 
    :todo: Mangle filenames in diff to be more relevant.
294
 
 
295
 
    :todo: Shouldn't be in the cmd function.
296
 
    """
297
 
 
298
 
    b = Branch('.')
299
 
 
300
 
    if revision == None:
301
 
        old_tree = b.basis_tree()
302
 
    else:
303
 
        old_tree = b.revision_tree(b.lookup_revision(revision))
304
 
        
305
 
    new_tree = b.working_tree()
306
 
    old_inv = old_tree.inventory
307
 
    new_inv = new_tree.inventory
308
 
 
309
 
    # TODO: Options to control putting on a prefix or suffix, perhaps as a format string
310
 
    old_label = ''
311
 
    new_label = ''
312
 
 
313
 
    DEVNULL = '/dev/null'
314
 
    # Windows users, don't panic about this filename -- it is a
315
 
    # special signal to GNU patch that the file should be created or
316
 
    # deleted respectively.
317
 
 
318
 
    # TODO: Generation of pseudo-diffs for added/deleted files could
319
 
    # be usefully made into a much faster special case.
320
 
 
321
 
    # TODO: Better to return them in sorted order I think.
322
 
    
323
 
    for file_state, fid, old_name, new_name, kind in bzrlib.diff_trees(old_tree, new_tree):
324
 
        d = None
325
 
 
326
 
        # Don't show this by default; maybe do it if an option is passed
327
 
        # idlabel = '      {%s}' % fid
328
 
        idlabel = ''
329
 
 
330
 
        # FIXME: Something about the diff format makes patch unhappy
331
 
        # with newly-added files.
332
 
 
333
 
        def diffit(*a, **kw):
334
 
            sys.stdout.writelines(difflib.unified_diff(*a, **kw))
335
 
            print
336
 
        
337
 
        if file_state in ['.', '?', 'I']:
338
 
            continue
339
 
        elif file_state == 'A':
340
 
            print '*** added %s %r' % (kind, new_name)
341
 
            if kind == 'file':
342
 
                diffit([],
343
 
                       new_tree.get_file(fid).readlines(),
344
 
                       fromfile=DEVNULL,
345
 
                       tofile=new_label + new_name + idlabel)
346
 
        elif file_state == 'D':
347
 
            assert isinstance(old_name, types.StringTypes)
348
 
            print '*** deleted %s %r' % (kind, old_name)
349
 
            if kind == 'file':
350
 
                diffit(old_tree.get_file(fid).readlines(), [],
351
 
                       fromfile=old_label + old_name + idlabel,
352
 
                       tofile=DEVNULL)
353
 
        elif file_state in ['M', 'R']:
354
 
            if file_state == 'M':
355
 
                assert kind == 'file'
356
 
                assert old_name == new_name
357
 
                print '*** modified %s %r' % (kind, new_name)
358
 
            elif file_state == 'R':
359
 
                print '*** renamed %s %r => %r' % (kind, old_name, new_name)
360
 
 
361
 
            if kind == 'file':
362
 
                diffit(old_tree.get_file(fid).readlines(),
363
 
                       new_tree.get_file(fid).readlines(),
364
 
                       fromfile=old_label + old_name + idlabel,
365
 
                       tofile=new_label + new_name)
366
 
        else:
367
 
            bailout("can't represent state %s {%s}" % (file_state, fid))
368
 
 
369
 
 
370
 
 
371
 
def cmd_log(timezone='original'):
372
 
    """Show log of this branch.
373
 
 
374
 
    :todo: Options for utc; to show ids; to limit range; etc.
375
 
    """
376
 
    Branch('.').write_log(show_timezone=timezone)
377
 
 
378
 
 
379
 
def cmd_ls(revision=None, verbose=False):
380
 
    """List files in a tree.
381
 
 
382
 
    :todo: Take a revision or remote path and list that tree instead.
383
 
    """
384
 
    b = Branch('.')
385
 
    if revision == None:
386
 
        tree = b.working_tree()
387
 
    else:
388
 
        tree = b.revision_tree(b.lookup_revision(revision))
389
 
        
390
 
    for fp, fc, kind, fid in tree.list_files():
391
 
        if verbose:
392
 
            if kind == 'directory':
393
 
                kindch = '/'
394
 
            elif kind == 'file':
395
 
                kindch = ''
 
37
from bzrlib.errors import (BzrError,
 
38
                           BzrCheckError,
 
39
                           BzrCommandError,
 
40
                           BzrOptionError,
 
41
                           NotBranchError)
 
42
from bzrlib.option import Option
 
43
from bzrlib.revisionspec import RevisionSpec
 
44
from bzrlib.symbol_versioning import *
 
45
import bzrlib.trace
 
46
from bzrlib.trace import mutter, note, log_error, warning, be_quiet
 
47
 
 
48
plugin_cmds = {}
 
49
 
 
50
 
 
51
def register_command(cmd, decorate=False):
 
52
    """Utility function to help register a command
 
53
 
 
54
    :param cmd: Command subclass to register
 
55
    :param decorate: If true, allow overriding an existing command
 
56
        of the same name; the old command is returned by this function.
 
57
        Otherwise it is an error to try to override an existing command.
 
58
    """
 
59
    global plugin_cmds
 
60
    k = cmd.__name__
 
61
    if k.startswith("cmd_"):
 
62
        k_unsquished = _unsquish_command_name(k)
 
63
    else:
 
64
        k_unsquished = k
 
65
    if not plugin_cmds.has_key(k_unsquished):
 
66
        plugin_cmds[k_unsquished] = cmd
 
67
        mutter('registered plugin command %s', k_unsquished)
 
68
        if decorate and k_unsquished in builtin_command_names():
 
69
            return _builtin_commands()[k_unsquished]
 
70
    elif decorate:
 
71
        result = plugin_cmds[k_unsquished]
 
72
        plugin_cmds[k_unsquished] = cmd
 
73
        return result
 
74
    else:
 
75
        log_error('Two plugins defined the same command: %r' % k)
 
76
        log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
 
77
 
 
78
 
 
79
def _squish_command_name(cmd):
 
80
    return 'cmd_' + cmd.replace('-', '_')
 
81
 
 
82
 
 
83
def _unsquish_command_name(cmd):
 
84
    assert cmd.startswith("cmd_")
 
85
    return cmd[4:].replace('_','-')
 
86
 
 
87
 
 
88
def _builtin_commands():
 
89
    import bzrlib.builtins
 
90
    r = {}
 
91
    builtins = bzrlib.builtins.__dict__
 
92
    for name in builtins:
 
93
        if name.startswith("cmd_"):
 
94
            real_name = _unsquish_command_name(name)
 
95
            r[real_name] = builtins[name]
 
96
    return r
 
97
            
 
98
 
 
99
def builtin_command_names():
 
100
    """Return list of builtin command names."""
 
101
    return _builtin_commands().keys()
 
102
    
 
103
 
 
104
def plugin_command_names():
 
105
    return plugin_cmds.keys()
 
106
 
 
107
 
 
108
def _get_cmd_dict(plugins_override=True):
 
109
    """Return name->class mapping for all commands."""
 
110
    d = _builtin_commands()
 
111
    if plugins_override:
 
112
        d.update(plugin_cmds)
 
113
    return d
 
114
 
 
115
    
 
116
def get_all_cmds(plugins_override=True):
 
117
    """Return canonical name and class for all registered commands."""
 
118
    for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
 
119
        yield k,v
 
120
 
 
121
 
 
122
def get_cmd_object(cmd_name, plugins_override=True):
 
123
    """Return the canonical name and command class for a command.
 
124
 
 
125
    plugins_override
 
126
        If true, plugin commands can override builtins.
 
127
    """
 
128
    from bzrlib.externalcommand import ExternalCommand
 
129
 
 
130
    cmd_name = str(cmd_name)            # not unicode
 
131
 
 
132
    # first look up this command under the specified name
 
133
    cmds = _get_cmd_dict(plugins_override=plugins_override)
 
134
    try:
 
135
        return cmds[cmd_name]()
 
136
    except KeyError:
 
137
        pass
 
138
 
 
139
    # look for any command which claims this as an alias
 
140
    for real_cmd_name, cmd_class in cmds.iteritems():
 
141
        if cmd_name in cmd_class.aliases:
 
142
            return cmd_class()
 
143
 
 
144
    cmd_obj = ExternalCommand.find_command(cmd_name)
 
145
    if cmd_obj:
 
146
        return cmd_obj
 
147
 
 
148
    raise BzrCommandError("unknown command %r" % cmd_name)
 
149
 
 
150
 
 
151
class Command(object):
 
152
    """Base class for commands.
 
153
 
 
154
    Commands are the heart of the command-line bzr interface.
 
155
 
 
156
    The command object mostly handles the mapping of command-line
 
157
    parameters into one or more bzrlib operations, and of the results
 
158
    into textual output.
 
159
 
 
160
    Commands normally don't have any state.  All their arguments are
 
161
    passed in to the run method.  (Subclasses may take a different
 
162
    policy if the behaviour of the instance needs to depend on e.g. a
 
163
    shell plugin and not just its Python class.)
 
164
 
 
165
    The docstring for an actual command should give a single-line
 
166
    summary, then a complete description of the command.  A grammar
 
167
    description will be inserted.
 
168
 
 
169
    aliases
 
170
        Other accepted names for this command.
 
171
 
 
172
    takes_args
 
173
        List of argument forms, marked with whether they are optional,
 
174
        repeated, etc.
 
175
 
 
176
                Examples:
 
177
 
 
178
                ['to_location', 'from_branch?', 'file*']
 
179
 
 
180
                'to_location' is required
 
181
                'from_branch' is optional
 
182
                'file' can be specified 0 or more times
 
183
 
 
184
    takes_options
 
185
        List of options that may be given for this command.  These can
 
186
        be either strings, referring to globally-defined options,
 
187
        or option objects.  Retrieve through options().
 
188
 
 
189
    hidden
 
190
        If true, this command isn't advertised.  This is typically
 
191
        for commands intended for expert users.
 
192
    """
 
193
    aliases = []
 
194
    takes_args = []
 
195
    takes_options = []
 
196
 
 
197
    hidden = False
 
198
    
 
199
    def __init__(self):
 
200
        """Construct an instance of this command."""
 
201
        if self.__doc__ == Command.__doc__:
 
202
            warn("No help message set for %r" % self)
 
203
 
 
204
    def options(self):
 
205
        """Return dict of valid options for this command.
 
206
 
 
207
        Maps from long option name to option object."""
 
208
        r = dict()
 
209
        r['help'] = Option.OPTIONS['help']
 
210
        for o in self.takes_options:
 
211
            if not isinstance(o, Option):
 
212
                o = Option.OPTIONS[o]
 
213
            r[o.name] = o
 
214
        return r
 
215
 
 
216
    @deprecated_method(zero_eight)
 
217
    def run_argv(self, argv):
 
218
        """Parse command line and run.
 
219
        
 
220
        See run_argv_aliases for the 0.8 and beyond api.
 
221
        """
 
222
        return self.run_argv_aliases(argv)
 
223
 
 
224
    def run_argv_aliases(self, argv, alias_argv=None):
 
225
        """Parse the command line and run with extra aliases in alias_argv."""
 
226
        args, opts = parse_args(self, argv, alias_argv)
 
227
        if 'help' in opts:  # e.g. bzr add --help
 
228
            from bzrlib.help import help_on_command
 
229
            help_on_command(self.name())
 
230
            return 0
 
231
        # XXX: This should be handled by the parser
 
232
        allowed_names = self.options().keys()
 
233
        for oname in opts:
 
234
            if oname not in allowed_names:
 
235
                raise BzrCommandError("option '--%s' is not allowed for"
 
236
                                      " command %r" % (oname, self.name()))
 
237
        # mix arguments and options into one dictionary
 
238
        cmdargs = _match_argform(self.name(), self.takes_args, args)
 
239
        cmdopts = {}
 
240
        for k, v in opts.items():
 
241
            cmdopts[k.replace('-', '_')] = v
 
242
 
 
243
        all_cmd_args = cmdargs.copy()
 
244
        all_cmd_args.update(cmdopts)
 
245
 
 
246
        return self.run(**all_cmd_args)
 
247
    
 
248
    def run(self):
 
249
        """Actually run the command.
 
250
 
 
251
        This is invoked with the options and arguments bound to
 
252
        keyword parameters.
 
253
 
 
254
        Return 0 or None if the command was successful, or a non-zero
 
255
        shell error code if not.  It's OK for this method to allow
 
256
        an exception to raise up.
 
257
        """
 
258
        raise NotImplementedError('no implementation of command %r' 
 
259
                                  % self.name())
 
260
 
 
261
    def help(self):
 
262
        """Return help message for this class."""
 
263
        from inspect import getdoc
 
264
        if self.__doc__ is Command.__doc__:
 
265
            return None
 
266
        return getdoc(self)
 
267
 
 
268
    def name(self):
 
269
        return _unsquish_command_name(self.__class__.__name__)
 
270
 
 
271
 
 
272
def parse_spec(spec):
 
273
    """
 
274
    >>> parse_spec(None)
 
275
    [None, None]
 
276
    >>> parse_spec("./")
 
277
    ['./', None]
 
278
    >>> parse_spec("../@")
 
279
    ['..', -1]
 
280
    >>> parse_spec("../f/@35")
 
281
    ['../f', 35]
 
282
    >>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
 
283
    ['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
 
284
    """
 
285
    if spec is None:
 
286
        return [None, None]
 
287
    if '/@' in spec:
 
288
        parsed = spec.split('/@')
 
289
        assert len(parsed) == 2
 
290
        if parsed[1] == "":
 
291
            parsed[1] = -1
 
292
        else:
 
293
            try:
 
294
                parsed[1] = int(parsed[1])
 
295
            except ValueError:
 
296
                pass # We can allow stuff like ./@revid:blahblahblah
396
297
            else:
397
 
                kindch = '???'
398
 
                
399
 
            print '%-8s %s%s' % (fc, fp, kindch)
400
 
        else:
401
 
            print fp
402
 
    
403
 
    
404
 
 
405
 
def cmd_unknowns():
406
 
    """List unknown files"""
407
 
    for f in Branch('.').unknowns():
408
 
        print quotefn(f)
409
 
 
410
 
 
411
 
def cmd_lookup_revision(revno):
412
 
    try:
413
 
        revno = int(revno)
414
 
    except ValueError:
415
 
        bailout("usage: lookup-revision REVNO",
416
 
                ["REVNO is a non-negative revision number for this branch"])
417
 
 
418
 
    print Branch('.').lookup_revision(revno) or NONE_STRING
419
 
 
420
 
 
421
 
 
422
 
def cmd_export(revno, dest):
423
 
    """Export past revision to destination directory."""
424
 
    b = Branch('.')
425
 
    rh = b.lookup_revision(int(revno))
426
 
    t = b.revision_tree(rh)
427
 
    t.export(dest)
428
 
 
429
 
 
430
 
 
431
 
######################################################################
432
 
# internal/test commands
433
 
 
434
 
 
435
 
def cmd_uuid():
436
 
    """Print a newly-generated UUID."""
437
 
    print uuid()
438
 
 
439
 
 
440
 
 
441
 
def cmd_local_time_offset():
442
 
    print bzrlib.osutils.local_time_offset()
443
 
 
444
 
 
445
 
 
446
 
def cmd_commit(message, verbose=False):
447
 
    Branch('.').commit(message, verbose=verbose)
448
 
 
449
 
 
450
 
def cmd_check():
451
 
    """Check consistency of the branch."""
452
 
    check()
453
 
 
454
 
 
455
 
def cmd_is(pred, *rest):
456
 
    """Test whether PREDICATE is true."""
457
 
    try:
458
 
        cmd_handler = globals()['assert_' + pred.replace('-', '_')]
459
 
    except KeyError:
460
 
        bailout("unknown predicate: %s" % quotefn(pred))
461
 
        
462
 
    try:
463
 
        cmd_handler(*rest)
464
 
    except BzrCheckError:
465
 
        # by default we don't print the message so that this can
466
 
        # be used from shell scripts without producing noise
467
 
        sys.exit(1)
468
 
 
469
 
 
470
 
def cmd_username():
471
 
    print bzrlib.osutils.username()
472
 
 
473
 
 
474
 
def cmd_user_email():
475
 
    print bzrlib.osutils.user_email()
476
 
 
477
 
 
478
 
def cmd_gen_revision_id():
479
 
    import time
480
 
    print bzrlib.branch._gen_revision_id(time.time())
481
 
 
482
 
 
483
 
def cmd_doctest():
484
 
    """Run internal doctest suite"""
485
 
    ## -v, if present, is seen by doctest; the argument is just here
486
 
    ## so our parser doesn't complain
487
 
 
488
 
    ## TODO: --verbose option
489
 
    
490
 
    import bzr, doctest, bzrlib.store
491
 
    bzrlib.trace.verbose = False
492
 
    doctest.testmod(bzr)
493
 
    doctest.testmod(bzrlib.store)
494
 
    doctest.testmod(bzrlib.inventory)
495
 
    doctest.testmod(bzrlib.branch)
496
 
    doctest.testmod(bzrlib.osutils)
497
 
    doctest.testmod(bzrlib.tree)
498
 
 
499
 
    # more strenuous tests;
500
 
    import bzrlib.tests
501
 
    doctest.testmod(bzrlib.tests)
502
 
 
503
 
 
504
 
######################################################################
505
 
# help
506
 
 
507
 
 
508
 
def cmd_help():
509
 
    # TODO: Specific help for particular commands
510
 
    print __doc__
511
 
 
512
 
 
513
 
def cmd_version():
514
 
    print "bzr (bazaar-ng) %s" % __version__
515
 
    print __copyright__
516
 
    print "http://bazaar-ng.org/"
517
 
    print
518
 
    print \
519
 
"""bzr comes with ABSOLUTELY NO WARRANTY.  bzr is free software, and
520
 
you may use, modify and redistribute it under the terms of the GNU 
521
 
General Public License version 2 or later."""
522
 
 
523
 
 
524
 
def cmd_rocks():
525
 
    """Statement of optimism."""
526
 
    print "it sure does!"
527
 
 
528
 
 
529
 
 
530
 
######################################################################
531
 
# main routine
532
 
 
533
 
 
534
 
# list of all available options; the rhs can be either None for an
535
 
# option that takes no argument, or a constructor function that checks
536
 
# the type.
537
 
OPTIONS = {
538
 
    'all':                    None,
539
 
    'help':                   None,
540
 
    'message':                unicode,
541
 
    'revision':               int,
542
 
    'show-ids':               None,
543
 
    'timezone':               str,
544
 
    'verbose':                None,
545
 
    'version':                None,
546
 
    }
547
 
 
548
 
SHORT_OPTIONS = {
549
 
    'm':                      'message',
550
 
    'r':                      'revision',
551
 
    'v':                      'verbose',
552
 
}
553
 
 
554
 
# List of options that apply to particular commands; commands not
555
 
# listed take none.
556
 
cmd_options = {
557
 
    'add':                    ['verbose'],
558
 
    'commit':                 ['message', 'verbose'],
559
 
    'diff':                   ['revision'],
560
 
    'inventory':              ['revision'],
561
 
    'log':                    ['show-ids', 'timezone'],
562
 
    'ls':                     ['revision', 'verbose'],
563
 
    'remove':                 ['verbose'],
564
 
    'status':                 ['all'],
565
 
    }
566
 
 
567
 
 
568
 
cmd_args = {
569
 
    'init':                   [],
570
 
    'add':                    ['file+'],
571
 
    'commit':                 [],
572
 
    'diff':                   [],
573
 
    'file-id':                ['filename'],
574
 
    'get-file-text':          ['text_id'],
575
 
    'get-inventory':          ['inventory_id'],
576
 
    'get-revision':           ['revision_id'],
577
 
    'get-revision-inventory': ['revision_id'],
578
 
    'log':                    [],
579
 
    'lookup-revision':        ['revno'],
580
 
    'export':                 ['revno', 'dest'],
581
 
    'remove':                 ['file+'],
582
 
    'status':                 [],
583
 
    }
584
 
 
585
 
 
586
 
def parse_args(argv):
 
298
                assert parsed[1] >=0
 
299
    else:
 
300
        parsed = [spec, None]
 
301
    return parsed
 
302
 
 
303
def parse_args(command, argv, alias_argv=None):
587
304
    """Parse command line.
588
305
    
589
306
    Arguments and options are parsed at this level before being passed
590
307
    down to specific command handlers.  This routine knows, from a
591
308
    lookup table, something about the available options, what optargs
592
309
    they take, and which commands will accept them.
593
 
 
594
 
    >>> parse_args('--help'.split())
595
 
    ([], {'help': True})
596
 
    >>> parse_args('--version'.split())
597
 
    ([], {'version': True})
598
 
    >>> parse_args('status --all'.split())
599
 
    (['status'], {'all': True})
600
 
    >>> parse_args('commit --message=biter'.split())
601
 
    (['commit'], {'message': u'biter'})
602
310
    """
 
311
    # TODO: chop up this beast; make it a method of the Command
603
312
    args = []
604
313
    opts = {}
605
 
 
606
 
    # TODO: Maybe handle '--' to end options?
607
 
 
608
 
    while argv:
609
 
        a = argv.pop(0)
610
 
        if a[0] == '-':
611
 
            optarg = None
612
 
            if a[1] == '-':
613
 
                mutter("  got option %r" % a)
614
 
                if '=' in a:
615
 
                    optname, optarg = a[2:].split('=', 1)
 
314
    alias_opts = {}
 
315
 
 
316
    cmd_options = command.options()
 
317
    argsover = False
 
318
    proc_aliasarg = True # Are we processing alias_argv now?
 
319
    for proc_argv in alias_argv, argv:
 
320
        while proc_argv:
 
321
            a = proc_argv.pop(0)
 
322
            if argsover:
 
323
                args.append(a)
 
324
                continue
 
325
            elif a == '--':
 
326
                # We've received a standalone -- No more flags
 
327
                argsover = True
 
328
                continue
 
329
            if a[0] == '-':
 
330
                # option names must not be unicode
 
331
                a = str(a)
 
332
                optarg = None
 
333
                if a[1] == '-':
 
334
                    mutter("  got option %r", a)
 
335
                    if '=' in a:
 
336
                        optname, optarg = a[2:].split('=', 1)
 
337
                    else:
 
338
                        optname = a[2:]
 
339
                    if optname not in cmd_options:
 
340
                        raise BzrOptionError('unknown long option %r for'
 
341
                                             ' command %s' % 
 
342
                                             (a, command.name()))
616
343
                else:
617
 
                    optname = a[2:]
618
 
                if optname not in OPTIONS:
619
 
                    bailout('unknown long option %r' % a)
620
 
            else:
621
 
                shortopt = a[1:]
622
 
                if shortopt not in SHORT_OPTIONS:
623
 
                    bailout('unknown short option %r' % a)
624
 
                optname = SHORT_OPTIONS[shortopt]
625
 
            
626
 
            if optname in opts:
627
 
                # XXX: Do we ever want to support this, e.g. for -r?
628
 
                bailout('repeated option %r' % a)
 
344
                    shortopt = a[1:]
 
345
                    if shortopt in Option.SHORT_OPTIONS:
 
346
                        # Multi-character options must have a space to delimit
 
347
                        # their value
 
348
                        # ^^^ what does this mean? mbp 20051014
 
349
                        optname = Option.SHORT_OPTIONS[shortopt].name
 
350
                    else:
 
351
                        # Single character short options, can be chained,
 
352
                        # and have their value appended to their name
 
353
                        shortopt = a[1:2]
 
354
                        if shortopt not in Option.SHORT_OPTIONS:
 
355
                            # We didn't find the multi-character name, and we
 
356
                            # didn't find the single char name
 
357
                            raise BzrError('unknown short option %r' % a)
 
358
                        optname = Option.SHORT_OPTIONS[shortopt].name
 
359
 
 
360
                        if a[2:]:
 
361
                            # There are extra things on this option
 
362
                            # see if it is the value, or if it is another
 
363
                            # short option
 
364
                            optargfn = Option.OPTIONS[optname].type
 
365
                            if optargfn is None:
 
366
                                # This option does not take an argument, so the
 
367
                                # next entry is another short option, pack it
 
368
                                # back into the list
 
369
                                proc_argv.insert(0, '-' + a[2:])
 
370
                            else:
 
371
                                # This option takes an argument, so pack it
 
372
                                # into the array
 
373
                                optarg = a[2:]
629
374
                
630
 
            optargfn = OPTIONS[optname]
631
 
            if optargfn:
632
 
                if optarg == None:
633
 
                    if not argv:
634
 
                        bailout('option %r needs an argument' % a)
 
375
                    if optname not in cmd_options:
 
376
                        raise BzrOptionError('unknown short option %r for'
 
377
                                             ' command %s' % 
 
378
                                             (shortopt, command.name()))
 
379
                if optname in opts:
 
380
                    # XXX: Do we ever want to support this, e.g. for -r?
 
381
                    if proc_aliasarg:
 
382
                        raise BzrError('repeated option %r' % a)
 
383
                    elif optname in alias_opts:
 
384
                        # Replace what's in the alias with what's in the real
 
385
                        # argument
 
386
                        del alias_opts[optname]
 
387
                        del opts[optname]
 
388
                        proc_argv.insert(0, a)
 
389
                        continue
635
390
                    else:
636
 
                        optarg = argv.pop(0)
637
 
                opts[optname] = optargfn(optarg)
638
 
                mutter("    option argument %r" % opts[optname])
 
391
                        raise BzrError('repeated option %r' % a)
 
392
                    
 
393
                option_obj = cmd_options[optname]
 
394
                optargfn = option_obj.type
 
395
                if optargfn:
 
396
                    if optarg == None:
 
397
                        if not proc_argv:
 
398
                            raise BzrError('option %r needs an argument' % a)
 
399
                        else:
 
400
                            optarg = proc_argv.pop(0)
 
401
                    opts[optname] = optargfn(optarg)
 
402
                    if proc_aliasarg:
 
403
                        alias_opts[optname] = optargfn(optarg)
 
404
                else:
 
405
                    if optarg != None:
 
406
                        raise BzrError('option %r takes no argument' % optname)
 
407
                    opts[optname] = True
 
408
                    if proc_aliasarg:
 
409
                        alias_opts[optname] = True
639
410
            else:
640
 
                if optarg != None:
641
 
                    bailout('option %r takes no argument' % optname)
642
 
                opts[optname] = True
643
 
        else:
644
 
            args.append(a)
645
 
 
 
411
                args.append(a)
 
412
        proc_aliasarg = False # Done with alias argv
646
413
    return args, opts
647
414
 
648
415
 
649
 
 
650
 
def _match_args(cmd, args):
651
 
    """Check non-option arguments match required pattern.
652
 
 
653
 
    >>> _match_args('status', ['asdasdsadasd'])
654
 
    Traceback (most recent call last):
655
 
    ...
656
 
    BzrError: ("extra arguments to command status: ['asdasdsadasd']", [])
657
 
    >>> _match_args('add', ['asdasdsadasd'])
658
 
    {'file_list': ['asdasdsadasd']}
659
 
    >>> _match_args('add', 'abc def gj'.split())
660
 
    {'file_list': ['abc', 'def', 'gj']}
661
 
    """
662
 
    # match argument pattern
663
 
    argform = cmd_args.get(cmd, [])
 
416
def _match_argform(cmd, takes_args, args):
664
417
    argdict = {}
665
 
    # TODO: Need a way to express 'cp SRC... DEST', where it matches
666
 
    # all but one.
667
418
 
668
 
    for ap in argform:
 
419
    # step through args and takes_args, allowing appropriate 0-many matches
 
420
    for ap in takes_args:
669
421
        argname = ap[:-1]
670
422
        if ap[-1] == '?':
671
 
            assert 0
672
 
        elif ap[-1] == '*':
673
 
            assert 0
 
423
            if args:
 
424
                argdict[argname] = args.pop(0)
 
425
        elif ap[-1] == '*': # all remaining arguments
 
426
            if args:
 
427
                argdict[argname + '_list'] = args[:]
 
428
                args = []
 
429
            else:
 
430
                argdict[argname + '_list'] = None
674
431
        elif ap[-1] == '+':
675
432
            if not args:
676
 
                bailout("command %r needs one or more %s"
 
433
                raise BzrCommandError("command %r needs one or more %s"
677
434
                        % (cmd, argname.upper()))
678
435
            else:
679
436
                argdict[argname + '_list'] = args[:]
680
437
                args = []
 
438
        elif ap[-1] == '$': # all but one
 
439
            if len(args) < 2:
 
440
                raise BzrCommandError("command %r needs one or more %s"
 
441
                        % (cmd, argname.upper()))
 
442
            argdict[argname + '_list'] = args[:-1]
 
443
            args[:-1] = []                
681
444
        else:
682
445
            # just a plain arg
683
446
            argname = ap
684
447
            if not args:
685
 
                bailout("command %r requires argument %s"
 
448
                raise BzrCommandError("command %r requires argument %s"
686
449
                        % (cmd, argname.upper()))
687
450
            else:
688
451
                argdict[argname] = args.pop(0)
689
452
            
690
453
    if args:
691
 
        bailout("extra arguments to command %s: %r"
692
 
                % (cmd, args))
 
454
        raise BzrCommandError("extra argument to command %s: %s"
 
455
                              % (cmd, args[0]))
693
456
 
694
457
    return argdict
695
458
 
696
459
 
697
460
 
 
461
def apply_profiled(the_callable, *args, **kwargs):
 
462
    import hotshot
 
463
    import tempfile
 
464
    import hotshot.stats
 
465
    pffileno, pfname = tempfile.mkstemp()
 
466
    try:
 
467
        prof = hotshot.Profile(pfname)
 
468
        try:
 
469
            ret = prof.runcall(the_callable, *args, **kwargs) or 0
 
470
        finally:
 
471
            prof.close()
 
472
        stats = hotshot.stats.load(pfname)
 
473
        stats.strip_dirs()
 
474
        stats.sort_stats('cum')   # 'time'
 
475
        ## XXX: Might like to write to stderr or the trace file instead but
 
476
        ## print_stats seems hardcoded to stdout
 
477
        stats.print_stats(20)
 
478
        return ret
 
479
    finally:
 
480
        os.close(pffileno)
 
481
        os.remove(pfname)
 
482
 
 
483
 
 
484
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
 
485
    from bzrlib.lsprof import profile
 
486
    import cPickle
 
487
    ret, stats = profile(the_callable, *args, **kwargs)
 
488
    stats.sort()
 
489
    if filename is None:
 
490
        stats.pprint()
 
491
    else:
 
492
        stats.freeze()
 
493
        cPickle.dump(stats, open(filename, 'w'), 2)
 
494
        print 'Profile data written to %r.' % filename
 
495
    return ret
 
496
 
 
497
 
 
498
def get_alias(cmd):
 
499
    """Return an expanded alias, or None if no alias exists"""
 
500
    import bzrlib.config
 
501
    alias = bzrlib.config.GlobalConfig().get_alias(cmd)
 
502
    if (alias):
 
503
        return alias.split(' ')
 
504
    return None
 
505
 
 
506
 
698
507
def run_bzr(argv):
699
508
    """Execute a command.
700
509
 
701
510
    This is similar to main(), but without all the trappings for
702
 
    logging and error handling.
 
511
    logging and error handling.  
 
512
    
 
513
    argv
 
514
       The command-line arguments, without the program name from argv[0]
 
515
    
 
516
    Returns a command status or raises an exception.
 
517
 
 
518
    Special master options: these must come before the command because
 
519
    they control how the command is interpreted.
 
520
 
 
521
    --no-plugins
 
522
        Do not load plugin modules at all
 
523
 
 
524
    --no-aliases
 
525
        Do not allow aliases
 
526
 
 
527
    --builtin
 
528
        Only use builtin commands.  (Plugins are still allowed to change
 
529
        other behaviour.)
 
530
 
 
531
    --profile
 
532
        Run under the Python hotshot profiler.
 
533
 
 
534
    --lsprof
 
535
        Run under the Python lsprof profiler.
703
536
    """
704
 
    try:
705
 
        args, opts = parse_args(argv[1:])
706
 
        if 'help' in opts:
707
 
            # TODO: pass down other arguments in case they asked for
708
 
            # help on a command name?
709
 
            cmd_help()
710
 
            return 0
711
 
        elif 'version' in opts:
712
 
            cmd_version()
713
 
            return 0
714
 
        cmd = args.pop(0)
715
 
    except IndexError:
716
 
        log_error('usage: bzr COMMAND\n')
717
 
        log_error('  try "bzr help"\n')
718
 
        return 1
719
 
            
720
 
    try:
721
 
        cmd_handler = globals()['cmd_' + cmd.replace('-', '_')]
722
 
    except KeyError:
723
 
        bailout("unknown command " + `cmd`)
724
 
 
725
 
    # TODO: special --profile option to turn on the Python profiler
726
 
 
727
 
    # check options are reasonable
728
 
    allowed = cmd_options.get(cmd, [])
729
 
    for oname in opts:
730
 
        if oname not in allowed:
731
 
            bailout("option %r is not allowed for command %r"
732
 
                    % (oname, cmd))
733
 
 
734
 
    cmdargs = _match_args(cmd, args)
735
 
    cmdargs.update(opts)
736
 
 
737
 
    ret = cmd_handler(**cmdargs) or 0
738
 
 
 
537
    argv = [a.decode(bzrlib.user_encoding) for a in argv]
 
538
 
 
539
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
 
540
                opt_no_aliases = False
 
541
    opt_lsprof_file = None
 
542
 
 
543
    # --no-plugins is handled specially at a very early stage. We need
 
544
    # to load plugins before doing other command parsing so that they
 
545
    # can override commands, but this needs to happen first.
 
546
 
 
547
    argv_copy = []
 
548
    i = 0
 
549
    while i < len(argv):
 
550
        a = argv[i]
 
551
        if a == '--profile':
 
552
            opt_profile = True
 
553
        elif a == '--lsprof':
 
554
            opt_lsprof = True
 
555
        elif a == '--lsprof-file':
 
556
            opt_lsprof_file = argv[i + 1]
 
557
            i += 1
 
558
        elif a == '--no-plugins':
 
559
            opt_no_plugins = True
 
560
        elif a == '--no-aliases':
 
561
            opt_no_aliases = True
 
562
        elif a == '--builtin':
 
563
            opt_builtin = True
 
564
        elif a in ('--quiet', '-q'):
 
565
            be_quiet()
 
566
        else:
 
567
            argv_copy.append(a)
 
568
        i += 1
 
569
 
 
570
    argv = argv_copy
 
571
    if (not argv):
 
572
        from bzrlib.builtins import cmd_help
 
573
        cmd_help().run_argv_aliases([])
 
574
        return 0
 
575
 
 
576
    if argv[0] == '--version':
 
577
        from bzrlib.builtins import show_version
 
578
        show_version()
 
579
        return 0
 
580
        
 
581
    if not opt_no_plugins:
 
582
        from bzrlib.plugin import load_plugins
 
583
        load_plugins()
 
584
    else:
 
585
        from bzrlib.plugin import disable_plugins
 
586
        disable_plugins()
 
587
 
 
588
    alias_argv = None
 
589
 
 
590
    if not opt_no_aliases:
 
591
        alias_argv = get_alias(argv[0])
 
592
        if alias_argv:
 
593
            alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
 
594
            argv[0] = alias_argv.pop(0)
 
595
 
 
596
    cmd = str(argv.pop(0))
 
597
 
 
598
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
 
599
    if not getattr(cmd_obj.run_argv, 'is_deprecated', False):
 
600
        run = cmd_obj.run_argv
 
601
        run_argv = [argv]
 
602
    else:
 
603
        run = cmd_obj.run_argv_aliases
 
604
        run_argv = [argv, alias_argv]
 
605
 
 
606
    try:
 
607
        if opt_lsprof:
 
608
            ret = apply_lsprofiled(opt_lsprof_file, run, *run_argv)
 
609
        elif opt_profile:
 
610
            ret = apply_profiled(run, *run_argv)
 
611
        else:
 
612
            ret = run(*run_argv)
 
613
        return ret or 0
 
614
    finally:
 
615
        # reset, in case we may do other commands later within the same process
 
616
        be_quiet(False)
 
617
 
 
618
def display_command(func):
 
619
    """Decorator that suppresses pipe/interrupt errors."""
 
620
    def ignore_pipe(*args, **kwargs):
 
621
        try:
 
622
            result = func(*args, **kwargs)
 
623
            sys.stdout.flush()
 
624
            return result
 
625
        except IOError, e:
 
626
            if not hasattr(e, 'errno'):
 
627
                raise
 
628
            if e.errno != errno.EPIPE:
 
629
                raise
 
630
            pass
 
631
        except KeyboardInterrupt:
 
632
            pass
 
633
    return ignore_pipe
739
634
 
740
635
 
741
636
def main(argv):
742
 
    ## TODO: Handle command-line options; probably know what options are valid for
743
 
    ## each command
744
 
 
745
 
    ## TODO: If the arguments are wrong, give a usage message rather
746
 
    ## than just a backtrace.
747
 
 
 
637
    import bzrlib.ui
 
638
    from bzrlib.ui.text import TextUIFactory
 
639
    ## bzrlib.trace.enable_default_logging()
 
640
    bzrlib.trace.log_startup(argv)
 
641
    bzrlib.ui.ui_factory = TextUIFactory()
 
642
    ret = run_bzr_catch_errors(argv[1:])
 
643
    mutter("return code %d", ret)
 
644
    return ret
 
645
 
 
646
 
 
647
def run_bzr_catch_errors(argv):
748
648
    try:
749
 
        # TODO: Lift into separate function in trace.py
750
 
        # TODO: Also show contents of /etc/lsb-release, if it can be parsed.
751
 
        #       Perhaps that should eventually go into the platform library?
752
 
        # TODO: If the file doesn't exist, add a note describing it.
753
 
        t = bzrlib.trace._tracefile
754
 
        t.write('-' * 60 + '\n')
755
 
        t.write('bzr invoked at %s\n' % format_date(time.time()))
756
 
        t.write('  by %s on %s\n' % (bzrlib.osutils.username(), socket.getfqdn()))
757
 
        t.write('  arguments: %r\n' % argv)
758
 
 
759
 
        starttime = os.times()[4]
760
 
 
761
 
        import platform
762
 
        t.write('  platform: %s\n' % platform.platform())
763
 
        t.write('  python: %s\n' % platform.python_version())
764
 
 
765
 
        ret = run_bzr(argv)
766
 
        
767
 
        times = os.times()
768
 
        mutter("finished, %.3fu/%.3fs cpu, %.3fu/%.3fs cum"
769
 
               % times[:4])
770
 
        mutter("    %.3f elapsed" % (times[4] - starttime))
771
 
 
772
 
        return ret
773
 
    except BzrError, e:
774
 
        log_error('bzr: error: ' + e.args[0] + '\n')
775
 
        if len(e.args) > 1:
776
 
            for h in e.args[1]:
777
 
                log_error('  ' + h + '\n')
778
 
        return 1
 
649
        try:
 
650
            return run_bzr(argv)
 
651
        finally:
 
652
            # do this here inside the exception wrappers to catch EPIPE
 
653
            sys.stdout.flush()
779
654
    except Exception, e:
780
 
        log_error('bzr: exception: %s\n' % e)
781
 
        log_error('    see .bzr.log for details\n')
782
 
        traceback.print_exc(None, bzrlib.trace._tracefile)
783
 
        traceback.print_exc(None, sys.stderr)
784
 
        return 1
785
 
 
786
 
    # TODO: Maybe nicer handling of IOError?
787
 
 
788
 
 
 
655
        # used to handle AssertionError and KeyboardInterrupt
 
656
        # specially here, but hopefully they're handled ok by the logger now
 
657
        import errno
 
658
        if (isinstance(e, IOError) 
 
659
            and hasattr(e, 'errno')
 
660
            and e.errno == errno.EPIPE):
 
661
            bzrlib.trace.note('broken pipe')
 
662
            return 3
 
663
        else:
 
664
            bzrlib.trace.log_exception()
 
665
            if os.environ.get('BZR_PDB'):
 
666
                print '**** entering debugger'
 
667
                import pdb
 
668
                pdb.post_mortem(sys.exc_traceback)
 
669
            return 3
789
670
 
790
671
if __name__ == '__main__':
791
672
    sys.exit(main(sys.argv))
792
 
    ##import profile
793
 
    ##profile.run('main(sys.argv)')
794