← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Olaf Conradi
  • Date: 2006-03-28 23:30:02 UTC
  • mto: (1661.1.1 bzr.mbp.remember)
  • mto: This revision was merged to the branch mainline in revision 1663.
  • Revision ID: olaf@conradi.org-20060328233002-f6262df0e19c1963
Added testcases for using pull with --remember. Moved remember code to
beginning of cmd_pull. This remembers the location in case of a failure
during pull.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commands.py
1
 
# Copyright (C) 2004, 2005 by Canonical Ltd
2
 
 
 
1
# Copyright (C) 2006 by Canonical Ltd
 
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
 
 
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
18
# TODO: probably should say which arguments are candidates for glob
19
19
# expansion on windows and do that at the command level.
20
20
 
21
 
# TODO: Help messages for options.
22
 
 
23
21
# TODO: Define arguments by objects, rather than just using names.
24
22
# Those objects can specify the expected type of the argument, which
25
 
# would help with validation and shell completion.
 
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.
26
27
 
27
28
# TODO: "--profile=cum", to change sort order.  Is there any value in leaving
28
29
# the profile output behind so it can be interactively examined?
30
31
import sys
31
32
import os
32
33
from warnings import warn
33
 
from inspect import getdoc
 
34
import errno
34
35
 
35
36
import bzrlib
 
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 *
36
45
import bzrlib.trace
37
 
from bzrlib.trace import mutter, note, log_error, warning
38
 
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError, NotBranchError
39
 
from bzrlib.revisionspec import RevisionSpec
40
 
from bzrlib import BZRDIR
41
 
from bzrlib.option import Option
 
46
from bzrlib.trace import mutter, note, log_error, warning, be_quiet
42
47
 
43
48
plugin_cmds = {}
44
49
 
45
50
 
46
 
def register_command(cmd):
 
51
def register_command(cmd, decorate=False):
47
52
    "Utility function to help register a command"
48
53
    global plugin_cmds
49
54
    k = cmd.__name__
54
59
    if not plugin_cmds.has_key(k_unsquished):
55
60
        plugin_cmds[k_unsquished] = cmd
56
61
        mutter('registered plugin command %s', k_unsquished)      
 
62
        if decorate and k_unsquished in builtin_command_names():
 
63
            return _builtin_commands()[k_unsquished]
 
64
    elif decorate:
 
65
        result = plugin_cmds[k_unsquished]
 
66
        plugin_cmds[k_unsquished] = cmd
 
67
        return result
57
68
    else:
58
69
        log_error('Two plugins defined the same command: %r' % k)
59
70
        log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
157
168
        List of argument forms, marked with whether they are optional,
158
169
        repeated, etc.
159
170
 
 
171
                Examples:
 
172
 
 
173
                ['to_location', 'from_branch?', 'file*']
 
174
 
 
175
                'to_location' is required
 
176
                'from_branch' is optional
 
177
                'file' can be specified 0 or more times
 
178
 
160
179
    takes_options
161
180
        List of options that may be given for this command.  These can
162
181
        be either strings, referring to globally-defined options,
189
208
            r[o.name] = o
190
209
        return r
191
210
 
 
211
    @deprecated_method(zero_eight)
192
212
    def run_argv(self, argv):
193
 
        """Parse command line and run."""
194
 
        args, opts = parse_args(self, argv)
 
213
        """Parse command line and run.
 
214
        
 
215
        See run_argv_aliases for the 0.8 and beyond api.
 
216
        """
 
217
        return self.run_argv_aliases(argv)
 
218
 
 
219
    def run_argv_aliases(self, argv, alias_argv=None):
 
220
        """Parse the command line and run with extra aliases in alias_argv."""
 
221
        args, opts = parse_args(self, argv, alias_argv)
195
222
        if 'help' in opts:  # e.g. bzr add --help
196
223
            from bzrlib.help import help_on_command
197
224
            help_on_command(self.name())
200
227
        allowed_names = self.options().keys()
201
228
        for oname in opts:
202
229
            if oname not in allowed_names:
