Merge lp:~jelmer/bzr-builddeb/distributionbranch-upstream-cleanup into lp:bzr-builddeb

[Jelmer Vernooij]

Clarify the meaning of upstream_branch and upstream_tree in DistributionBranch - these are the branches with the pristine upstream tar sources.

[James Westby (james-w)]

review: Approve

=== modified file 'cmds.py'
--- cmds.py	2011-06-14 14:04:53 +0000
+++ cmds.py	2011-06-15 13:28:52 +0000
@@ -557,7 +557,7 @@
     def _do_merge(self, tree, tarball_filenames, package, version,
             current_version, upstream_branch, upstream_revision, merge_type,
             force):
-        db = DistributionBranch(tree.branch, None, tree=tree)
+        db = DistributionBranch(tree.branch, tree.branch, tree=tree)
         dbs = DistributionBranchSet()
         dbs.add_branch(db)
         if len(tarball_filenames) > 1:
@@ -860,7 +860,7 @@
                         "yet supported.")
             orig_dir = config.orig_dir or default_orig_dir
             orig_target = os.path.join(tree.basedir, default_orig_dir)
-            db = DistributionBranch(tree.branch, None, tree=tree)
+            db = DistributionBranch(tree.branch, tree.branch, tree=tree)
             dbs = DistributionBranchSet()
             dbs.add_branch(db)
             try:
@@ -945,8 +945,8 @@
         tempdir = tempfile.mkdtemp(
             dir=branch.bzrdir.root_transport.clone('..').local_abspath('.'))
         self.add_cleanup(shutil.rmtree, tempdir)
-        db = DistributionBranch(branch, upstream_branch=upstream)
-        if db.pristine_tar_source.has_version(None, version):
+        db = DistributionBranch(branch, pristine_upstream_branch=branch)
+        if db.pristine_upstream_source.has_version(None, version):
             raise BzrCommandError("Version %s is already present." % version)
         tagged_versions = {}
         for tag_name, tag_revid in branch.tags.get_tag_dict().iteritems():

=== modified file 'dh_make.py'
--- dh_make.py	2011-06-14 14:04:53 +0000
+++ dh_make.py	2011-06-15 13:28:52 +0000
@@ -84,7 +84,7 @@
     tarball_filenames  = _get_tarballs(tree, tarball,
             package_name, version, use_v3=use_v3)
     db = import_dsc.DistributionBranch(tree.branch, tree.branch, tree=tree,
-            upstream_tree=tree)
+            pristine_upstream_tree=tree)
     dbs = import_dsc.DistributionBranchSet()
     dbs.add_branch(db)
     if len(tarball_filenames) > 1:

=== modified file 'import_dsc.py'
--- import_dsc.py	2011-06-09 21:43:07 +0000
+++ import_dsc.py	2011-06-15 13:28:52 +0000
@@ -209,28 +209,28 @@
     have a total ordering with respect to these relationships.
     """
 
-    def __init__(self, branch, upstream_branch, tree=None,
-            upstream_tree=None):
+    def __init__(self, branch, pristine_upstream_branch, tree=None,
+            pristine_upstream_tree=None):
         """Create a distribution branch.
 
         You can only import packages on to the DistributionBranch
-        if both tree and upstream_tree are provided.
+        if both tree and pristine_upstream_tree are provided.
 
         :param branch: the Branch for the packaging part.
-        :param upstream_branch: the Branch for the upstream part, if any.
+        :param upstream_pristine_branch: the Branch for the pristine tar part, if any.
         :param tree: an optional tree for the branch.
-        :param upstream_tree: an optional upstream_tree for the
+        :param pristine_upstream_tree: an optional tree for the
             upstream_branch.
         """
         self.branch = branch
         self.tree = tree
-        self.pristine_tar_source = PristineTarSource(branch=branch, tree=tree)
-        self.upstream_branch = upstream_branch
-        self.upstream_tree = upstream_tree
-        if upstream_branch is not None:
-            self.upstream_source = UpstreamBranchSource(self.upstream_branch)
+        self.pristine_upstream_branch = pristine_upstream_branch
+        self.pristine_upstream_tree = pristine_upstream_tree
+        if pristine_upstream_branch is not None:
+            self.pristine_upstream_source = PristineTarSource(
+                branch=pristine_upstream_branch, tree=pristine_upstream_tree)
         else:
-            self.upstream_source = None
+            self.pristine_upstream_source = None
         self.get_lesser_branches = None
         self.get_greater_branches = None
 
@@ -341,8 +341,8 @@
         :return: True if the upstream branch contains the specified upstream
             version of the package. False otherwise.
         """
