Merge lp:~mwhudson/launchpad/no-hosted-area-fix-branch-distro into lp:launchpad

[Michael Hudson-Doyle]

Hi Tim,

This branch fixes the branch-distro.py script to work without the hosted/mirror split. It's quite a bit simpler -- a shame that we're not quite going to get this landed in time to use it for opening maverick! Oh well.

Cheers,
mwh

[Tim Penhey (thumper)]

Looks good.

review: Approve

=== modified file 'lib/lp/code/model/branch.py'
--- lib/lp/code/model/branch.py	2010-04-27 02:13:58 +0000
+++ lib/lp/code/model/branch.py	2010-04-27 02:14:19 +0000
@@ -873,10 +873,6 @@
             # another RCS system such as CVS.
             prefix = config.launchpad.bzr_imports_root_url
             return urlappend(prefix, '%08x' % self.id)
-        elif self.branch_type == BranchType.HOSTED:
-            # This is a push branch, hosted on Launchpad (pushed there by
-            # users via sftp or bzr+ssh).
-            return 'lp-hosted:///%s' % (self.unique_name,)
         else:
             raise AssertionError("No pull URL for %r" % (self,))
 
 
=== modified file 'lib/lp/code/model/tests/test_branch.py'
--- lib/lp/code/model/tests/test_branch.py	2010-04-27 02:13:58 +0000
+++ lib/lp/code/model/tests/test_branch.py	2010-04-27 02:14:19 +0000
@@ -260,12 +260,6 @@
 
     layer = DatabaseFunctionalLayer
 
-    def test_pullURLHosted(self):
-        # Hosted branches are pulled from internal Launchpad URLs.
-        branch = self.factory.makeAnyBranch(branch_type=BranchType.HOSTED)
-        self.assertEqual(
-            'lp-hosted:///%s' % branch.unique_name, branch.getPullURL())
-
     def test_pullURLMirrored(self):
         # Mirrored branches are pulled from their actual URLs -- that's the
         # point.
 
=== modified file 'lib/lp/codehosting/branchdistro.py'
--- lib/lp/codehosting/branchdistro.py	2009-10-26 22:37:15 +0000
+++ lib/lp/codehosting/branchdistro.py	2010-04-27 02:14:19 +0000
@@ -21,8 +21,6 @@
 from bzrlib.bzrdir import BzrDir
 from bzrlib.errors import NotBranchError, NotStacked
 
-from lazr.uri import URI
-
 import transaction
 
 from zope.component import getUtility
@@ -79,12 +77,9 @@
     # location so that it works to set the stacked on url to '/' + a
     # unique_name.
     new_location_bzrdir = BzrDir.open(
-        str(URI(
-            scheme=scheme, host='', path='/' + new_db_branch.unique_name)))
+        scheme + ':///' + new_db_branch.unique_name)
     old_location_bzrdir = new_location_bzrdir.clone(
-        str(URI(
-            scheme=scheme, host='', path='/' + old_db_branch.unique_name)),
-        revision_id='null:')
+        scheme + ':///' + old_db_branch.unique_name, revision_id='null:')
 
     # Set the stacked on url for old location.
     old_location_branch = old_location_bzrdir.open_branch()
@@ -207,8 +202,7 @@
 
         This function checks that every official package branch in the old
         distroseries has a matching branch in the new distroseries and that
-        stacking is set up as we expect in both the hosted and mirrored areas
-        on disk.
+        stacking is set up as we expect on disk.
 
         Every branch will be checked, even if some fail.
 