203
 
                raise BzrCommandError("option '--%s' is not allowed for command %r"
204
 
                                      % (oname, self.name()))
 
230
                raise BzrCommandError("option '--%s' is not allowed for"
 
231
                                      " command %r" % (oname, self.name()))
205
232
        # mix arguments and options into one dictionary
206
233
        cmdargs = _match_argform(self.name(), self.takes_args, args)
207
234
        cmdopts = {}
212
239
        all_cmd_args.update(cmdopts)
213
240
 
214
241
        return self.run(**all_cmd_args)
215
 
 
216
242
    
217
243
    def run(self):
218
244
        """Actually run the command.
224
250
        shell error code if not.  It's OK for this method to allow
225
251
        an exception to raise up.
226
252
        """
227
 
        raise NotImplementedError()
228
 
 
 
253
        raise NotImplementedError('no implementation of command %r' 
 
254
                                  % self.name())
229
255
 
230
256
    def help(self):
231
257
        """Return help message for this class."""
 
258
        from inspect import getdoc
232
259
        if self.__doc__ is Command.__doc__:
233
260
            return None
234
261
        return getdoc(self)
268
295
        parsed = [spec, None]
269
296
    return parsed
270
297
 
271
 
def parse_args(command, argv):
 
298
def parse_args(command, argv, alias_argv=None):
272
299
    """Parse command line.
273
300
    
274
301
    Arguments and options are parsed at this level before being passed
279
306
    # TODO: chop up this beast; make it a method of the Command
280
307
    args = []
281
308
    opts = {}
 
309
    alias_opts = {}
282
310
 
283
311
    cmd_options = command.options()
284
312
    argsover = False
285
 
    while argv:
286
 
        a = argv.pop(0)
287
 
        if argsover:
288
 
            args.append(a)
289
 
            continue
290
 
        elif a == '--':
291
 
            # We've received a standalone -- No more flags
292
 
            argsover = True
293
 
            continue
294
 
        if a[0] == '-':
295
 
            # option names must not be unicode
296
 
            a = str(a)
297
 
            optarg = None
298
 
            if a[1] == '-':
299
 
                mutter("  got option %r" % a)
300
 
                if '=' in a:
301
 
                    optname, optarg = a[2:].split('=', 1)
302
 
                else:
303
 
                    optname = a[2:]
304
 
                if optname not in cmd_options:
305
 
                    raise BzrCommandError('unknown long option %r for command %s' 
306
 
                            % (a, command.name))
307
 
            else:
308
 
                shortopt = a[1:]
309
 
                if shortopt in Option.SHORT_OPTIONS:
310
 
                    # Multi-character options must have a space to delimit
311
 
                    # their value
312
 
                    # ^^^ what does this mean? mbp 20051014
313
 
                    optname = Option.SHORT_OPTIONS[shortopt].name
314
 
                else:
315
 
                    # Single character short options, can be chained,
316
 
                    # and have their value appended to their name
317
 
                    shortopt = a[1:2]
318
 
                    if shortopt not in Option.SHORT_OPTIONS:
319
 
                        # We didn't find the multi-character name, and we
320
 
                        # didn't find the single char name
321
 
                        raise BzrError('unknown short option %r' % a)
322
 
                    optname = Option.SHORT_OPTIONS[shortopt].name
 
313
    proc_aliasarg = True # Are we processing alias_argv now?
 
314
    for proc_argv in alias_argv, argv:
 
315
        while proc_argv:
 
316
            a = proc_argv.pop(0)
 
317
            if argsover:
 
318
                args.append(a)
 
319
                continue
 
320
            elif a == '--':
 
321
                # We've received a standalone -- No more flags
 
322
                argsover = True
 
323
                continue
 
324
            if a[0] == '-':
 
325
                # option names must not be unicode
 
326
                a = str(a)
 
327
                optarg = None
 
328
                if a[1] == '-':
 
329
                    mutter("  got option %r", a)
 
330
                    if '=' in a:
 
331
                        optname, optarg = a[2:].split('=', 1)
 
332
                    else:
 
333
                        optname = a[2:]
 
334
                    if optname not in cmd_options:
 
335
                        raise BzrOptionError('unknown long option %r for'
 
336
                                             ' command %s' % 
 
337
                                             (a, command.name()))
 
338
                else:
 
339
                    shortopt = a[1:]
 
340
                    if shortopt in Option.SHORT_OPTIONS:
 
341
                        # Multi-character options must have a space to delimit
 
342
                        # their value
 
343
                        # ^^^ what does this mean? mbp 20051014
 
344
                        optname = Option.SHORT_OPTIONS[shortopt].name
 
345
                    else:
 
346
                        # Single character short options, can be chained,
 
347
                        # and have their value appended to their name
 
348
                        shortopt = a[1:2]
 
349
                        if shortopt not in Option.SHORT_OPTIONS:
 
350
                            # We didn't find the multi-character name, and we
 
351
                            # didn't find the single char name
 
352
                            raise BzrError('unknown short option %r' % a)
 
353
                        optname = Option.SHORT_OPTIONS[shortopt].name
323
354
 
324
 
                    if a[2:]:
325
 
                        # There are extra things on this option
326
 
                        # see if it is the value, or if it is another
327
 
                        # short option
328
 
                        optargfn = Option.OPTIONS[optname].type
329
 
                        if optargfn is None:
330
 
                            # This option does not take an argument, so the
331
 
                            # next entry is another short option, pack it back
332
 
                            # into the list
333
 
                            argv.insert(0, '-' + a[2:])
 
355
                        if a[2:]:
 
356
                            # There are extra things on this option
 
357
                            # see if it is the value, or if it is another
 
358
                            # short option
 
359
                            optargfn = Option.OPTIONS[optname].type
 
360
                            if optargfn is None:
 
361
                                # This option does not take an argument, so the
 
362
                                # next entry is another short option, pack it
 
363
                                # back into the list
 
364
                                proc_argv.insert(0, '-' + a[2:])
 
365
                            else:
 
366
                                # This option takes an argument, so pack it
 
367
                                # into the array
 
368
                                optarg = a[2:]
 
369
                
 
370
                    if optname not in cmd_options:
 
371
                        raise BzrOptionError('unknown short option %r for'
 
372
                                             ' command %s' % 
 
373
                                             (shortopt, command.name()))
 
374
                if optname in opts:
 
375
                    # XXX: Do we ever want to support this, e.g. for -r?
 
376
                    if proc_aliasarg:
 
377
                        raise BzrError('repeated option %r' % a)
 
378
                    elif optname in alias_opts:
 
379
                        # Replace what's in the alias with what's in the real
 
380
                        # argument
 
381
                        del alias_opts[optname]
 
382
                        del opts[optname]
 
383
                        proc_argv.insert(0, a)
 
384
                        continue
 
385
                    else:
 
386
                        raise BzrError('repeated option %r' % a)
 
387
                    
 
388
                option_obj = cmd_options[optname]
 
389
                optargfn = option_obj.type
 
390
                if optargfn:
 
391
                    if optarg == None:
 
392
                        if not proc_argv:
 
393
                            raise BzrError('option %r needs an argument' % a)
334
394
                        else:
335
 
                            # This option takes an argument, so pack it
336
 
                            # into the array
337
 
                            optarg = a[2:]
338
 
            
339
 
            if optname in opts:
340
 
                # XXX: Do we ever want to support this, e.g. for -r?
341
 
                raise BzrError('repeated option %r' % a)
342
 
                
343
 
            option_obj = cmd_options[optname]
344
 
            optargfn = option_obj.type
345
 
            if optargfn:
346
 
                if optarg == None:
347
 
                    if not argv:
348
 
                        raise BzrError('option %r needs an argument' % a)
349
 
                    else:
350
 
                        optarg = argv.pop(0)
351
 
                opts[optname] = optargfn(optarg)
 
395
                            optarg = proc_argv.pop(0)
 
396
                    opts[optname] = optargfn(optarg)
 
397
                    if proc_aliasarg:
 
398
                        alias_opts[optname] = optargfn(optarg)
 
399
                else:
 
400
                    if optarg != None:
 
401
                        raise BzrError('option %r takes no argument' % optname)
 
402
                    opts[optname] = True
 
403
                    if proc_aliasarg:
 
404
                        alias_opts[optname] = True
352
405
            else:
353
 
                if optarg != None:
354
 
                    raise BzrError('option %r takes no argument' % optname)
355
 
                opts[optname] = True
356
 
        else:
357
 
            args.append(a)
 
406
                args.append(a)
 
407
        proc_aliasarg = False # Done with alias argv
358
408
    return args, opts
359
409
 
360
410
 
426
476
        os.remove(pfname)
427
477
 
428
478
 
 
479
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
 
480
    from bzrlib.lsprof import profile
 
481
    import cPickle
 
482
    ret, stats = profile(the_callable, *args, **kwargs)
 
483
    stats.sort()
 
484
    if filename is None:
 
485
        stats.pprint()
 
486
    else:
 
487
        stats.freeze()
 
488
        cPickle.dump(stats, open(filename, 'w'), 2)
 
489
        print 'Profile data written to %r.' % filename
 
490
    return ret
 
491
 
 
492
 
 
493
def get_alias(cmd):
 
494
    """Return an expanded alias, or None if no alias exists"""
 
495
    import bzrlib.config
 
496
    alias = bzrlib.config.GlobalConfig().get_alias(cmd)
 
497
    if (alias):
 
498
        return alias.split(' ')
 
499
    return None
 
500
 
 
501
 
429
502
def run_bzr(argv):
430
503
    """Execute a command.