-        for tag_name in self.pristine_tar_source.possible_tag_names(version):
-            if self._has_version(self.upstream_branch, tag_name, md5=md5):
+        for tag_name in self.pristine_upstream_source.possible_tag_names(version):
+            if self._has_version(self.pristine_upstream_branch, tag_name, md5=md5):
                 return True
         return False
 
@@ -442,11 +442,11 @@
         :return: the revision id corresponding to the upstream portion
             of the version
         """
-        for tag_name in self.pristine_tar_source.possible_tag_names(version):
-            if self._has_version(self.upstream_branch, tag_name):
-                return self.upstream_branch.tags.lookup_tag(tag_name)
-        tag_name = self.pristine_tar_source.tag_name(version)
-        return self.upstream_branch.tags.lookup_tag(tag_name)
+        for tag_name in self.pristine_upstream_source.possible_tag_names(version):
+            if self._has_version(self.pristine_upstream_branch, tag_name):
+                return self.pristine_upstream_branch.tags.lookup_tag(tag_name)
+        tag_name = self.pristine_upstream_source.tag_name(version)
+        return self.pristine_upstream_branch.tags.lookup_tag(tag_name)
 
     def tag_version(self, version, revid=None):
         """Tags the branch's last revision with the given version.
@@ -475,16 +475,16 @@
         :param version: the upstream part of the version number to derive the 
             tag name from.
         :param revid: the revid to associate the tag with, or None for the
-            tip of self.upstream_branch.
+            tip of self.pristine_upstream_branch.
         :return The tag name, revid of the added tag.
         """
         assert isinstance(version, str)
-        tag_name = self.pristine_tar_source.tag_name(version)
+        tag_name = self.pristine_upstream_source.tag_name(version)
         if revid is None:
-            revid = self.upstream_branch.last_revision()
-        self.upstream_branch.tags.set_tag(tag_name, revid)
+            revid = self.pristine_upstream_branch.last_revision()
+        self.pristine_upstream_branch.tags.set_tag(tag_name, revid)
         try:
-            self.branch.repository.fetch(self.upstream_branch.repository,
+            self.branch.repository.fetch(self.pristine_upstream_branch.repository,
                 revision_id=revid)
         except NoSuchRevision:
             # See bug lp:574223
@@ -612,13 +612,13 @@
         assert md5 is not None, \
             ("It's not a good idea to use branch_to_pull_upstream_from with "
              "md5 == None, as you may pull the wrong revision.")
-        up_branch = self.upstream_branch
+        up_branch = self.pristine_upstream_branch
         up_branch.lock_read()
         try:
             for branch in reversed(self.get_lesser_branches()):
                 if branch.has_upstream_version(version, md5=md5):
                     # Check that they haven't diverged
-                    other_up_branch = branch.upstream_branch
+                    other_up_branch = branch.pristine_upstream_branch
                     other_up_branch.lock_read()
                     try:
                         graph = other_up_branch.repository.get_graph(
@@ -631,7 +631,7 @@
             for branch in self.get_greater_branches():
                 if branch.has_upstream_version(version, md5=md5):
                     # Check that they haven't diverged
-                    other_up_branch = branch.upstream_branch
+                    other_up_branch = branch.pristine_upstream_branch
                     other_up_branch.lock_read()
                     try:
                         graph = other_up_branch.repository.get_graph(
@@ -729,14 +729,14 @@
         pull_revision = pull_branch.revid_of_upstream_version(version)
         mutter("Pulling upstream part of %s from revision %s" % \
                 (version, pull_revision))
-        up_pull_branch = pull_branch.upstream_branch
-        assert self.upstream_tree is not None, \
+        up_pull_branch = pull_branch.pristine_upstream_branch
+        assert self.pristine_upstream_tree is not None, \
             "Can't pull upstream with no tree"
-        self.upstream_tree.pull(up_pull_branch,
+        self.pristine_upstream_tree.pull(up_pull_branch,
                 stop_revision=pull_revision)
         self.tag_upstream_version(version, revid=pull_revision)
-        self.branch.fetch(self.upstream_branch, last_revision=pull_revision)
-        self.upstream_branch.tags.merge_to(self.branch.tags)
+        self.branch.fetch(self.pristine_upstream_branch, last_revision=pull_revision)
+        self.pristine_upstream_branch.tags.merge_to(self.branch.tags)
 
     def pull_version_from_branch(self, pull_branch, version, native=False):
         """Pull a version from a particular branch.
