← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Jelmer Vernooij
  • Date: 2010-04-30 11:35:43 UTC
  • mfrom: (5195 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5197.
  • Revision ID: jelmer@samba.org-20100430113543-tiqqhmqa3d8no4iu
merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commands.py
182
182
    import bzrlib.builtins
183
183
    for cmd_class in _scan_module_for_commands(bzrlib.builtins).values():
184
184
        builtin_command_registry.register(cmd_class)
185
 
    # lazy builtins
186
 
    builtin_command_registry.register_lazy('cmd_bundle_info',
187
 
        [],
188
 
        'bzrlib.bundle.commands')
 
185
    bzrlib.builtins._register_lazy_builtins()
189
186
 
190
187
 
191
188
def _scan_module_for_commands(module):
414
411
            warn("No help message set for %r" % self)
415
412
        # List of standard options directly supported
416
413
        self.supported_std_options = []
417
 
        self._operation = cleanup.OperationWithCleanups(self.run)
 
414
        self._setup_run()
418
415
 
419
416
    def add_cleanup(self, cleanup_func, *args, **kwargs):
420
417
        """Register a function to call after self.run returns or raises.
432
429
 
433
430
        This is useful for releasing expensive or contentious resources (such
434
431
        as write locks) before doing further work that does not require those
435
 
        resources (such as writing results to self.outf).
 
432
        resources (such as writing results to self.outf). Note though, that
 
433
        as it releases all resources, this may release locks that the command
 
434
        wants to hold, so use should be done with care.
436
435
        """
437
436
        self._operation.cleanup_now()
438
437
 
683
682
 
684
683
        self._setup_outf()
685
684
 
686
 
        return self.run_direct(**all_cmd_args)
687
 
 
 
685
        return self.run(**all_cmd_args)
 
686
 
 
687
    def _setup_run(self):
 
688
        """Wrap the defined run method on self with a cleanup.
 
689
 
 
690
        This is called by __init__ to make the Command be able to be run
 
691
        by just calling run(), as it could be before cleanups were added.
 
692
 
 
693
        If a different form of cleanups are in use by your Command subclass,
 
694
        you can override this method.
 
695
        """
 
696
        class_run = self.run
 
697
        def run(*args, **kwargs):
 
698
            self._operation = cleanup.OperationWithCleanups(class_run)
 
699
            try:
 
700
                return self._operation.run_simple(*args, **kwargs)
 
701
            finally:
 
702
                del self._operation
 
703
        self.run = run
 
704
 
 
705
    @deprecated_method(deprecated_in((2, 2, 0)))
688
706
    def run_direct(self, *args, **kwargs):
689
 
        """Call run directly with objects (without parsing an argv list)."""
690
 
        return self._operation.run_simple(*args, **kwargs)
 
707
        """Deprecated thunk from bzrlib 2.1."""
 
708
        return self.run(*args, **kwargs)
691
709
 
692
710
    def run(self):
693
711
        """Actually run the command.
698
716
        Return 0 or None if the command was successful, or a non-zero
699
717
        shell error code if not.  It's OK for this method to allow
700
718
        an exception to raise up.
 
719
 
 
720
        This method is automatically wrapped by Command.__init__ with a 
 
721
        cleanup operation, stored as self._operation. This can be used
 
722
        via self.add_cleanup to perform automatic cleanups at the end of
 
723
        run().
 
724
 
 
725
        The argument for run are assembled by introspection. So for instance,
 
726
        if your command takes an argument files, you would declare::
 
727
 
 
728
            def run(self, files=None):
 
729
                pass
701
730
        """
702
731
        raise NotImplementedError('no implementation of command %r'
703
732
                                  % self.name())