431
504
 
443
516
    --no-plugins
444
517
        Do not load plugin modules at all
445
518
 
 
519
    --no-aliases
 
520
        Do not allow aliases
 
521
 
446
522
    --builtin
447
523
        Only use builtin commands.  (Plugins are still allowed to change
448
524
        other behaviour.)
449
525
 
450
526
    --profile
451
 
        Run under the Python profiler.
 
527
        Run under the Python hotshot profiler.
 
528
 
 
529
    --lsprof
 
530
        Run under the Python lsprof profiler.
452
531
    """
453
532
    argv = [a.decode(bzrlib.user_encoding) for a in argv]
454
533
 
455
 
    opt_profile = opt_no_plugins = opt_builtin = False
 
534
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
 
535
                opt_no_aliases = False
 
536
    opt_lsprof_file = None
456
537
 
457
538
    # --no-plugins is handled specially at a very early stage. We need
458
539
    # to load plugins before doing other command parsing so that they
459
540
    # can override commands, but this needs to happen first.
460
541
 
461
 
    for a in argv:
 
542
    argv_copy = []
 
543
    i = 0
 
544
    while i < len(argv):
 
545
        a = argv[i]
462
546
        if a == '--profile':
463
547
            opt_profile = True
 
548
        elif a == '--lsprof':
 
549
            opt_lsprof = True
 
550
        elif a == '--lsprof-file':
 
551
            opt_lsprof_file = argv[i + 1]
 
552
            i += 1
464
553
        elif a == '--no-plugins':
465
554
            opt_no_plugins = True
 
555
        elif a == '--no-aliases':
 
556
            opt_no_aliases = True
466
557
        elif a == '--builtin':
467
558
            opt_builtin = True
 
559
        elif a in ('--quiet', '-q'):
 
560
            be_quiet()
468
561
        else:
469
 
            break
470
 
        argv.remove(a)
 
562
            argv_copy.append(a)
 
563
        i += 1
471
564
 
 
565
    argv = argv_copy
472
566
    if (not argv) or (argv[0] == '--help'):
473
567
        from bzrlib.help import help
474
568
        if len(argv) > 1:
485
579
    if not opt_no_plugins:
486
580
        from bzrlib.plugin import load_plugins
487
581
        load_plugins()
 
582
    else:
 
583
        from bzrlib.plugin import disable_plugins
 
584
        disable_plugins()
 
585
 
 
586
    alias_argv = None
 
587
 
 
588
    if not opt_no_aliases:
 
589
        alias_argv = get_alias(argv[0])
 
590
        if alias_argv:
 
591
            alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
 
592
            argv[0] = alias_argv.pop(0)
488
593
 
489
594
    cmd = str(argv.pop(0))
490
595
 
491
596
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
492
 
 
493
 
    if opt_profile:
494
 
        ret = apply_profiled(cmd_obj.run_argv, argv)
 
597
    if not getattr(cmd_obj.run_argv, 'is_deprecated', False):
 
598
        run = cmd_obj.run_argv
 
599
        run_argv = [argv]
495
600
    else:
496
 
        ret = cmd_obj.run_argv(argv)
497
 
    return ret or 0
 
601
        run = cmd_obj.run_argv_aliases
 
602
        run_argv = [argv, alias_argv]
 
603
 
 
604
    try:
 
605
        if opt_lsprof:
 
606
            ret = apply_lsprofiled(opt_lsprof_file, run, *run_argv)
 
607
        elif opt_profile:
 
608
            ret = apply_profiled(run, *run_argv)
 
609
        else:
 
610
            ret = run(*run_argv)
 
611
        return ret or 0
 
612
    finally:
 
613
        # reset, in case we may do other commands later within the same process
 
614
        be_quiet(False)
 
615
 
 
616
def display_command(func):
 
617
    """Decorator that suppresses pipe/interrupt errors."""
 
618
    def ignore_pipe(*args, **kwargs):
 
619
        try:
 
620
            result = func(*args, **kwargs)
 
621
            sys.stdout.flush()
 
622
            return result
 
623
        except IOError, e:
 
624
            if not hasattr(e, 'errno'):
 
625
                raise
 
626
            if e.errno != errno.EPIPE:
 
627
                raise
 
628
            pass
 
629
        except KeyboardInterrupt:
 
630
            pass
 
631
    return ignore_pipe
498
632
 
499
633
 
500
634
def main(argv):
501
635
    import bzrlib.ui
 
636
    from bzrlib.ui.text import TextUIFactory
 
637
    ## bzrlib.trace.enable_default_logging()
502
638
    bzrlib.trace.log_startup(argv)
503
 
    bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
504
 
 
505
 
    return run_bzr_catch_errors(argv[1:])
 
639
    bzrlib.ui.ui_factory = TextUIFactory()
 
640
    ret = run_bzr_catch_errors(argv[1:])
 
641
    mutter("return code %d", ret)
 
642
    return ret
506
643
 
507
644
 
508
645
def run_bzr_catch_errors(argv):
512
649
        finally:
513
650
            # do this here inside the exception wrappers to catch EPIPE
514
651
            sys.stdout.flush()
515
 
    except BzrCommandError, e:
516
 
        # command line syntax error, etc
517
 
        log_error(str(e))
518
 
        return 1
519
 
    except BzrError, e:
520
 
        bzrlib.trace.log_exception()
521
 
        return 1
522
 
    except AssertionError, e:
523
 
        bzrlib.trace.log_exception('assertion failed: ' + str(e))
524
 
        return 3
525
 
    except KeyboardInterrupt, e:
526
 
        bzrlib.trace.log_exception('interrupted')
527
 
        return 2
528
652
    except Exception, e:
 
653
        # used to handle AssertionError and KeyboardInterrupt
 
654
        # specially here, but hopefully they're handled ok by the logger now
529
655
        import errno
530
656
        if (isinstance(e, IOError) 
531
657
            and hasattr(e, 'errno')
532
658
            and e.errno == errno.EPIPE):
533
659
            bzrlib.trace.note('broken pipe')
534
 
            return 2
 
660
            return 3
535
661
        else:
536
 
            ## import pdb
537
 
            ## pdb.pm()
538
662
            bzrlib.trace.log_exception()
539
 
            return 2
 
663
            if os.environ.get('BZR_PDB'):
 
664
                print '**** entering debugger'
 
665
                import pdb
 
666
                pdb.post_mortem(sys.exc_traceback)
 
667
            return 3
540
668
 
541
669
if __name__ == '__main__':
542
670
    sys.exit(main(sys.argv))