@@ -772,12 +772,12 @@
             else:
                 assert False, ("Can't find the needed upstream part "
                         "for version %s" % version)
-        if (native and self.upstream_branch.last_revision() == NULL_REVISION
-            and pull_branch.upstream_branch.last_revision() != NULL_REVISION):
+        if (native and self.pristine_upstream_branch.last_revision() == NULL_REVISION
+            and pull_branch.pristine_upstream_branch.last_revision() != NULL_REVISION):
             # in case the package wasn't native before then we pull
             # the upstream. These checks may be a bit restrictive.
-            self.upstream_tree.pull(pull_branch.upstream_branch)
-            pull_branch.upstream_branch.tags.merge_to(self.upstream_branch.tags)
+            self.pristine_upstream_tree.pull(pull_branch.pristine_upstream_branch)
+            pull_branch.pristine_upstream_branch.tags.merge_to(self.pristine_upstream_branch.tags)
         elif native:
             mutter("Not checking for upstream as it is a native package")
         else:
@@ -834,8 +834,8 @@
         # Make sure we see any revisions added by the upstream branch
         # since self.tree was locked.
         self.branch.repository.refresh_data()
-        self.branch.fetch(self.upstream_branch, last_revision=revid)
-        self.upstream_branch.tags.merge_to(self.branch.tags)
+        self.branch.fetch(self.pristine_upstream_branch, last_revision=revid)
+        self.pristine_upstream_branch.tags.merge_to(self.branch.tags)
 
     def import_upstream(self, upstream_part, version, md5, upstream_parents,
             upstream_tarball=None, upstream_branch=None,
@@ -863,28 +863,28 @@
         assert isinstance(version, str)
         mutter("Importing upstream version %s from %s with parents %s" \
                 % (version, upstream_part, str(upstream_parents)))
-        assert self.upstream_tree is not None, \
+        assert self.pristine_upstream_tree is not None, \
             "Can't import upstream with no tree"
         if len(upstream_parents) > 0:
             parent_revid = upstream_parents[0]
         else:
             parent_revid = NULL_REVISION
-        self.upstream_tree.pull(self.upstream_tree.branch, overwrite=True,
+        self.pristine_upstream_tree.pull(self.pristine_upstream_tree.branch, overwrite=True,
                 stop_revision=parent_revid)
         other_branches = self.get_other_branches()
         def get_last_revision_tree(br):
             return br.repository.revision_tree(br.last_revision())
-        upstream_trees = [get_last_revision_tree(o.upstream_branch)
+        upstream_trees = [get_last_revision_tree(o.pristine_upstream_branch)
             for o in other_branches]
         target_tree = None
         if upstream_branch is not None:
             if upstream_revision is None:
                 upstream_revision = upstream_branch.last_revision()
-            self.upstream_branch.fetch(upstream_branch,
+            self.pristine_upstream_branch.fetch(upstream_branch,
                     last_revision=upstream_revision)
-            upstream_branch.tags.merge_to(self.upstream_branch.tags)
+            upstream_branch.tags.merge_to(self.pristine_upstream_branch.tags)
             upstream_parents.append(upstream_revision)
-            target_tree = self.upstream_branch.repository.revision_tree(
+            target_tree = self.pristine_upstream_branch.repository.revision_tree(
                         upstream_revision)
         if file_ids_from is not None:
             upstream_trees = file_ids_from + upstream_trees
@@ -895,16 +895,16 @@
             self_tree = self.get_branch_tip_revtree()
             self_tree.lock_read()
         try:
-            import_dir(self.upstream_tree, upstream_part,
+            import_dir(self.pristine_upstream_tree, upstream_part,
                     file_ids_from=[self_tree] + upstream_trees,
                     target_tree=target_tree)
         finally:
             self_tree.unlock()
-        self.upstream_tree.set_parent_ids(upstream_parents)
+        self.pristine_upstream_tree.set_parent_ids(upstream_parents)
         revprops = {"deb-md5": md5}
         if upstream_tarball is not None:
-            delta_revprops = self.pristine_tar_source.create_delta_revprops(
-                self.upstream_tree, upstream_tarball)
+            delta_revprops = self.pristine_upstream_source.create_delta_revprops(
+                self.pristine_upstream_tree, upstream_tarball)
             revprops.update(delta_revprops)
         if author is not None:
             revprops['authors'] = author
@@ -912,7 +912,7 @@
         if timestamp is not None:
             timezone = timestamp[1]
             timestamp = timestamp[0]
-        revid = self.upstream_tree.commit("Import upstream version %s" \
+        revid = self.pristine_upstream_tree.commit("Import upstream version %s" \
                 % (version,),
                 revprops=revprops, timestamp=timestamp, timezone=timezone)
         tag_name, _ = self.tag_upstream_version(version, revid=revid)
@@ -1090,7 +1090,7 @@
             importing the specified upstream version.
         """
         parents = []
-        first_parent = self.upstream_branch.last_revision()
+        first_parent = self.pristine_upstream_branch.last_revision()
         if first_parent != NULL_REVISION:
             parents = [first_parent]
         last_contained_version = self.last_contained_version(versions)
@@ -1102,7 +1102,7 @@
                 and not self.has_upstream_version(last_contained_version.upstream_version)):
                 revid = self.revid_of_version(last_contained_version)
                 parents.append(revid)
-                self.upstream_branch.fetch(self.branch,
+                self.pristine_upstream_branch.fetch(self.branch,
                         last_revision=revid)
         pull_parents = self.get_parents(versions)
         if ((first_parent == NULL_REVISION and len(pull_parents) > 0)
@@ -1119,11 +1119,11 @@
                     mutter("Initialising upstream from %s, version %s" \
                         % (str(pull_branch), str(pull_version)))
                     parents.append(pull_revid)
-                    self.upstream_branch.fetch(
-                            pull_branch.upstream_branch,
+                    self.pristine_upstream_branch.fetch(
+                            pull_branch.pristine_upstream_branch,
                             last_revision=pull_revid)
-                    pull_branch.upstream_branch.tags.merge_to(
-                            self.upstream_branch.tags)
+                    pull_branch.pristine_upstream_branch.tags.merge_to(
+                            self.pristine_upstream_branch.tags)
         return parents
 
     def get_changelog_from_source(self, dir):
@@ -1150,7 +1150,7 @@
             # We need to import at least the diff, possibly upstream.
             # Work out if we need the upstream part first.
             imported_upstream = False
-            if not self.has_upstream_version(version.upstream_version):
+            if not self.pristine_upstream_source.has_version(None, version.upstream_version):
                 up_pull_branch = \
                     self.branch_to_pull_upstream_from(version.upstream_version,
                             upstream_md5)
@@ -1195,9 +1195,9 @@
                 branch.branch.tags.merge_to(self.branch.tags)
                 self.branch.fetch(branch.branch,
                         last_revision=revid)
-                if self.upstream_branch.last_revision() == NULL_REVISION:
-                    self.upstream_tree.pull(branch.upstream_branch)
-                    branch.upstream_branch.tags.merge_to(self.upstream_branch.tags)
+                if self.pristine_upstream_branch.last_revision() == NULL_REVISION:
+                    self.pristine_upstream_tree.pull(branch.pristine_upstream_branch)
+                    branch.pristine_upstream_branch.tags.merge_to(self.pristine_upstream_branch.tags)
         for branch in self.get_greater_branches():
             merged, missing_versions = \
                 branch.contained_versions(missing_versions)
@@ -1208,9 +1208,9 @@
                 branch.branch.tags.merge_to(self.branch.tags)
                 self.branch.fetch(branch.branch,
                         last_revision=revid)
-                if self.upstream_branch.last_revision() == NULL_REVISION:
-                    self.upstream_tree.pull(branch.upstream_branch)
-                    branch.upstream_branch.tags.merge_to(self.upstream_branch.tags)
+                if self.pristine_upstream_branch.last_revision() == NULL_REVISION:
+                    self.pristine_upstream_tree.pull(branch.pristine_upstream_branch)
+                    branch.pristine_upstream_branch.tags.merge_to(self.pristine_upstream_branch.tags)
         if (self.branch.last_revision() != NULL_REVISION
                 and not self.branch.last_revision() in parents):
             parents.insert(0, self.branch.last_revision())
@@ -1300,16 +1300,16 @@
         # TODO: remove the _extract_upstream_tree alias below.
         to_location = os.path.join(basedir, "upstream")
         # Use upstream_branch if it has been set, otherwise self.branch.
-        source_branch = self.upstream_branch or self.branch
+        source_branch = self.pristine_upstream_branch or self.branch
         dir_to = source_branch.bzrdir.sprout(to_location,
                 revision_id=upstream_tip,
                 accelerator_tree=self.tree)
         try:
-            self.upstream_tree = dir_to.open_workingtree()
+            self.pristine_upstream_tree = dir_to.open_workingtree()
         except NoWorkingTree:
             # Handle shared treeless repo's.
-            self.upstream_tree = dir_to.create_workingtree()
-        self.upstream_branch = self.upstream_tree.branch
+            self.pristine_upstream_tree = dir_to.create_workingtree()
+        self.pristine_upstream_branch = self.pristine_upstream_tree.branch
 
     _extract_upstream_tree = extract_upstream_tree
 
@@ -1333,8 +1333,8 @@
             else:
                 branch = existing_bzrdir.create_branch()
                 existing_bzrdir.create_workingtree()
-        self.upstream_branch = branch
-        self.upstream_tree = branch.bzrdir.open_workingtree()
+        self.pristine_upstream_branch = branch
+        self.pristine_upstream_tree = branch.bzrdir.open_workingtree()
         if self.tree:
             root_id = self.tree.path2id('')
         else:
@@ -1345,7 +1345,7 @@
             finally:
                 tip.unlock()
         if root_id:
-            self.upstream_tree.set_root_id(root_id)
+            self.pristine_upstream_tree.set_root_id(root_id)
 
     def _extract_tarball_to_tempdir(self, tarball_filename):
         tempdir = tempfile.mkdtemp()
@@ -1365,28 +1365,23 @@
             shutil.rmtree(tempdir)
             raise
 
-    def _export_previous_upstream_tree(self, package, previous_version, tempdir, upstream_branch=None):
+    def _export_previous_upstream_tree(self, package, previous_version, tempdir):
         assert isinstance(previous_version, str), \
             "Should pass upstream version as str, not Version."
-        if self.pristine_tar_source.has_version(package, previous_version):
-            upstream_tip = self.pristine_tar_source.version_as_revision(
+        if self.pristine_upstream_source.has_version(package, previous_version):
+            upstream_tip = self.pristine_upstream_source.version_as_revision(
                     package, previous_version)
             self.extract_upstream_tree(upstream_tip, tempdir)
-        elif self.upstream_source is not None:
-            upstream_tip = self.upstream_source.version_as_revision(package, previous_version)
-            self.extract_upstream_tree(upstream_tip, tempdir)
         else:
             raise BzrCommandError("Unable to find the tag for the "
                     "previous upstream version, %s, in the branch: "
                     "%s" % (
                 previous_version,
-                self.pristine_tar_source.tag_name(previous_version)))
+                self.pristine_upstream_source.tag_name(previous_version)))
 
     def merge_upstream(self, tarball_filename, package, version, previous_version,
             upstream_branch=None, upstream_revision=None, merge_type=None,
             force=False):
-        assert self.upstream_branch is None, \
-                "Should use self.upstream_branch if set"
         assert isinstance(version, str), \
             "Should pass version as str not %s" % str(type(version))
         assert isinstance(previous_version, str) or previous_version is None, \
@@ -1395,11 +1390,10 @@
         tempdir = tempfile.mkdtemp(dir=os.path.join(self.tree.basedir, '..'))
         try:
             if previous_version is not None:
-                self._export_previous_upstream_tree(package, previous_version, tempdir,
-                    upstream_branch)
+                self._export_previous_upstream_tree(package, previous_version, tempdir)
             else:
                 self._create_empty_upstream_tree(tempdir)
-            if self.pristine_tar_source.has_version(package, version):
+            if self.pristine_upstream_source.has_version(package, version):
                 raise UpstreamAlreadyImported(version)
             if upstream_branch is not None:
                 upstream_branch.lock_read()
@@ -1418,8 +1412,8 @@
                 try:
                     # FIXME: should use upstream_parents()?
                     parents = []
-                    if self.upstream_branch.last_revision() != NULL_REVISION:
-                        parents = [self.upstream_branch.last_revision()]
+                    if self.pristine_upstream_branch.last_revision() != NULL_REVISION:
+                        parents = [self.pristine_upstream_branch.last_revision()]
                     _, new_revid = self.import_upstream(tarball_dir,
                             version,
                             md5sum, parents, upstream_tarball=tarball_filename,
@@ -1431,7 +1425,7 @@
                 if self.branch.last_revision() != NULL_REVISION:
                     try:
                         conflicts = self.tree.merge_from_branch(
-                                self.upstream_branch, merge_type=merge_type)
+                                self.pristine_upstream_branch, merge_type=merge_type)
                     except UnrelatedBranches:
                         # Bug lp:515367 where the first upstream tarball is
                         # missing a proper history link and a criss-cross merge
@@ -1442,14 +1436,14 @@
                         else:
                             from_revision = parents[0]
                         conflicts = self.tree.merge_from_branch(
-                                self.upstream_branch, merge_type=merge_type,
+                                self.pristine_upstream_branch, merge_type=merge_type,
                                 from_revision=from_revision)
                 else:
                     # Pull so that merge-upstream allows you to start a branch
                     # from upstream tarball.
                     conflicts = 0
-                    self.tree.pull(self.upstream_branch)
-                self.upstream_branch.tags.merge_to(self.branch.tags)
+                    self.tree.pull(self.pristine_upstream_branch)
+                self.pristine_upstream_branch.tags.merge_to(self.branch.tags)
                 return conflicts
             finally:
                 if upstream_branch is not None:

=== modified file 'merge_package.py'
--- merge_package.py	2011-01-29 00:13:30 +0000
+++ merge_package.py	2011-06-15 13:28:52 +0000
@@ -60,7 +60,7 @@
         db = DistributionBranch(branch, branch)
         uver = _latest_version(branch).upstream_version
         results.append((Version(uver),
-                    db.pristine_tar_source.version_as_revision(None, uver)))
+                    db.pristine_upstream_source.version_as_revision(None, uver)))
 
     return results
 
@@ -137,7 +137,7 @@
                 # Extract the merge target's upstream tree into a temporary
                 # directory.
                 db.extract_upstream_tree(ut_revid, tempdir)
-                tmp_target_utree = db.upstream_tree
+                tmp_target_utree = db.pristine_upstream_tree
 
                 # Merge upstream branch tips to obtain a shared upstream parent.
                 # This will add revision K (see graph above) to a temporary merge

=== modified file 'tests/blackbox/test_merge_upstream.py'
--- tests/blackbox/test_merge_upstream.py	2011-06-13 23:01:14 +0000
+++ tests/blackbox/test_merge_upstream.py	2011-06-15 13:28:52 +0000
@@ -88,7 +88,7 @@
         branchpath = test_case.getUniqueString()
         tree = self.upstream.tree.bzrdir.sprout(branchpath).open_workingtree()
         db = DistributionBranch(tree.branch, tree.branch, tree=tree,
-                upstream_tree=tree)
+                pristine_upstream_tree=tree)
         dbs = DistributionBranchSet()
         dbs.add_branch(db)
         db.import_upstream_tarball(self.tar.tarball, str(self.tar.version),

=== modified file 'tests/test_import_dsc.py'
--- tests/test_import_dsc.py	2011-06-10 11:47:25 +0000
+++ tests/test_import_dsc.py	2011-06-15 13:28:52 +0000
@@ -82,28 +82,28 @@
         self.up_tree1.set_root_id(root_id)
         self.db1 = DistributionBranch(self.tree1.branch,
                 self.up_tree1.branch, tree=self.tree1,
-                upstream_tree=self.up_tree1)
+                pristine_upstream_tree=self.up_tree1)
         self.tree2 = self.make_branch_and_tree('experimental')
         self.tree2.set_root_id(root_id)
         self.up_tree2 = self.make_branch_and_tree('experimental-upstream')
         self.up_tree2.set_root_id(root_id)
         self.db2 = DistributionBranch(self.tree2.branch,
                 self.up_tree2.branch, tree=self.tree2,
-                upstream_tree=self.up_tree2)
+                pristine_upstream_tree=self.up_tree2)
         self.tree3 = self.make_branch_and_tree('gutsy')
         self.tree3.set_root_id(root_id)
         self.up_tree3 = self.make_branch_and_tree('gutsy-upstream')
         self.up_tree3.set_root_id(root_id)
         self.db3 = DistributionBranch(self.tree3.branch,
                 self.up_tree3.branch, tree=self.tree3,
-                upstream_tree=self.up_tree3)
+                pristine_upstream_tree=self.up_tree3)
         self.tree4 = self.make_branch_and_tree('hardy')
         self.tree4.set_root_id(root_id)
         self.up_tree4 = self.make_branch_and_tree('hardy-upstream')
         self.up_tree4.set_root_id(root_id)
         self.db4 = DistributionBranch(self.tree4.branch,
                 self.up_tree4.branch, tree=self.tree4,
-                upstream_tree=self.up_tree4)
+                pristine_upstream_tree=self.up_tree4)
         self.set = DistributionBranchSet()
         self.set.add_branch(self.db1)
         self.set.add_branch(self.db2)
@@ -128,9 +128,9 @@
         db = self.db1
         self.assertNotEqual(db, None)
         self.assertEqual(db.branch, self.tree1.branch)
-        self.assertEqual(db.upstream_branch, self.up_tree1.branch)
+        self.assertEqual(db.pristine_upstream_branch, self.up_tree1.branch)
         self.assertEqual(db.tree, self.tree1)
-        self.assertEqual(db.upstream_tree, self.up_tree1)
+        self.assertEqual(db.pristine_upstream_tree, self.up_tree1)
 
     def test_tag_name(self):
         db = self.db1
@@ -153,7 +153,7 @@
         version = "0.1"
         revid = tree.commit("one")
         db.tag_upstream_version(version)
-        tag_name = db.pristine_tar_source.tag_name(version)
+        tag_name = db.pristine_upstream_source.tag_name(version)
         self.assertEqual(tree.branch.tags.lookup_tag(tag_name), revid)
 
     def test_has_version(self):
@@ -888,7 +888,7 @@
         builder.add_default_control()
         builder.build()
         self.db1.import_package(builder.dsc_name())
-        self.db1.upstream_tree = None
+        self.db1.pristine_upstream_tree = None
         builder.new_version(version2)
         builder.build()
         self.db2.import_package(builder.dsc_name())
@@ -903,7 +903,7 @@
         builder.add_default_control()
         builder.build()
         self.db2.import_package(builder.dsc_name())
-        self.db2.upstream_tree = None
+        self.db2.pristine_upstream_tree = None
         builder.new_version(version2)
         builder.build()
         self.db1.import_package(builder.dsc_name())
@@ -1482,7 +1482,7 @@
         self.write_changelog(cl, 'work/debian/changelog')
         tree.add(['debian/', 'debian/changelog'])
         orig_debian_rev = tree.commit("two")
-        db = DistributionBranch(tree.branch, None, tree=tree)
+        db = DistributionBranch(tree.branch, tree.branch, tree=tree)
         dbs = DistributionBranchSet()
         dbs.add_branch(db)
         tarball_filename = "package-0.2.tar.gz"
@@ -1519,7 +1519,7 @@
         self.addCleanup(tree.unlock)
         upstream_tree.lock_read()
         self.addCleanup(upstream_tree.unlock)
-        db = DistributionBranch(tree.branch, None, tree=tree)
+        db = DistributionBranch(tree.branch, tree.branch, tree=tree)
         dbs = DistributionBranchSet()
         dbs.add_branch(db)
         tarball_filename = "package-0.2.tar.gz"
@@ -1559,7 +1559,7 @@
         self.addCleanup(tree.unlock)
         upstream_tree.lock_read()
         self.addCleanup(upstream_tree.unlock)
-        db = DistributionBranch(tree.branch, None, tree=tree)
+        db = DistributionBranch(tree.branch, tree.branch, tree=tree)
         dbs = DistributionBranchSet()
         dbs.add_branch(db)
         tarball_filename = "package-0.2.tar.gz"
@@ -1597,7 +1597,7 @@
         packaging_upstream_tree = self.make_branch_and_tree(
             "packaging-upstream")
         db = DistributionBranch(tree.branch, packaging_upstream_tree.branch,
-            tree=tree, upstream_tree=packaging_upstream_tree)
+            tree=tree, pristine_upstream_tree=packaging_upstream_tree)
         dbs = DistributionBranchSet()
         dbs.add_branch(db)
         db.import_package(builder.dsc_name())
@@ -1609,7 +1609,7 @@
         upstream_tree.add(['a'], ['a-id'])
         upstream_tree.commit("one")
         upstream_rev = upstream_tree.branch.last_revision()
-        db = DistributionBranch(tree.branch, None, tree=tree)
+        db = DistributionBranch(tree.branch, tree.branch, tree=tree)
         dbs = DistributionBranchSet()
         dbs.add_branch(db)
         tree.lock_write()
@@ -1639,7 +1639,7 @@
         self.write_changelog(cl, 'work/debian/changelog')
         tree.add(['debian/', 'debian/changelog'])
         orig_debian_rev = tree.commit("two")
-        db = DistributionBranch(tree.branch, None, tree=tree)
+        db = DistributionBranch(tree.branch, tree.branch, tree=tree)
         dbs = DistributionBranchSet()
         dbs.add_branch(db)
         tarball_filename = "package-0.2.tar.gz"
@@ -1675,7 +1675,7 @@
         upstream_tree.add(['a'], ['a-id'])
         upstream_rev1 = upstream_tree.commit("one")
         tree = upstream_tree.bzrdir.sprout('packaging').open_workingtree()
-        db = DistributionBranch(tree.branch, None, tree=tree)
+        db = DistributionBranch(tree.branch, tree.branch, tree=tree)
         dbs = DistributionBranchSet()
         dbs.add_branch(db)
         tree.lock_write()
@@ -1711,7 +1711,7 @@
         upstream_tree.add(['a', 'b'], ['a-id', 'b-id'])
         upstream_rev1 = upstream_tree.commit("one")
         tree = upstream_tree.bzrdir.sprout('packaging').open_workingtree()
-        db = DistributionBranch(tree.branch, None, tree=tree)
+        db = DistributionBranch(tree.branch, tree.branch, tree=tree)
         dbs = DistributionBranchSet()
         dbs.add_branch(db)
         tree.lock_write()
@@ -1747,7 +1747,7 @@
         self.build_tree(['packaging/a'])
         packaging_tree.add(['a'], ['a-id'])
         upstream_rev1 = packaging_tree.commit("one")
-        db = DistributionBranch(packaging_tree.branch, None,
+        db = DistributionBranch(packaging_tree.branch, packaging_tree.branch,
             tree=packaging_tree)
         dbs = DistributionBranchSet()
         dbs.add_branch(db)