@@ -234,8 +228,7 @@
         """Check a branch in the old distroseries has been copied to the new.
 
         This function checks that `old_db_branch` has a matching branch in the
-        new distroseries and that stacking is set up as we expect in both the
-        hosted and mirrored areas on disk.
+        new distroseries and that stacking is set up as we expect on disk.
 
         This function simply returns True or False -- any problems will be
         logged to ``self.logger``.
@@ -258,71 +251,67 @@
         ok = self.checkConsistentOfficialPackageBranch(new_db_branch)
         if not ok:
             return ok
-        # for both mirrored and hosted areas:
-        for scheme in 'lp-mirrored', 'lp-hosted':
-            # the branch in the new distroseries is unstacked
-            new_location = str(URI(
-                scheme=scheme, host='', path='/' + new_db_branch.unique_name))
-            try:
-                new_bzr_branch = Branch.open(new_location)
-            except NotBranchError:
-                self.logger.warning(
-                    "No bzr branch at new location %s", new_location)
-                ok = False
-            else:
-                try:
-                    new_stacked_on_url = new_bzr_branch.get_stacked_on_url()
-                    ok = False
-                    self.logger.warning(
-                        "New branch at %s is stacked on %s, should be "
-                        "unstacked.", new_location, new_stacked_on_url)
-                except NotStacked:
-                    pass
-            # The branch in the old distroseries is stacked on that in the
-            # new.
-            old_location = str(URI(
-                scheme=scheme, host='', path='/' + old_db_branch.unique_name))
-            try:
-                old_bzr_branch = Branch.open(old_location)
-            except NotBranchError:
-                self.logger.warning(
-                    "No bzr branch at old location %s", old_location)
-                ok = False
-            else:
-                try:
-                    old_stacked_on_url = old_bzr_branch.get_stacked_on_url()
-                    if old_stacked_on_url != '/' + new_db_branch.unique_name:
-                        self.logger.warning(
-                            "Old branch at %s is stacked on %s, should be "
-                            "stacked on %s", old_location, old_stacked_on_url,
-                            '/' + new_db_branch.unique_name)
-                        ok = False
-                except NotStacked:
-                    self.logger.warning(
-                        "Old branch at %s is not stacked, should be stacked "
-                        "on %s", old_location,
+        # the branch in the new distroseries is unstacked
+        new_location = 'lp-internal:///' + new_db_branch.unique_name
+        try:
+            new_bzr_branch = Branch.open(new_location)
+        except NotBranchError:
+            self.logger.warning(
+                "No bzr branch at new location %s", new_location)
+            ok = False
+        else:
+            try:
+                new_stacked_on_url = new_bzr_branch.get_stacked_on_url()
+                ok = False
+                self.logger.warning(
+                    "New branch at %s is stacked on %s, should be "
+                    "unstacked.", new_location, new_stacked_on_url)
+            except NotStacked:
+                pass
+        # The branch in the old distroseries is stacked on that in the
+        # new.
+        old_location = 'lp-internal:///' + old_db_branch.unique_name
+        try:
+            old_bzr_branch = Branch.open(old_location)
+        except NotBranchError:
+            self.logger.warning(
+                "No bzr branch at old location %s", old_location)
+            ok = False
+        else:
+            try:
+                old_stacked_on_url = old_bzr_branch.get_stacked_on_url()
+                if old_stacked_on_url != '/' + new_db_branch.unique_name:
+                    self.logger.warning(
+                        "Old branch at %s is stacked on %s, should be "
+                        "stacked on %s", old_location, old_stacked_on_url,
                         '/' + new_db_branch.unique_name)
                     ok = False
-                # The branch in the old distroseries has no revisions in its
-                # repository.  We open the repository independently of the
-                # branch because the branch's repository has had its fallback
-                # location activated. Note that this check might fail if new
-                # revisions get pushed to the branch in the old distroseries,
-                # which shouldn't happen but isn't totally impossible.
-                old_repo = BzrDir.open(old_location).open_repository()
-                if len(old_repo.all_revision_ids()) > 0:
-                    self.logger.warning(
-                        "Repository at %s has %s revisions.",
-                        old_location, len(old_repo.all_revision_ids()))
-                    ok = False
-                # The branch in the old distroseries has at least some
-                # history.  (We can't check that the tips are the same because
-                # the branch in the new distroseries might have new revisons).
-                if old_bzr_branch.last_revision() == 'null:':
-                    self.logger.warning(
-                        "Old branch at %s has null tip revision.",
-                        old_location)
-                    ok = False
+            except NotStacked:
+                self.logger.warning(
+                    "Old branch at %s is not stacked, should be stacked "
+                    "on %s", old_location,
+                    '/' + new_db_branch.unique_name)
+                ok = False
+            # The branch in the old distroseries has no revisions in its
+            # repository.  We open the repository independently of the
+            # branch because the branch's repository has had its fallback
+            # location activated. Note that this check might fail if new
+            # revisions get pushed to the branch in the old distroseries,
+            # which shouldn't happen but isn't totally impossible.
+            old_repo = BzrDir.open(old_location).open_repository()
+            if len(old_repo.all_revision_ids()) > 0:
+                self.logger.warning(
+                    "Repository at %s has %s revisions.",
+                    old_location, len(old_repo.all_revision_ids()))
+                ok = False
+            # The branch in the old distroseries has at least some
+            # history.  (We can't check that the tips are the same because
+            # the branch in the new distroseries might have new revisons).
+            if old_bzr_branch.last_revision() == 'null:':
+                self.logger.warning(
+                    "Old branch at %s has null tip revision.",
+                    old_location)
+                ok = False
         return ok
 
     def makeOneNewBranch(self, old_db_branch):
@@ -357,9 +346,6 @@
         # again.  So commit before doing that.
         transaction.commit()
         switch_branches(
-            config.codehosting.hosted_branches_root,
-            'lp-hosted', old_db_branch, new_db_branch)
-        switch_branches(
             config.codehosting.mirrored_branches_root,
-            'lp-mirrored', old_db_branch, new_db_branch)
+            'lp-internal', old_db_branch, new_db_branch)
         return new_db_branch
 
=== modified file 'lib/lp/codehosting/tests/test_branchdistro.py'
--- lib/lp/codehosting/tests/test_branchdistro.py	2010-01-20 23:10:44 +0000
+++ lib/lp/codehosting/tests/test_branchdistro.py	2010-04-27 02:14:19 +0000
@@ -118,12 +118,8 @@
         transaction.commit()
 
         _, tree = self.create_branch_and_tree(
-            tree_location=self.factory.getUniqueString(), db_branch=db_branch,
-            hosted=True)
+            tree_location=self.factory.getUniqueString(), db_branch=db_branch)
         tree.commit('')
-        mirrored_branch = BzrDir.create_branch_convenience(
-            db_branch.warehouse_url)
-        mirrored_branch.pull(tree.branch)
 
         return db_branch
 
@@ -396,229 +392,123 @@
             ['^WARNING .*/.*/.* is the official branch for .*/.*/.* but not '
              'its sourcepackage$'])
 
-    def checkOneBranch_new_branch_missing(self, branch_type):
+    def test_checkOneBranch_new_branch_missing(self):
         # checkOneBranch returns False when there is no bzr branch for the
         # database branch in the new distroseries.
-        assert branch_type in ('hosted', 'mirrored')
         db_branch = self.makeOfficialPackageBranch()
         brancher = self.makeNewSeriesAndBrancher(db_branch.distroseries)
         new_db_branch = brancher.makeOneNewBranch(db_branch)
-        if branch_type == 'hosted':
-            url = new_db_branch.getPullURL()
-        else:
-            url = new_db_branch.warehouse_url
+        url = 'lp-internal:///' + new_db_branch.unique_name
         get_transport(url).delete_tree('.bzr')
         ok = brancher.checkOneBranch(db_branch)
         self.assertFalse(ok)
         # Deleting the new branch will break the old branch, as that's stacked
         # on the new one.
         self.assertLogMessages([
-            '^WARNING No bzr branch at new location lp-%s:///.*/.*/.*/.*$'
-            % branch_type,
-            '^WARNING No bzr branch at old location lp-%s:///.*/.*/.*/.*$'
-            % branch_type,
+            '^WARNING No bzr branch at new location '
+            'lp-internal:///.*/.*/.*/.*$',
+            '^WARNING No bzr branch at old location '
+            'lp-internal:///.*/.*/.*/.*$',
             ])
 
-    def test_checkOneBranch_new_hosted_branch_missing(self):
-        # checkOneBranch returns False when there is no bzr branch in the
-        # hosted area for the database branch in the new distroseries.
-        self.checkOneBranch_new_branch_missing('hosted')
-
-    def test_checkOneBranch_new_mirrored_branch_missing(self):
-        # checkOneBranch returns False when there is no bzr branch in the
-        # mirrored area for the database branch in the new distroseries.
-        self.checkOneBranch_new_branch_missing('mirrored')
-
-    def checkOneBranch_old_branch_missing(self, branch_type):
+    def test_checkOneBranch_old_branch_missing(self):
         # checkOneBranch returns False when there is no bzr branchfor the
         # database branch in old distroseries.
-        assert branch_type in ('hosted', 'mirrored')
         db_branch = self.makeOfficialPackageBranch()
         brancher = self.makeNewSeriesAndBrancher(db_branch.distroseries)
         brancher.makeOneNewBranch(db_branch)
-        if branch_type == 'hosted':
-            url = db_branch.getPullURL()
-        else:
-            url = db_branch.warehouse_url
+        url = 'lp-internal:///' + db_branch.unique_name
         get_transport(url).delete_tree('.bzr')
         ok = brancher.checkOneBranch(db_branch)
         self.assertFalse(ok)
         self.assertLogMessages([
-            '^WARNING No bzr branch at old location lp-%s:///.*/.*/.*/.*$'
-            % branch_type,
+            '^WARNING No bzr branch at old location '
+            'lp-internal:///.*/.*/.*/.*$'
             ])
 
-    def test_checkOneBranch_old_hosted_branch_missing(self):
-        # checkOneBranch returns False when there is no bzr branch in the
-        # hosted area for the database branch in old distroseries.
-        self.checkOneBranch_old_branch_missing('hosted')
-
-    def test_checkOneBranch_old_mirrored_branch_missing(self):
-        # checkOneBranch returns False when there is no bzr branch in the
-        # mirrored area for the database branch in old distroseries.
-        self.checkOneBranch_old_branch_missing('mirrored')
-
-    def checkOneBranch_new_stacked(self, branch_type):
+    def test_checkOneBranch_new_stacked(self):
         # checkOneBranch returns False when the bzr branch for the database
         # branch in new distroseries is stacked.
-        assert branch_type in ('hosted', 'mirrored')
         db_branch = self.makeOfficialPackageBranch()
-        b, _ = self.create_branch_and_tree(
-            self.factory.getUniqueString(), hosted=(branch_type == 'hosted'))
+        b, _ = self.create_branch_and_tree(self.factory.getUniqueString())
         brancher = self.makeNewSeriesAndBrancher(db_branch.distroseries)
         new_db_branch = brancher.makeOneNewBranch(db_branch)
-        if branch_type == 'hosted':
-            url = new_db_branch.getPullURL()
-        else:
-            url = new_db_branch.warehouse_url
+        url = 'lp-internal:///' + new_db_branch.unique_name
         Branch.open(url).set_stacked_on_url('/' + b.unique_name)
         ok = brancher.checkOneBranch(db_branch)
         self.assertFalse(ok)
         self.assertLogMessages([
-            '^WARNING New branch at lp-%s:///.*/.*/.*/.* is stacked on '
-            '/.*/.*/.*, should be unstacked.$' % branch_type,
+            '^WARNING New branch at lp-internal:///.*/.*/.*/.* is stacked on '
+            '/.*/.*/.*, should be unstacked.$',
             ])
 
-    def test_checkOneBranch_new_hosted_stacked(self):
-        # checkOneBranch returns False when the bzr branch in the hosted area
-        # for the database branch in new distroseries is stacked.
-        self.checkOneBranch_new_stacked('hosted')
-
-    def test_checkOneBranch_new_mirrored_stacked(self):
-        # checkOneBranch returns False when the bzr branch in the mirrored
-        # area for the database branch in new distroseries is stacked.
-        self.checkOneBranch_new_stacked('mirrored')
-
-    def checkOneBranch_old_unstacked(self, branch_type):
+    def test_checkOneBranch_old_unstacked(self):
         # checkOneBranch returns False when the bzr branch for the database
         # branch in old distroseries is not stacked.
-        assert branch_type in ('hosted', 'mirrored')
         db_branch = self.makeOfficialPackageBranch()
         brancher = self.makeNewSeriesAndBrancher(db_branch.distroseries)
         brancher.makeOneNewBranch(db_branch)
-        if branch_type == 'hosted':
-            url = db_branch.getPullURL()
-        else:
-            url = db_branch.warehouse_url
+        url = 'lp-internal:///' + db_branch.unique_name
         old_bzr_branch = Branch.open(url)
         old_bzr_branch.set_stacked_on_url(None)
         ok = brancher.checkOneBranch(db_branch)
         self.assertLogMessages([
-            '^WARNING Old branch at lp-%s:///.*/.*/.*/.* is not stacked, '
-            'should be stacked on /.*/.*/.*.$' % branch_type,
+            '^WARNING Old branch at lp-internal:///.*/.*/.*/.* is not '
+            'stacked, should be stacked on /.*/.*/.*.$',
             '^.*has .* revisions.*$',
             ])
         self.assertFalse(ok)
 
-    def test_checkOneBranch_old_hosted_unstacked(self):
-        # checkOneBranch returns False when the bzr branch in the hosted area
-        # for the database branch in old distroseries is not stacked.
-        self.checkOneBranch_old_unstacked('hosted')
-
-    def test_checkOneBranch_old_mirrored_unstacked(self):
-        # checkOneBranch returns False when the bzr branch in the mirrored
-        # area for the database branch in old distroseries is not stacked.
-        self.checkOneBranch_old_unstacked('mirrored')
-
-    def checkOneBranch_old_misstacked(self, branch_type):
+    def test_checkOneBranch_old_misstacked(self):
         # checkOneBranch returns False when the bzr branch for the database
         # branch in old distroseries stacked on some other branch than the
         # branch in the new distroseries.
-        assert branch_type in ('hosted', 'mirrored')
         db_branch = self.makeOfficialPackageBranch()
-        b, _ = self.create_branch_and_tree(
-            self.factory.getUniqueString(), hosted=(branch_type == 'hosted'))
+        b, _ = self.create_branch_and_tree(self.factory.getUniqueString())
         brancher = self.makeNewSeriesAndBrancher(db_branch.distroseries)
         brancher.makeOneNewBranch(db_branch)
-        if branch_type == 'hosted':
-            url = db_branch.getPullURL()
-        else:
-            url = db_branch.warehouse_url
+        url = 'lp-internal:///' + db_branch.unique_name
         Branch.open(url).set_stacked_on_url('/' + b.unique_name)
         ok = brancher.checkOneBranch(db_branch)
         self.assertLogMessages([
-            '^WARNING Old branch at lp-%s:///.*/.*/.*/.* is stacked on '
-            '/.*/.*/.*, should be stacked on /.*/.*/.*.$' % branch_type,
+            '^WARNING Old branch at lp-internal:///.*/.*/.*/.* is stacked on '
+            '/.*/.*/.*, should be stacked on /.*/.*/.*.$',
             ])
         self.assertFalse(ok)
 
-    def test_checkOneBranch_old_hosted_misstacked(self):
-        # checkOneBranch returns False when the bzr branch in the hosted area
-        # for the database branch in old distroseries stacked on some other
-        # branch than the branch in the new distroseries.
-        self.checkOneBranch_old_misstacked('hosted')
-
-    def test_checkOneBranch_old_mirrored_misstacked(self):
-        # checkOneBranch returns False when the bzr branch in the mirrored
-        # area for the database branch in old distroseries stacked on some
-        # other branch than the branch in the new distroseries.
-        self.checkOneBranch_old_misstacked('mirrored')
-
-    def checkOneBranch_old_has_revisions(self, branch_type):
+    def test_checkOneBranch_old_has_revisions(self):
         # checkOneBranch returns False when the bzr branch for the database
         # branch in old distroseries has a repository that contains revisions.
-        assert branch_type in ('hosted', 'mirrored')
         db_branch = self.makeOfficialPackageBranch()
         brancher = self.makeNewSeriesAndBrancher(db_branch.distroseries)
         brancher.makeOneNewBranch(db_branch)
-        if branch_type == 'hosted':
-            url = db_branch.getPullURL()
-        else:
-            url = db_branch.warehouse_url
+        url = 'lp-internal:///' + db_branch.unique_name
         old_bzr_branch = Branch.open(url)
         old_bzr_branch.create_checkout(
             self.factory.getUniqueString()).commit('')
         ok = brancher.checkOneBranch(db_branch)
         self.assertLogMessages([
-            '^WARNING Repository at lp-%s:///.*/.*/.*/.* has 1 revisions.'
-            % branch_type
+            '^WARNING Repository at lp-internal:///.*/.*/.*/.* has 1 '
+            'revisions.'
             ])
         self.assertFalse(ok)
 
-    def test_checkOneBranch_old_hosted_has_revisions(self):
-        # checkOneBranch returns False when the bzr branch in the hosted area
-        # for the database branch in old distroseries has a repository that
-        # contains revisions.
-        self.checkOneBranch_old_has_revisions('hosted')
-
-    def test_checkOneBranch_old_mirrored_has_revisions(self):
-        # checkOneBranch returns False when the bzr branch in the mirrored
-        # area for the database branch in old distroseries has a repository
-        # that contains revisions.
-        self.checkOneBranch_old_has_revisions('mirrored')
-
-    def checkOneBranch_old_has_null_tip(self, branch_type):
+    def test_checkOneBranch_old_has_null_tip(self):
         # checkOneBranch returns False when the bzr branch for the database
         # branch in old distroseries has tip revision of 'null:'.
-        assert branch_type in ('hosted', 'mirrored')
         db_branch = self.makeOfficialPackageBranch()
         brancher = self.makeNewSeriesAndBrancher(db_branch.distroseries)
         brancher.makeOneNewBranch(db_branch)
-        if branch_type == 'hosted':
-            url = db_branch.getPullURL()
-        else:
-            url = db_branch.warehouse_url
+        url = 'lp-internal:///' + db_branch.unique_name
         old_bzr_branch = Branch.open(url)
         old_bzr_branch.set_last_revision_info(0, 'null:')
         ok = brancher.checkOneBranch(db_branch)
         self.assertLogMessages([
-            '^WARNING Old branch at lp-%s:///.*/.*/.*/.* has null tip '
-            'revision.' % branch_type
+            '^WARNING Old branch at lp-internal:///.*/.*/.*/.* has null tip '
+            'revision.'
             ])
         self.assertFalse(ok)
 
-    def test_checkOneBranch_old_hosted_has_null_tip(self):
-        # checkOneBranch returns False when the bzr branch in the hosted area
-        # for the database branch in old distroseries has tip revision of
-        # 'null:'.
-        self.checkOneBranch_old_has_null_tip('hosted')
-
-    def test_checkOneBranch_old_mirrored_has_null_tip(self):
-        # checkOneBranch returns False when the bzr branch in the mirrored
-        # area for the database branch in old distroseries has tip revision of
-        # 'null:'.
-        self.checkOneBranch_old_has_null_tip('mirrored')
-
     def runBranchDistroScript(self, args):
         """Run the branch-distro.py script with the given arguments.
 
 
