Merge lp:~spiv/bzr-loom/plugin-init into lp:bzr-loom

[Andrew Bennetts]

This branch does a couple of loosely related things:
 * makes sure InterLoomBranch is always registered, by moving its definition to formats.py. I don't think this is a great solution, but it does solve the problem. Certainly by the time formats.register.formats() has been called that InterLoomBranch ought to be installed one way or another I think. This fixes bug 617212.
 * replaces "import bzrlib.branch" etc with "from bzrlib import branch" etc, following bzrlib's own conventions in format.py and branch.py. This also makes explicit a bunch of import dependencies like bzrlib.inventory that were only implicitly imported before.
 * uses lazy_import where appropriate in format.py and branch.py (and don't use it when not helpful... register_formats is always called by __init__.py so bzrlib.branch will unavoidably be imported).

I've verified that bzr with no plugins other than loom this saves 25 open syscalls (out of ~1500, as measured with strace: BZR_PLUGIN_PATH='-user:-core:-site' BZR_PLUGINS_AT=loom@$(pwd) strace -e stat64,open -c bzr.dev st). There's no noticeable time difference on a warm system, but this does suggest it is slightly more efficient this way, or at least no worse.

[Robert Collins (lifeless)]

On Fri, Aug 13, 2010 at 7:13 PM, Andrew Bennetts
<email address hidden> wrote:
> Andrew Bennetts has proposed merging lp:~spiv/bzr-loom/plugin-init into lp:bzr-loom.
>
> Requested reviews:
>  Loom Developers (bzr-loom-devs)
> Related bugs:
>  #617212 "bzr selftest -s bt.per_interbranch Loom" finds 0 tests
>  https://bugs.launchpad.net/bugs/617212
>
>
> This branch does a couple of loosely related things:
>  * makes sure InterLoomBranch is always registered, by moving its definition to formats.py.  I don't think this is a great solution, but it does solve the problem.  Certainly by the time formats.register.formats() has been called that InterLoomBranch ought to be installed one way or another I think.  This fixes bug 617212.

Probably ok.

>  * replaces "import bzrlib.branch" etc with "from bzrlib import branch" etc, following bzrlib's own conventions in format.py and branch.py.  This also makes explicit a bunch of import dependencies like bzrlib.inventory that were only implicitly imported before.

This is going to be really confusing. Loom has its own 'branch'
module, so please don't do that. (Not to mention that I am not
convinced by the bzr convention anyhow. If you feel you must do that,
please do _mod_bzrlib_branch or something to make in unambiguous.
Personally though, import bzrlib.branch is pretty nice.

>  * uses lazy_import where appropriate in format.py and branch.py (and don't use it when not helpful... register_formats is always called by __init__.py so bzrlib.branch will unavoidably be imported).

I would keep it lazy myself, if we fix bzrlib to not load
bzrlib.branch when registering formats, it would be a shame to have to
rework this because of an arbitrary change

-Rob

Unmerged revisions

127. By Andrew Bennetts on 2010-08-13

Follow bzrlib conventions for imports, use lazy_imports in branch.py, and register InterLoomBranch in formats.py so that it is always registered for the bzr per_interbranch test suite.

=== modified file 'branch.py'
--- branch.py	2010-07-16 08:30:13 +0000
+++ branch.py	2010-08-13 07:13:40 +0000
@@ -26,17 +26,29 @@
 
 from StringIO import StringIO
 
-import bzrlib.branch
-from bzrlib import bzrdir
+from bzrlib.lazy_import import lazy_import
+lazy_import(globals(), """
+from bzrlib import (
+    bzrdir,
+    inventory,
+    lockable_files,
+    lockdir,
+    remote,
+    revision as _mod_revision,
+    symbol_versioning,
+    trace,
+    ui,
+    urlutils,
+    )
+""")
+from bzrlib import (
+    branch as _mod_branch,
+    errors,
+    tree as _mod_tree,
+    )
+
+
 from bzrlib.decorators import needs_read_lock, needs_write_lock
-import bzrlib.errors
-import bzrlib.osutils
-from bzrlib import remote, symbol_versioning
-import bzrlib.trace
-import bzrlib.ui
-from bzrlib.revision import is_null, NULL_REVISION
-import bzrlib.tree
-import bzrlib.urlutils
 
 import formats
 import loom_io
@@ -57,12 +69,12 @@
         loom.unlock()
 
 
-class AlreadyLoom(bzrlib.errors.BzrError):
+class AlreadyLoom(errors.BzrError):
 
     _fmt = """Loom %(loom)s is already a loom."""
 
     def __init__(self, loom):
-        bzrlib.errors.BzrError.__init__(self)
+        errors.BzrError.__init__(self)
         self.loom = loom
 
 
@@ -81,9 +93,9 @@
             raise AlreadyLoom(branch)
         try:
             format = {
-                bzrlib.branch.BzrBranchFormat5: BzrBranchLoomFormat1,
-                bzrlib.branch.BzrBranchFormat6: BzrBranchLoomFormat6,
-                bzrlib.branch.BzrBranchFormat7: BzrBranchLoomFormat7,
+                _mod_branch.BzrBranchFormat5: BzrBranchLoomFormat1,
+                _mod_branch.BzrBranchFormat6: BzrBranchLoomFormat6,
+                _mod_branch.BzrBranchFormat7: BzrBranchLoomFormat7,
             }[branch._format.__class__]()
         except KeyError:
             raise UnsupportedBranchFormat(branch._format)
@@ -96,26 +108,26 @@
 NotALoom = formats.NotALoom
 
 
-class LoomThreadError(bzrlib.errors.BzrError):
+class LoomThreadError(errors.BzrError):
     """Base class for Loom-Thread errors."""
 
     def __init__(self, branch, thread):
-        bzrlib.errors.BzrError.__init__(self)
+        errors.BzrError.__init__(self)
         self.branch = branch
         self.thread = thread
 
 
-class UnrecordedRevision(bzrlib.errors.BzrError):
+class UnrecordedRevision(errors.BzrError):
 
     _fmt = """The revision %(revision_id)s is not recorded in the loom %(branch)s."""
 
     def __init__(self, branch, revision_id):
-        bzrlib.errors.BzrError.__init__(self)
+        errors.BzrError.__init__(self)
         self.branch = branch
         self.revision_id = revision_id
 
 
-class UnsupportedBranchFormat(bzrlib.errors.BzrError):
+class UnsupportedBranchFormat(errors.BzrError):
 
     _fmt = """The branch format %(format)s is not supported by loomify."""
 
@@ -138,7 +150,7 @@
     _fmt = """No such thread '%(thread)s'."""
 
 
-class NoLowerThread(bzrlib.errors.BzrError):
+class NoLowerThread(errors.BzrError):
 
     _fmt = """No lower thread exists."""
 
@@ -148,7 +160,7 @@
     _fmt = """Cannot combine threads on the bottom thread."""
 
 
-class LoomMetaTree(bzrlib.tree.Tree):
+class LoomMetaTree(_mod_tree.Tree):
     """A 'tree' object that is used to commit the loom meta branch."""
 
     def __init__(self, loom_meta_ie, loom_stream, loom_sha1):
@@ -156,7 +168,7 @@
 
         :param loom_content_lines: the unicode content to be used for the loom.
         """
-        self._inventory = bzrlib.inventory.Inventory()
+        self._inventory = inventory.Inventory()
         self.inventory.add(loom_meta_ie)
         self._loom_stream = loom_stream
         self._loom_sha1 = loom_sha1
@@ -203,7 +215,7 @@
                 # all threads gone
                 # revert to being a normal branch: revert to an empty revision
                 # history.
-                self.generate_revision_history(bzrlib.revision.NULL_REVISION)
+                self.generate_revision_history(_mod_revision.NULL_REVISION)
                 return
             # TODO, calculate the offset of removed threads.
             # i.e. if there are ten threads removed, and current_index is 5, 
@@ -215,19 +227,19 @@
                 self._set_nick(threads[-1][0])
                 new_rev = threads[-1][1]
                 if new_rev == EMPTY_REVISION:
-                    new_rev = bzrlib.revision.NULL_REVISION
+                    new_rev = _mod_revision.NULL_REVISION
                 self.generate_revision_history(new_rev)
                 return
             # non-end thread removed.
             self._set_nick(threads[current_index][0])
             new_rev = threads[current_index][1]
             if new_rev == EMPTY_REVISION:
-                new_rev = bzrlib.revision.NULL_REVISION
+                new_rev = _mod_revision.NULL_REVISION
             self.generate_revision_history(new_rev)
         elif self.last_revision() != threads_dict[self.nick]:
             new_rev = threads_dict[self.nick]
             if new_rev == EMPTY_REVISION:
-                new_rev = bzrlib.revision.NULL_REVISION
+                new_rev = _mod_revision.NULL_REVISION
             self.generate_revision_history(new_rev)
 
     def bind(self, other):
@@ -237,7 +249,7 @@
         :type other: Branch
         """
         # Looms are not currently bindable.
-        raise bzrlib.errors.UpgradeRequired(self.base)
+        raise errors.UpgradeRequired(self.base)
 
     @needs_read_lock
     def clone(self, to_bzrdir, revision_id=None, repository_policy=None):
@@ -258,7 +270,7 @@
         result = format.initialize(to_bzrdir)
         if repository_policy is not None:
             repository_policy.configure_branch(result)
-        bzrlib.branch.InterBranch.get(self, result).copy_content_into(
+        _mod_branch.InterBranch.get(self, result).copy_content_into(
             revision_id=revision_id)
         return result
 
@@ -268,7 +280,7 @@
         This is a short term measure to get to an all-tests passing status.
         """
         format = self.repository.bzrdir.checkout_metadir()
-        format.set_branch_format(bzrlib.branch.BzrBranchFormat6())
+        format.set_branch_format(_mod_branch.BzrBranchFormat6())
         return format
 
     def get_loom_state(self):
@@ -282,7 +294,7 @@
     def get_old_bound_location(self):
         """Return the URL of the branch we used to be bound to."""
         # No binding for looms yet.
-        raise bzrlib.errors.UpgradeRequired(self.base)
+        raise errors.UpgradeRequired(self.base)
 
     def get_threads(self, rev_id):
         """Return the threads from a loom revision.
@@ -294,7 +306,7 @@
             symbol_versioning.warn('NULL_REVISION should be used for the null'
                 ' revision instead of None, as of bzr 0.90.',
                 DeprecationWarning, stacklevel=2)
-        if is_null(rev_id):
+        if _mod_revision.is_null(rev_id):
             return []
         content = self._loom_content(rev_id)
         return self._parse_loom(content)
@@ -308,14 +320,14 @@
         threads = self.get_loom_state().get_threads()
         for thread_name, thread_revision, _parents in threads:
             thread_transport = root_transport.clone(thread_name)
-            user_location = bzrlib.urlutils.unescape_for_display(
+            user_location = urlutils.unescape_for_display(
                 thread_transport.base, 'utf-8')
             try:
                 control_dir = bzrdir.BzrDir.open(thread_transport.base,
                     possible_transports=[thread_transport])
                 tree, branch = control_dir._get_tree_branch()
-            except bzrlib.errors.NotBranchError:
-                bzrlib.trace.note('Creating branch at %s' % user_location)
+            except errors.NotBranchError:
+                trace.note('Creating branch at %s' % user_location)
                 branch = bzrdir.BzrDir.create_branch_convenience(
                     thread_transport.base,
                     possible_transports=[thread_transport])
@@ -323,11 +335,11 @@
                     thread_transport.base)
             else:
                 if thread_revision == branch.last_revision():
-                    bzrlib.trace.note('Skipping up-to-date branch at %s'
-                                      % user_location)
+                    trace.note('Skipping up-to-date branch at %s'
+                               % user_location)
                     continue
                 else:
-                    bzrlib.trace.note('Updating branch at %s' % user_location)
+                    trace.note('Updating branch at %s' % user_location)
             if tree is not None:
                 tree.pull(self, stop_revision=thread_revision)
             else:
@@ -369,7 +381,7 @@
             revision_for_thread = self.last_revision()
         else:
             revision_for_thread = threads[insertion_point - 1][1]
-        if is_null(revision_for_thread):
+        if _mod_revision.is_null(revision_for_thread):
             revision_for_thread = EMPTY_REVISION
         threads.insert(
             insertion_point,
@@ -432,10 +444,10 @@
         threads = state.get_threads()
         # check the semantic value, not the serialised value for equality.
         if old_threads == threads:
-            raise bzrlib.errors.PointlessCommit
+            raise errors.PointlessCommit
         builder = self.get_commit_builder(parents)
-        loom_ie = bzrlib.inventory.make_entry(
-            'file', 'loom', bzrlib.inventory.ROOT_ID, 'loom_meta_tree')
+        loom_ie = inventory.make_entry(
+            'file', 'loom', inventory.ROOT_ID, 'loom_meta_tree')
         writer = loom_io.LoomWriter()
         loom_stream = StringIO()
         new_threads = [thread[0:2] for thread in threads]
@@ -443,8 +455,8 @@
         loom_stream.seek(0)
         loom_tree = LoomMetaTree(loom_ie, loom_stream, loom_sha1)
         if getattr(builder, 'record_root_entry', False):
-            root_ie = bzrlib.inventory.make_entry(
-                'directory', '', None, bzrlib.inventory.ROOT_ID)
+            root_ie = inventory.make_entry(
+                'directory', '', None, inventory.ROOT_ID)
             builder.record_entry_contents(root_ie, [], '', loom_tree,
                 ('directory', None, None, None))
         builder.record_entry_contents(
@@ -469,7 +481,7 @@
         state = self.get_loom_state()
         threads = state.get_threads()
         assert thread_name in state.get_threads_dict()
-        if is_null(revision_id):
+        if _mod_revision.is_null(revision_id):
             revision_id = EMPTY_REVISION
         for position, (name, rev, parents) in enumerate(threads):
             if name == thread_name:
@@ -555,7 +567,7 @@
             if len(threads):
                 # looms are enabled:
                 lastrev = self.last_revision()
-                if is_null(lastrev):
+                if _mod_revision.is_null(lastrev):
                     lastrev = EMPTY_REVISION
                 if dict(state.get_threads_dict())[self.nick][0] != lastrev:
                     self.record_thread(self.nick, lastrev)
@@ -604,11 +616,11 @@
 
     @staticmethod
     def make_result():
-        return bzrlib.branch.PullResult()
+        return _mod_branch.PullResult()
 
     @staticmethod
     def post_hooks():
-        return bzrlib.branch.Branch.hooks['post_pull']
+        return _mod_branch.Branch.hooks['post_pull']
 
     def plain_transfer(self, result, run_hooks, stop_revision, overwrite):
         # no thread commits ever
@@ -617,7 +629,7 @@
         if new_rev is None:
             new_rev = self.source.last_revision()
         if new_rev == EMPTY_REVISION:
-            new_rev = bzrlib.revision.NULL_REVISION
+            new_rev = _mod_revision.NULL_REVISION
         self.target.repository.fetch(self.source.repository,
             revision_id=new_rev)
         if not overwrite:
@@ -625,11 +637,10 @@
                 new_rev)
             last_rev = self.target.last_revision()
             # get_ancestry returns None for NULL_REVISION currently.
-            if last_rev == NULL_REVISION:
+            if last_rev == _mod_revision.NULL_REVISION:
                 last_rev = None
             if last_rev not in new_rev_ancestry:
-                raise bzrlib.errors.DivergedBranches(
-                    self.target, self.source)
+                raise errors.DivergedBranches(self.target, self.source)
         self.target.generate_revision_history(new_rev)
         # get the final result object details
         self.do_hooks(result, run_hooks)
@@ -639,9 +650,9 @@
         possible_transports=None, _override_hook_target=None, local=False):
         """Implementation of push and pull"""
         if local:
-            raise bzrlib.errors.LocalRequiresBoundBranch()
+            raise errors.LocalRequiresBoundBranch()
         # pull the loom, and position our
-        pb = bzrlib.ui.ui_factory.nested_progress_bar()
+        pb = ui.ui_factory.nested_progress_bar()
         try:
             result = self.prepare_result(_override_hook_target)
             self.target.lock_write()
@@ -662,7 +673,7 @@
                         source_ancestry = self.source.repository.get_ancestry(
                             source_loom_rev)
                         if my_state.get_parents()[0] not in source_ancestry:
-                            raise bzrlib.errors.DivergedBranches(
+                            raise errors.DivergedBranches(
                                 self.target, self.source)
                 # fetch the loom content
                 self.target.repository.fetch(self.source.repository,
@@ -679,7 +690,7 @@
                 # thread to include all content.
                 for rev_id in reversed(revisions):
                     if rev_id not in (EMPTY_REVISION,
-                        bzrlib.revision.NULL_REVISION):
+                        _mod_revision.NULL_REVISION):
                         # fetch the loom content for this revision
                         self.target.repository.fetch(self.source.repository,
                             revision_id=rev_id)
@@ -697,7 +708,7 @@
                 # and position the branch on the top loom
                 new_rev = threads[-1][1]
                 if new_rev == EMPTY_REVISION:
-                    new_rev = bzrlib.revision.NULL_REVISION
+                    new_rev = _mod_revision.NULL_REVISION
                 self.target.generate_revision_history(new_rev)
                 self.do_hooks(result, run_hooks)
                 return result
@@ -712,14 +723,14 @@
 
     @staticmethod
     def make_result():
-        return bzrlib.branch.BranchPushResult()
+        return _mod_branch.BranchPushResult()
 
     @staticmethod
     def post_hooks():
-        return bzrlib.branch.Branch.hooks['post_push']
-
-
-class LoomBranch(LoomSupport, bzrlib.branch.BzrBranch5):
+        return _mod_branch.Branch.hooks['post_push']
+
+
+class LoomBranch(LoomSupport, _mod_branch.BzrBranch5):
     """The Loom branch.
     
     A mixin is used as the easiest migration path to support branch6. A
@@ -727,7 +738,7 @@
     """
 
 
-class LoomBranch6(LoomSupport, bzrlib.branch.BzrBranch6):
+class LoomBranch6(LoomSupport, _mod_branch.BzrBranch6):
     """Branch6 Loom branch.
 
     A mixin is used as the easiest migration path to support branch6. A
@@ -735,7 +746,7 @@
     """
 
 
-class LoomBranch7(LoomSupport, bzrlib.branch.BzrBranch7):
+class LoomBranch7(LoomSupport, _mod_branch.BzrBranch7):
     """Branch6 Loom branch.
 
     A mixin is used as the easiest migration path to support branch7.
@@ -752,7 +763,7 @@
     def initialize(self, a_bzrdir, name=None):
         """Create a branch of this format in a_bzrdir."""
         if name is not None:
-            raise bzrlib.errors.NoColocatedBranchSupport(self)
+            raise errors.NoColocatedBranchSupport(self)
         super(LoomFormatMixin, self).initialize(a_bzrdir, name=None)
         branch_transport = a_bzrdir.get_branch_transport(self)
         files = []
@@ -762,8 +773,8 @@
         writer.write(state_stream)
         state_stream.seek(0)
         files.append(('last-loom', state_stream))
-        control_files = bzrlib.lockable_files.LockableFiles(
-            branch_transport, 'lock', bzrlib.lockdir.LockDir)
+        control_files = lockable_files.LockableFiles(
+            branch_transport, 'lock', lockdir.LockDir)
         control_files.lock_write()
         try:
             for name, stream in files:
@@ -783,13 +794,13 @@
             it is unused.
         """
         if not _found:
-            format = BranchFormat.find_format(a_bzrdir)
+            format = _mod_branch.BranchFormat.find_format(a_bzrdir)
             assert format.__class__ == self.__class__
         if name is not None:
-            raise bzrlib.errors.NoColocatedBranchSupport(self)
+            raise errors.NoColocatedBranchSupport(self)
         transport = a_bzrdir.get_branch_transport(None)
-        control_files = bzrlib.lockable_files.LockableFiles(
-            transport, 'lock', bzrlib.lockdir.LockDir)
+        control_files = lockable_files.LockableFiles(
+            transport, 'lock', lockdir.LockDir)
         return self._branch_class(_format=self,
                           _control_files=control_files,
                           a_bzrdir=a_bzrdir,
@@ -815,7 +826,7 @@
 
 
 
-class BzrBranchLoomFormat1(LoomFormatMixin, bzrlib.branch.BzrBranchFormat5):
+class BzrBranchLoomFormat1(LoomFormatMixin, _mod_branch.BzrBranchFormat5):
     """Loom's first format.
 
     This format is an extension to BzrBranchFormat5 with the following changes:
@@ -828,7 +839,7 @@
     """
 
     _branch_class = LoomBranch
-    _parent_classs = bzrlib.branch.BzrBranchFormat5
+    _parent_classs = _mod_branch.BzrBranchFormat5
 
     def get_format_string(self):
         """See BranchFormat.get_format_string()."""
@@ -842,7 +853,7 @@
         return "Bazaar-NG Loom format 1"
 
 
-class BzrBranchLoomFormat6(LoomFormatMixin, bzrlib.branch.BzrBranchFormat6):
+class BzrBranchLoomFormat6(LoomFormatMixin, _mod_branch.BzrBranchFormat6):
     """Loom's second edition - based on bzr's Branch6.
 
     This format is an extension to BzrBranchFormat6 with the following changes:
@@ -855,7 +866,7 @@
     """
 
     _branch_class = LoomBranch6
-    _parent_classs = bzrlib.branch.BzrBranchFormat6
+    _parent_classs = _mod_branch.BzrBranchFormat6
 
     def get_format_string(self):
         """See BranchFormat.get_format_string()."""
@@ -869,7 +880,7 @@
         return "bzr loom format 6 (based on bzr branch format 6)\n"
 
 
-class BzrBranchLoomFormat7(LoomFormatMixin, bzrlib.branch.BzrBranchFormat7):
+class BzrBranchLoomFormat7(LoomFormatMixin, _mod_branch.BzrBranchFormat7):
     """Loom's second edition - based on bzr's Branch7.
 
     This format is an extension to BzrBranchFormat7 with the following changes:
@@ -882,7 +893,7 @@
     """
 
     _branch_class = LoomBranch7
-    _parent_classs = bzrlib.branch.BzrBranchFormat7
+    _parent_classs = _mod_branch.BzrBranchFormat7
 
     def get_format_string(self):
         """See BranchFormat.get_format_string()."""
@@ -896,136 +907,4 @@
         return "bzr loom format 7 (based on bzr branch format 7)\n"
 
 
-# Handle the smart server:
-
-class InterLoomBranch(bzrlib.branch.GenericInterBranch):
-
-    @classmethod
-    def _get_branch_formats_to_test(klass):
-        return [
-            (bzrlib.branch.BranchFormat._default_format,
-             BzrBranchLoomFormat7()),
-            (BzrBranchLoomFormat7(),
-             bzrlib.branch.BranchFormat._default_format),
-            (BzrBranchLoomFormat7(), BzrBranchLoomFormat7()),
-            ]
-
-    def unwrap_branch(self, branch):
-        if isinstance(branch, remote.RemoteBranch):
-            branch._ensure_real()
-            return branch._real_branch
-        return branch
-
-    @classmethod
-    def is_compatible(klass, source, target):
-        # 1st cut: special case and handle all *->Loom and Loom->*
-        return klass.branch_is_loom(source) or klass.branch_is_loom(target)
-
-    def get_loom_state(self, branch):
-        branch = self.unwrap_branch(branch)
-        return branch.get_loom_state()
-
-    def get_threads(self, branch, revision_id):
-        branch = self.unwrap_branch(branch)
-        return branch.get_threads(revision_id)
-
-    @classmethod
-    def branch_is_loom(klass, branch):
-        format = klass.unwrap_format(branch._format)
-        return isinstance(format, LoomFormatMixin)
-
-    @needs_write_lock
-    def copy_content_into(self, revision_id=None):
-        if not self.__class__.branch_is_loom(self.source):
-            # target is loom, but the generic code path works Just Fine for
-            # regular to loom copy_content_into.
-            return super(InterLoomBranch, self).copy_content_into(
-                revision_id=revision_id)
-        # XXX: hint for bzrlib - break this into two routines, one for
-        # copying the last-rev pointer, one for copying parent etc.
-        source_nick = self.source.nick
-        state = self.get_loom_state(self.source)
-        parents = state.get_parents()
-        if parents:
-            loom_tip = parents[0]
-        else:
-            loom_tip = None
-        threads = self.get_threads(self.source, state.get_basis_revision_id())
-        if revision_id not in (None, NULL_REVISION):
-            if threads:
-                # revision_id should be in the loom, or its an error 
-                found_threads = [thread for thread, rev in threads
-                    if rev == revision_id]
-                if not found_threads:
-                    # the thread we have been asked to set in the remote 
-                    # side has not been recorded yet, so its data is not
-                    # present at this point.
-                    raise UnrecordedRevision(self.source, revision_id)
-
-            # pull in the warp, which was skipped during the initial pull
-            # because the front end does not know what to pull.
-            # nb: this is mega huge hacky. THINK. RBC 2006062
-            nested = bzrlib.ui.ui_factory.nested_progress_bar()
-            try:
-                if parents:
-                    self.target.repository.fetch(self.source.repository,
-                        revision_id=parents[0])
-                if threads:
-                    for thread, rev_id in reversed(threads):
-                        # fetch the loom content for this revision
-                        self.target.repository.fetch(self.source.repository,
-                            revision_id=rev_id)
-            finally:
-                nested.finished()
-        state = loom_state.LoomState()
-        try:
-            require_loom_branch(self.target)
-            if threads:
-                last_rev = threads[-1][1]
-                if last_rev == EMPTY_REVISION:
-                    last_rev = bzrlib.revision.NULL_REVISION
-                self.target.generate_revision_history(last_rev)
-                state.set_parents([loom_tip])
-                state.set_threads(
-                    (thread + ([thread[1]],) for thread in threads)
-                    )
-            else:
-                # no threads yet, be a normal branch.
-                self.source._synchronize_history(self.target, revision_id)
-            target_loom = self.unwrap_branch(self.target)
-            target_loom._set_last_loom(state)
-        except NotALoom:
-            self.source._synchronize_history(self.target, revision_id)
-        try:
-            parent = self.source.get_parent()
-        except bzrlib.errors.InaccessibleParent, e:
-            bzrlib.trace.mutter('parent was not accessible to copy: %s', e)
-        else:
-            if parent:
-                self.target.set_parent(parent)
-        if threads:
-            self.target._set_nick(threads[-1][0])
-
-    @needs_write_lock
-    def pull(self, overwrite=False, stop_revision=None,
-        run_hooks=True, possible_transports=None, _override_hook_target=None,
-        local=False):
-        """Perform a pull, reading from self.source and writing to self.target.
-
-        If the source branch is a non-loom branch, the pull is done against the
-        current warp. If it is a loom branch, then the pull is done against the
-        entire loom and the current thread set to the top thread.
-        """
-        # Special code only needed when both source and targets are looms:
-        if (self.__class__.branch_is_loom(self.target) and
-            self.__class__.branch_is_loom(self.source)):
-            return _Puller(self.source, self.target).transfer(overwrite, stop_revision,
-                run_hooks, possible_transports, _override_hook_target, local)
-        return super(InterLoomBranch, self).pull(
-            overwrite=overwrite, stop_revision=stop_revision,
-            possible_transports=possible_transports,
-            _override_hook_target=_override_hook_target, local=local,
-            run_hooks=run_hooks)
-
-
-bzrlib.branch.InterBranch.register_optimiser(InterLoomBranch)
+
 
=== modified file 'formats.py'
--- formats.py	2010-06-18 04:44:52 +0000
+++ formats.py	2010-08-13 07:13:40 +0000
@@ -27,12 +27,21 @@
     'require_loom_branch',
     ]
 
+from bzrlib import errors
+
 from bzrlib.lazy_import import lazy_import
-import bzrlib.errors
-
 lazy_import(globals(), """
+from bzrlib import (
+    remote,
+    revision as _mod_revision,
+    trace,
+    ui,
+    )
+import branch as _loom_branch
+import loom_state
+""")
 from bzrlib import branch as _mod_branch
-""")
+from bzrlib.decorators import needs_write_lock
 
 
 _LOOM_FORMATS = {
@@ -44,15 +53,14 @@
 def register_formats():
     if getattr(_mod_branch, 'MetaDirBranchFormatFactory', None):
         branch_formats = [_mod_branch.MetaDirBranchFormatFactory(format_string,
-            "bzrlib.plugins.loom.branch", format_class) for 
+            "bzrlib.plugins.loom.branch", format_class) for
             (format_string, format_class) in _LOOM_FORMATS.iteritems()]
     else:
         # Compat for folk not running bleeding edge. Like me as I commit this.
-        import branch
         branch_formats = [
-            branch.BzrBranchLoomFormat1(),
-            branch.BzrBranchLoomFormat6(),
-            branch.BzrBranchLoomFormat7(),
+            _loom_branch.BzrBranchLoomFormat1(),
+            _loom_branch.BzrBranchLoomFormat6(),
+            _loom_branch.BzrBranchLoomFormat7(),
             ]
     map(_mod_branch.BranchFormat.register_format, branch_formats)
 
@@ -64,11 +72,148 @@
 
 
 # TODO: define errors without importing all errors.
-class NotALoom(bzrlib.errors.BzrError):
+class NotALoom(errors.BzrError):
 
     _fmt = ("The branch %(branch)s is not a loom. "
         "You can use 'bzr loomify' to make it into a loom.")
 
     def __init__(self, branch):
-        bzrlib.errors.BzrError.__init__(self)
+        errors.BzrError.__init__(self)
         self.branch = branch
+
+
+class InterLoomBranch(_mod_branch.GenericInterBranch):
+    """Handle the smart server."""
+
+    @classmethod
+    def _get_branch_formats_to_test(klass):
+        return [
+            (_mod_branch.BranchFormat._default_format,
+             _loom_branch.BzrBranchLoomFormat7()),
+            (_loom_branch.BzrBranchLoomFormat7(),
+             _mod_branch.BranchFormat._default_format),
+            (_loom_branch.BzrBranchLoomFormat7(),
+             _loom_branch.BzrBranchLoomFormat7()),
+            ]
+
+    def unwrap_branch(self, branch):
+        if isinstance(branch, remote.RemoteBranch):
+            branch._ensure_real()
+            return branch._real_branch
+        return branch
+
+    @classmethod
+    def is_compatible(klass, source, target):
+        # 1st cut: special case and handle all *->Loom and Loom->*
+        return klass.branch_is_loom(source) or klass.branch_is_loom(target)
+
+    def get_loom_state(self, branch):
+        branch = self.unwrap_branch(branch)
+        return branch.get_loom_state()
+
+    def get_threads(self, branch, revision_id):
+        branch = self.unwrap_branch(branch)
+        return branch.get_threads(revision_id)
+
+    @classmethod
+    def branch_is_loom(klass, branch):
+        format = klass.unwrap_format(branch._format)
+        return isinstance(format, _loom_branch.LoomFormatMixin)
+
+    @needs_write_lock
+    def copy_content_into(self, revision_id=None):
+        if not self.__class__.branch_is_loom(self.source):
+            # target is loom, but the generic code path works Just Fine for
+            # regular to loom copy_content_into.
+            return super(InterLoomBranch, self).copy_content_into(
+                revision_id=revision_id)
+        # XXX: hint for bzrlib - break this into two routines, one for
+        # copying the last-rev pointer, one for copying parent etc.
+        source_nick = self.source.nick
+        state = self.get_loom_state(self.source)
+        parents = state.get_parents()
+        if parents:
+            loom_tip = parents[0]
+        else:
+            loom_tip = None
+        threads = self.get_threads(self.source, state.get_basis_revision_id())
+        if revision_id not in (None, _mod_revision.NULL_REVISION):
+            if threads:
+                # revision_id should be in the loom, or its an error 
+                found_threads = [thread for thread, rev in threads
+                    if rev == revision_id]
+                if not found_threads:
+                    # the thread we have been asked to set in the remote 
+                    # side has not been recorded yet, so its data is not
+                    # present at this point.
+                    raise _loom_branch.UnrecordedRevision(
+                        self.source, revision_id)
+
+            # pull in the warp, which was skipped during the initial pull
+            # because the front end does not know what to pull.
+            # nb: this is mega huge hacky. THINK. RBC 2006062
+            nested = ui.ui_factory.nested_progress_bar()
+            try:
+                if parents:
+                    self.target.repository.fetch(self.source.repository,
+                        revision_id=parents[0])
+                if threads:
+                    for thread, rev_id in reversed(threads):
+                        # fetch the loom content for this revision
+                        self.target.repository.fetch(self.source.repository,
+                            revision_id=rev_id)
+            finally:
+                nested.finished()
+        state = loom_state.LoomState()
+        try:
+            require_loom_branch(self.target)
+            if threads:
+                last_rev = threads[-1][1]
+                if last_rev == _loom_branch.EMPTY_REVISION:
+                    last_rev = _mod_revision.NULL_REVISION
+                self.target.generate_revision_history(last_rev)
+                state.set_parents([loom_tip])
+                state.set_threads(
+                    (thread + ([thread[1]],) for thread in threads)
+                    )
+            else:
+                # no threads yet, be a normal branch.
+                self.source._synchronize_history(self.target, revision_id)
+            target_loom = self.unwrap_branch(self.target)
+            target_loom._set_last_loom(state)
+        except NotALoom:
+            self.source._synchronize_history(self.target, revision_id)
+        try:
+            parent = self.source.get_parent()
+        except errors.InaccessibleParent, e:
+            trace.mutter('parent was not accessible to copy: %s', e)
+        else:
+            if parent:
+                self.target.set_parent(parent)
+        if threads:
+            self.target._set_nick(threads[-1][0])
+
+    @needs_write_lock
+    def pull(self, overwrite=False, stop_revision=None,
+        run_hooks=True, possible_transports=None, _override_hook_target=None,
+        local=False):
+        """Perform a pull, reading from self.source and writing to self.target.
+
+        If the source branch is a non-loom branch, the pull is done against the
+        current warp. If it is a loom branch, then the pull is done against the
+        entire loom and the current thread set to the top thread.
+        """
+        # Special code only needed when both source and targets are looms:
+        if (self.__class__.branch_is_loom(self.target) and
+            self.__class__.branch_is_loom(self.source)):
+            puller = _loom_branch._Puller(self.source, self.target)
+            return puller.transfer(overwrite, stop_revision,
+                run_hooks, possible_transports, _override_hook_target, local)
+        return super(InterLoomBranch, self).pull(
+            overwrite=overwrite, stop_revision=stop_revision,
+            possible_transports=possible_transports,
+            _override_hook_target=_override_hook_target, local=local,
+            run_hooks=run_hooks)
+
+
+_mod_branch.InterBranch.register_optimiser(InterLoomBranch)