=== modified file 'lib/lp/codehosting/vfs/branchfs.py'
--- lib/lp/codehosting/vfs/branchfs.py	2010-04-27 02:13:58 +0000
+++ lib/lp/codehosting/vfs/branchfs.py	2010-04-27 02:14:19 +0000
@@ -177,18 +177,25 @@
         'lp-mirrored:///', codehosting_endpoint, branch_transport)
 
 
-def get_rw_server():
+def get_rw_server(direct_database=False):
     """Get a server that can write to the Launchpad branch vfs.
 
     You can only call this usefully on the codehost -- the transport this
     server provides are backed onto file:/// URLs.
+
+    :param direct_database: if True, use a server implementation that talks
+        directly to the database.  If False, the default, use a server
+        implementation that talks to the internal XML-RPC server.
     """
-    hosted_transport = get_chrooted_transport(
+    transport = get_chrooted_transport(
         config.codehosting.mirrored_branches_root, mkdir=True)
-    proxy = xmlrpclib.ServerProxy(config.codehosting.codehosting_endpoint)
-    codehosting_endpoint = BlockingProxy(proxy)
-    return LaunchpadInternalServer(
-        'lp-internal:///', codehosting_endpoint, hosted_transport)
+    if direct_database:
+        return DirectDatabaseLaunchpadServer('lp-internal:///', transport)
+    else:
+        proxy = xmlrpclib.ServerProxy(config.codehosting.codehosting_endpoint)
+        codehosting_endpoint = BlockingProxy(proxy)
+        return LaunchpadInternalServer(
+            'lp-internal:///', codehosting_endpoint, transport)
 
 
 def get_multi_server(write_hosted=False, write_mirrored=False,
 
=== modified file 'lib/lp/testing/__init__.py'
--- lib/lp/testing/__init__.py	2010-04-24 02:41:03 +0000
+++ lib/lp/testing/__init__.py	2010-04-27 02:14:19 +0000
@@ -84,7 +84,7 @@
 from canonical.launchpad.webapp.interaction import ANONYMOUS
 from canonical.launchpad.webapp.interfaces import ILaunchBag
 from canonical.launchpad.windmill.testing import constants
-from lp.codehosting.vfs import branch_id_to_path, get_multi_server
+from lp.codehosting.vfs import branch_id_to_path, get_rw_server
 from lp.registry.interfaces.packaging import IPackagingUtil
 # Import the login and logout functions here as it is a much better
 # place to import them from in tests.
@@ -452,14 +452,12 @@
             branch_url, format=format)
 
     def create_branch_and_tree(self, tree_location=None, product=None,
-                               hosted=False, db_branch=None, format=None,
+                               db_branch=None, format=None,
                                **kwargs):
         """Create a database branch, bzr branch and bzr checkout.
 
         :param tree_location: The path on disk to create the tree at.
         :param product: The product to associate with the branch.
-        :param hosted: If True, create in the hosted area.  Otherwise, create
-            in the mirrored area.
         :param db_branch: If supplied, the database branch to use.
         :param format: Override the default bzrdir format to create.
         :return: a `Branch` and a workingtree.
@@ -469,10 +467,7 @@
                 db_branch = self.factory.makeAnyBranch(**kwargs)
             else:
                 db_branch = self.factory.makeProductBranch(product, **kwargs)
-        if hosted:
-            branch_url = db_branch.getPullURL()
-        else:
-            branch_url = db_branch.warehouse_url
+        branch_url = 'lp-internal:///' + db_branch.unique_name
         if self.real_bzr_server:
             transaction.commit()
         bzr_branch = self.createBranchAtURL(branch_url, format=format)
@@ -552,8 +547,7 @@
         self.useTempBzrHome()
         self.real_bzr_server = real_server
         if real_server:
-            server = get_multi_server(
-                write_hosted=True, write_mirrored=True,
+            server = get_rw_server(
                 direct_database=direct_database)
             server.start_server()
             self.addCleanup(server.destroy)
 
=== modified file 'scripts/branch-distro.py'
--- scripts/branch-distro.py	2010-02-16 15:25:52 +0000
+++ scripts/branch-distro.py	2010-04-27 02:14:19 +0000
@@ -6,7 +6,7 @@
 import _pythonpath
 
 from lp.codehosting.branchdistro import DistroBrancher
-from lp.codehosting.vfs import get_multi_server
+from lp.codehosting.vfs import get_rw_server
 from lp.services.scripts.base import LaunchpadScript, LaunchpadScriptFailure
 
 
@@ -24,8 +24,7 @@
         if len(self.args) != 3:
             self.parser.error("Wrong number of arguments.")
         brancher = DistroBrancher.fromNames(self.logger, *self.args)
-        server = get_multi_server(
-            write_mirrored=True, write_hosted=True, direct_database=True)
+        server = get_rw_server(direct_database=True)
         server.start_server()
         try:
             if self.options.check: