Merge lp:~jelmer/bzr-builddeb/multiple-upstream-tarballs-pt3 into lp:bzr-builddeb

[Jelmer Vernooij]

Another step towards support for multiple upstream tarballs. This simplifies some of the code in import_dsc.

It also adds support for tarballs everywhere but the places deep down where the actual work has to happen:

* PristineTarSource.has_version()
* DistributionBranch.import_upstream()
* extract_orig_tarballs()
* PristineTarSource.fetch_tarball().

Except for the last, these now raise MultipleUpstreamTarballs

[James Westby (james-w)]

review: Approve

=== modified file 'cmds.py'
--- cmds.py	2011-06-15 16:29:37 +0000
+++ cmds.py	2011-06-15 16:39:26 +0000
@@ -870,8 +870,8 @@
                         '..'))
             try:
                 if last_version is not None:
-                    if not db.pristine_tar_source.has_version(None,
-                            last_version.upstream_version):
+                    if not db.pristine_tar_source.has_version(
+                            changelog.package, last_version.upstream_version):
                         raise BzrCommandError("Unable to find the tag for the "
                             "previous upstream version, %s, in the branch: %s."
                             " Consider importing it via import-dsc or "
@@ -879,7 +879,7 @@
                                     db.pristine_tar_source.tag_name(
                                         last_version.upstream_version)))
                     upstream_tip = db.pristine_tar_source.version_as_revision(
-                        None, last_version.upstream_version)
+                        changelog.package, last_version.upstream_version)
                     db.extract_upstream_tree(upstream_tip, tempdir)
                 else:
                     db._create_empty_upstream_tree(tempdir)

=== modified file 'import_dsc.py'
--- import_dsc.py	2011-06-15 16:29:37 +0000
+++ import_dsc.py	2011-06-15 16:39:26 +0000
@@ -300,30 +300,6 @@
                 pass
         return False
 
-    def _has_upstream_version(self, branch, tag_name, tarballs=None):
-        if branch.tags.has_tag(tag_name):
-            revid = branch.tags.lookup_tag(tag_name)
-            branch.lock_read()
-            try:
-                graph = branch.repository.get_graph()
-                if not graph.is_ancestor(revid, branch.last_revision()):
-                    return False
-            finally:
-                branch.unlock()
-            if tarballs is None:
-                return True
-            if len(tarballs) != 1:
-                raise MultipleUpstreamTarballsNotSupported()
-            (filename, md5) = tarballs[0]
-            rev = branch.repository.get_revision(revid)
-            try:
-                return rev.properties['deb-md5'] == md5
-            except KeyError:
-                warning("tag %s present in branch, but there is no "
-                    "associated 'deb-md5' property" % tag_name)
-                pass
-        return False
-
     def has_version(self, version, md5=None):
         """Whether this branch contains the package version specified.
 
@@ -349,7 +325,7 @@
             return True
         return False
 
-    def has_upstream_version(self, version, tarballs=None):
+    def has_upstream_version(self, package, version, tarballs=None):
         """Whether this branch contains the upstream version specified.
 
         The version must be judged present by having the appropriate tag
@@ -364,11 +340,7 @@
         :return: True if the upstream branch contains the specified upstream
             version of the package. False otherwise.
         """
-        for tag_name in self.pristine_upstream_source.possible_tag_names(version):
-            if self._has_upstream_version(self.pristine_upstream_branch,
-                    tag_name, tarballs=tarballs):
-                return True
-        return False
+        return self.pristine_upstream_source.has_version(package, version, tarballs)
 
     def contained_versions(self, versions):
         """Splits a list of versions depending on presence in the branch.
@@ -457,20 +429,17 @@
             return self.branch.tags.lookup_tag(ubuntu_tag_name)
         return self.branch.tags.lookup_tag(tag_name)
 
-    def revid_of_upstream_version(self, version):
+    def revid_of_upstream_version(self, package, version, tarballs=None):
         """Returns the revision id corresponding to the upstream version.
 
         :param version: the Version object to extract the upstream version
-            from to retreive the revid of. The upstream version must be
+            from to retrieve the revid of. The upstream version must be
             present in the upstream branch.
         :return: the revision id corresponding to the upstream portion
             of the version
         """
-        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)
+        return self.pristine_upstream_source.version_as_revision(package, version,
+            tarballs)
 
     def tag_version(self, version, revid=None):
         """Tags the branch's last revision with the given version.
@@ -614,7 +583,7 @@
         finally:
             self.branch.unlock()
 
-    def branch_to_pull_upstream_from(self, version, upstream_tarballs):
+    def branch_to_pull_upstream_from(self, package, version, upstream_tarballs):
         """Checks whether this upstream is a pull from a lesser branch.
 
         Looks in all the other upstream branches for the given
@@ -635,7 +604,8 @@
         up_branch.lock_read()
         try:
             for branch in reversed(self.get_lesser_branches()):
-                if branch.has_upstream_version(version, tarballs=upstream_tarballs):
+                if branch.has_upstream_version(package, version,
+                        tarballs=upstream_tarballs):
                     # Check that they haven't diverged
                     other_up_branch = branch.pristine_upstream_branch
                     other_up_branch.lock_read()
@@ -643,12 +613,13 @@
                         graph = other_up_branch.repository.get_graph(
                                 up_branch.repository)
                         if graph.is_ancestor(up_branch.last_revision(),
-                                branch.revid_of_upstream_version(version)):
+                                branch.revid_of_upstream_version(package, version)):
                             return branch
                     finally:
                         other_up_branch.unlock()
             for branch in self.get_greater_branches():
-                if branch.has_upstream_version(version, tarballs=upstream_tarballs):
+                if branch.has_upstream_version(package, version,
+                        tarballs=upstream_tarballs):
                     # Check that they haven't diverged
                     other_up_branch = branch.pristine_upstream_branch
                     other_up_branch.lock_read()
@@ -656,7 +627,7 @@
                         graph = other_up_branch.repository.get_graph(
                                 up_branch.repository)
                         if graph.is_ancestor(up_branch.last_revision(),
-                                branch.revid_of_upstream_version(version)):
+                                branch.revid_of_upstream_version(package, version)):
                             return branch
                     finally:
                         other_up_branch.unlock()
@@ -729,7 +700,7 @@
                         last_revision=revid)
         return parents
 
-    def pull_upstream_from_branch(self, pull_branch, version):
+    def pull_upstream_from_branch(self, pull_branch, package, version):
         """Pulls an upstream version from a branch.
 
         Given a DistributionBranch and a version number this method
@@ -745,7 +716,7 @@
         :param version: the upstream version string
         """
         assert isinstance(version, str)
-        pull_revision = pull_branch.revid_of_upstream_version(version)
+        pull_revision = pull_branch.revid_of_upstream_version(package, version)
         mutter("Pulling upstream part of %s from revision %s" % \
                 (version, pull_revision))
         up_pull_branch = pull_branch.pristine_upstream_branch
@@ -757,7 +728,7 @@
         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):
+    def pull_version_from_branch(self, pull_branch, package, version, native=False):
         """Pull a version from a particular branch.
 
         Given a DistributionBranch and a version number this method
@@ -784,10 +755,10 @@
         assert self.tree is not None, "Can't pull branch with no tree"
         self.tree.pull(pull_branch.branch, stop_revision=pull_revision)
         self.tag_version(version, revid=pull_revision)
-        if not native and not self.has_upstream_version(version.upstream_version):
-            if pull_branch.has_upstream_version(version.upstream_version):
+        if not native and not self.has_upstream_version(package, version.upstream_version):
+            if pull_branch.has_upstream_version(package, version.upstream_version):
                 self.pull_upstream_from_branch(pull_branch, 
-                    version.upstream_version)
+                    package, version.upstream_version)
             else:
                 assert False, ("Can't find the needed upstream part "
                         "for version %s" % version)
@@ -803,7 +774,7 @@
             mutter("Not importing the upstream part as it is already "
                     "present in the upstream branch")
 
-    def get_parents_with_upstream(self, version, versions,
+    def get_parents_with_upstream(self, package, version, versions,
             force_upstream_parent=False):
         """Get the list of parents including any upstream parents.
 
@@ -840,7 +811,8 @@
                     break
         real_parents = [p[2] for p in parents]
         if need_upstream_parent:
-            parent_revid = self.revid_of_upstream_version(version.upstream_version)
+            parent_revid = self.revid_of_upstream_version(package,
+                version.upstream_version)
             if len(parents) > 0:
                 real_parents.insert(1, parent_revid)
             else:
@@ -1100,7 +1072,7 @@
                 timezone=timezone)
         self.tag_version(version, revid=revid)
 
-    def upstream_parents(self, versions, version):
+    def upstream_parents(self, package, versions, version):
         """Get the parents for importing a new upstream.
 
         The upstream parents will be the last upstream version,
@@ -1119,7 +1091,8 @@
             # upstream as a non-native version (i.e. it wasn't a mistaken
             # native -2 version), then we want to add an extra parent.
             if (self.is_version_native(last_contained_version)
-                and not self.has_upstream_version(last_contained_version.upstream_version)):
+                and not self.has_upstream_version(package,
+                    last_contained_version.upstream_version)):
                 revid = self.revid_of_version(last_contained_version)
                 parents.append(revid)
                 self.pristine_upstream_branch.fetch(self.branch,
@@ -1134,16 +1107,16 @@
                 pull_branch = pull_parents[1][0]
                 pull_version = pull_parents[1][1]
             if not pull_branch.is_version_native(pull_version):
-                    pull_revid = \
-                        pull_branch.revid_of_upstream_version(pull_version.upstream_version)
-                    mutter("Initialising upstream from %s, version %s" \
-                        % (str(pull_branch), str(pull_version)))
-                    parents.append(pull_revid)
-                    self.pristine_upstream_branch.fetch(
-                            pull_branch.pristine_upstream_branch,
-                            last_revision=pull_revid)
-                    pull_branch.pristine_upstream_branch.tags.merge_to(
-                            self.pristine_upstream_branch.tags)
+                pull_revid = pull_branch.revid_of_upstream_version(
+                    package, pull_version.upstream_version)
+                mutter("Initialising upstream from %s, version %s",
+                    str(pull_branch), str(pull_version))
+                parents.append(pull_revid)
+                self.pristine_upstream_branch.fetch(
+                        pull_branch.pristine_upstream_branch,
+                        last_revision=pull_revid)
+                pull_branch.pristine_upstream_branch.tags.merge_to(
+                        self.pristine_upstream_branch.tags)
         return parents
 
     def get_changelog_from_source(self, dir):
@@ -1152,11 +1125,12 @@
         cl.parse_changelog(open(cl_filename).read(), strict=False)
         return cl
 
-    def _import_normal_package(self, version, versions, debian_part, md5,
+    def _import_normal_package(self, package, version, versions, debian_part, md5,
             upstream_part, upstream_tarballs, timestamp=None, author=None,
             file_ids_from=None, pull_debian=True):
         """Import a source package.
 
+        :param package: Package name
         :param version: Full Debian version
         :param versions: Safe versions from changelog
         :param debian_part: Path to extracted directory with Debian changes
@@ -1172,28 +1146,28 @@
         if pull_debian:
             pull_branch = self.branch_to_pull_version_from(version, md5)
         if pull_branch is not None:
-            if (self.branch_to_pull_upstream_from(version.upstream_version,
-                        upstream_tarballs)
+            if (self.branch_to_pull_upstream_from(package,
+                    version.upstream_version, upstream_tarballs)
                     is None):
                 pull_branch = None
         if pull_branch is not None:
-            self.pull_version_from_branch(pull_branch, version)
+            self.pull_version_from_branch(pull_branch, package, version)
         else:
             # 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.pristine_upstream_source.has_version(None, version.upstream_version):
+            if not self.pristine_upstream_source.has_version(package, version.upstream_version):
                 up_pull_branch = \
-                    self.branch_to_pull_upstream_from(version.upstream_version,
+                    self.branch_to_pull_upstream_from(package, version.upstream_version,
                             upstream_tarballs)
                 if up_pull_branch is not None:
                     self.pull_upstream_from_branch(up_pull_branch,
-                            version.upstream_version)
+                            package, version.upstream_version)
                 else:
                     imported_upstream = True
                     # Check whether we should pull first if this initialises
                     # from another branch:
-                    upstream_parents = self.upstream_parents(versions,
+                    upstream_parents = self.upstream_parents(package, versions,
                             version.upstream_version)
                     _, new_revid = self.import_upstream(upstream_part,
                             version.upstream_version,
@@ -1204,7 +1178,7 @@
                     self._fetch_upstream_to_branch(new_revid)
             else:
                 mutter("We already have the needed upstream part")
-            parents = self.get_parents_with_upstream(version, versions,
+            parents = self.get_parents_with_upstream(package, version, versions,
                     force_upstream_parent=imported_upstream)
             # Now we have the list of parents we need to import the .diff.gz
             self.import_debian(debian_part, version, parents, md5,
@@ -1248,13 +1222,13 @@
             parents.insert(0, self.branch.last_revision())
         return parents
 
-    def _import_native_package(self, version, versions, debian_part, md5,
+    def _import_native_package(self, package, version, versions, debian_part, md5,
             timestamp=None, file_ids_from=None, pull_debian=True):
         pull_branch = None
         if pull_debian:
             pull_branch = self.branch_to_pull_version_from(version, md5)
         if pull_branch is not None:
-            self.pull_version_from_branch(pull_branch, version, native=True)
+            self.pull_version_from_branch(pull_branch, package, version, native=True)
         else:
             parents = self.get_native_parents(version, versions)
             self.import_debian(debian_part, version, parents, md5,
@@ -1308,7 +1282,7 @@
             # should happen if it isn't.
 
             if extractor.extracted_upstream is not None:
-                self._import_normal_package(version, versions,
+                self._import_normal_package(dsc['Source'], version, versions,
                         extractor.extracted_debianised,
                         extractor.unextracted_debian_md5,
                         extractor.extracted_upstream,
@@ -1317,7 +1291,7 @@
                         file_ids_from=file_ids_from,
                         pull_debian=pull_debian)
             else:
-                self._import_native_package(version, versions,
+                self._import_native_package(dsc['Source'], version, versions,
                         extractor.extracted_debianised,
                         extractor.unextracted_debian_md5,
                         timestamp=timestamp, file_ids_from=file_ids_from,

=== modified file 'tests/test_import_dsc.py'
--- tests/test_import_dsc.py	2011-06-15 16:29:37 +0000
+++ tests/test_import_dsc.py	2011-06-15 16:39:26 +0000
@@ -47,9 +47,6 @@
         BuilddebTestCase,
         SourcePackageBuilder,
         )
-from bzrlib.plugins.builddeb.util import (
-        md5sum_filename,
-        )
 
 
 class _PristineTarFeature(tests.Feature):
@@ -174,27 +171,27 @@
     def test_has_upstream_version(self):
         db = self.db1
         version = "0.1"
-        self.assertFalse(db.has_upstream_version(version))
-        self.assertFalse(db.has_upstream_version(version,
+        self.assertFalse(db.has_upstream_version("package", version))
+        self.assertFalse(db.has_upstream_version("package", version,
             [("foo.tar.gz", self.fake_md5_1)]))
         self.do_commit_with_md5(self.up_tree1, "one", self.fake_md5_1)
         db.tag_upstream_version(version)
-        self.assertTrue(db.has_upstream_version(version))
-        self.assertTrue(db.has_upstream_version(
+        self.assertTrue(db.has_upstream_version("package", version))
+        self.assertTrue(db.has_upstream_version("package",
             version, [("foo.tar.gz", self.fake_md5_1)]))
-        self.assertFalse(db.has_upstream_version(version,
+        self.assertFalse(db.has_upstream_version("package", version,
             [("foo.tar.gz", self.fake_md5_2)]))
         version = "0.1"
-        self.assertTrue(db.has_upstream_version(version))
-        self.assertTrue(db.has_upstream_version(version,
+        self.assertTrue(db.has_upstream_version("package", version))
+        self.assertTrue(db.has_upstream_version("package", version,
             [("foo.tar.gz", self.fake_md5_1)]))
-        self.assertFalse(db.has_upstream_version(version,
+        self.assertFalse(db.has_upstream_version("package", version,
             [("foo.tar.gz", self.fake_md5_2)]))
         version = "0.2"
-        self.assertFalse(db.has_upstream_version(version))
-        self.assertFalse(db.has_upstream_version(version,
+        self.assertFalse(db.has_upstream_version("package", version))
+        self.assertFalse(db.has_upstream_version("package", version,
             [("foo.tar.gz", self.fake_md5_1)]))
-        self.assertFalse(db.has_upstream_version(version,
+        self.assertFalse(db.has_upstream_version("package", version,
             [("foo.tar.gz", self.fake_md5_2)]))
 
     def test_revid_of_version(self):
@@ -211,7 +208,8 @@
         version = "0.1"
         revid = tree.commit("one")
         db.tag_upstream_version(version)
-        self.assertEqual(db.revid_of_upstream_version(version), revid)
+        self.assertEqual(
+            db.revid_of_upstream_version("package", version), revid)
 
     def test_contained_versions(self):
         db = self.db1
@@ -401,13 +399,15 @@
         version1 = Version("0.1-1")
         up_revid = self.up_tree1.commit("one")
         db.tag_upstream_version(version1.upstream_version)
-        self.assertEqual(db.get_parents_with_upstream(version1, [version1]),
-                [up_revid])
+        self.assertEqual(
+            db.get_parents_with_upstream("package", version1, [version1]),
+            [up_revid])
         db = self.db2
         self.up_tree2.pull(self.up_tree1.branch)
         db.tag_upstream_version(version1.upstream_version)
-        self.assertEqual(db.get_parents_with_upstream(version1, [version1]),
-                [up_revid])
+        self.assertEqual(
+            db.get_parents_with_upstream("package", version1, [version1]),
+            [up_revid])
 
     def test_get_parents_with_upstream_second_version(self):
         db = self.db1
@@ -418,8 +418,8 @@
         up_revid = self.up_tree1.commit("upstream one")
         db.tag_upstream_version(version1.upstream_version)
         # No upstream parent
-        self.assertEqual(db.get_parents_with_upstream(version2,
-                    [version2, version1]), [revid1])
+        self.assertEqual(db.get_parents_with_upstream(
+            "package", version2, [version2, version1]), [revid1])
 
     def test_get_parents_with_upstream_merge_from_lesser(self):
         version1 = Version("0.1-1")
@@ -435,8 +435,8 @@
         self.db2.tag_upstream_version(version2.upstream_version)
         versions = [version3, version1, version2]
         # No upstream parent
-        self.assertEqual(self.db2.get_parents_with_upstream(version3,
-                    versions), [revid2, revid1])
+        self.assertEqual(self.db2.get_parents_with_upstream(
+            "package", version3, versions), [revid2, revid1])
 
     def test_get_parents_with_upstream_merge_from_greater(self):
         version1 = Version("0.1-1")
@@ -452,8 +452,8 @@
         self.db2.tag_upstream_version(version2.upstream_version)
         versions = [version3, version2, version1]
         # No upstream parent
-        self.assertEqual(self.db1.get_parents_with_upstream(version3,
-                    versions), [revid1, revid2])
+        self.assertEqual(self.db1.get_parents_with_upstream(
+            "package", version3, versions), [revid1, revid2])
 
     def test_get_parents_with_upstream_new_upstream_import(self):
         version1 = Version("0.1-1")
@@ -468,8 +468,8 @@
         self.db2.tag_upstream_version(version2.upstream_version)
         versions = [version2, version1]
         # Upstream parent as it is new upstream version
-        self.assertEqual(self.db2.get_parents_with_upstream(version2,
-                    versions), [revid1, up_revid2])
+        self.assertEqual(self.db2.get_parents_with_upstream(
+            "package", version2, versions), [revid1, up_revid2])
 
     def test_get_parents_merge_new_upstream_from_lesser(self):
         version1 = Version("0.1-1")
@@ -492,8 +492,8 @@
         self.db2.tag_upstream_version(version4.upstream_version)
         versions = [version4, version3, version2, version1]
         # no upstream parent as the lesser branch has already merged it
-        self.assertEqual(self.db2.get_parents_with_upstream(version4,
-                    versions), [revid2, revid3])
+        self.assertEqual(self.db2.get_parents_with_upstream(
+            "package", version4, versions), [revid2, revid3])
 
     def test_get_parents_with_upstream_force_upstream(self):
         version1 = Version("0.1-1")
@@ -507,9 +507,9 @@
         versions = [version2, version1]
         # a previous test checked that this wouldn't give an
         # upstream parent, but we are requiring one.
-        self.assertEqual(self.db2.get_parents_with_upstream(version2,
-                    versions, force_upstream_parent=True),
-                [revid1, up_revid2])
+        self.assertEqual(self.db2.get_parents_with_upstream(
+            "package", version2, versions, force_upstream_parent=True),
+            [revid1, up_revid2])
 
     def test_get_parents_with_upstream_sync_when_diverged(self):
         version1 = Version("0.1-1")
@@ -528,8 +528,8 @@
         versions = [version3, version2, version1]
         # This is a sync but we are diverged so we should get two
         # parents
-        self.assertEqual(self.db2.get_parents_with_upstream(version3,
-                    versions), [revid2, revid3])
+        self.assertEqual(self.db2.get_parents_with_upstream(
+            "package", version3, versions), [revid2, revid3])
 
     def test_get_parents_with_upstream_sync_new_upstream(self):
         version1 = Version("0.1-1")
@@ -551,8 +551,8 @@
         # This a sync, but we are diverged, so we should get two
         # parents. There should be no upstream as the synced
         # version will already have it.
-        self.assertEqual(self.db2.get_parents_with_upstream(version3,
-                    versions), [revid2, revid3])
+        self.assertEqual(self.db2.get_parents_with_upstream(
+            "package", version3, versions), [revid2, revid3])
 
     def test_get_parents_with_upstream_sync_new_upstream_force(self):
         version1 = Version("0.1-1")
@@ -578,8 +578,8 @@
         # checks that there is not normally an upstream parent
         # when we fake-sync, but we are forcing one here.
         #TODO: should the upstream parent be second or third?
-        self.assertEqual(self.db2.get_parents_with_upstream(version3,
-                    versions, force_upstream_parent=True),
+        self.assertEqual(self.db2.get_parents_with_upstream(
+            "package", version3, versions, force_upstream_parent=True),
                 [revid2, up_revid3, revid3])
 
     def test_branch_to_pull_version_from(self):
@@ -639,46 +639,48 @@
         version1 = Version("0.1-1")
         version2 = Version("0.2-1")
         # With no versions tagged everything is None
-        branch = self.db2.branch_to_pull_upstream_from(
+        branch = self.db2.branch_to_pull_upstream_from("package",
                 version1.upstream_version, [("foo.tar.gz", self.fake_md5_1)])
         self.assertEqual(branch, None)
-        branch = self.db2.branch_to_pull_upstream_from(
+        branch = self.db2.branch_to_pull_upstream_from("package",
                 version1.upstream_version, [("foo.tar.gz", self.fake_md5_2)])
         self.assertEqual(branch, None)
-        branch = self.db1.branch_to_pull_upstream_from(
+        branch = self.db1.branch_to_pull_upstream_from("package",
                 version1.upstream_version, [("foo.tar.gz", self.fake_md5_1)])
         self.assertEqual(branch, None)
         self.do_commit_with_md5(self.up_tree1, "one", self.fake_md5_1)
         self.db1.tag_upstream_version(version1.upstream_version)
         # Version and md5 available, so we get the correct branch.
-        branch = self.db2.branch_to_pull_upstream_from(
+        branch = self.db2.branch_to_pull_upstream_from("package",
                 version1.upstream_version, [("foo.tar.gz", self.fake_md5_1)])
         self.assertEqual(branch, self.db1)
         # Otherwise (different version or md5) then we get None
-        branch = self.db2.branch_to_pull_upstream_from(
+        branch = self.db2.branch_to_pull_upstream_from("package",
                 version1.upstream_version, [("foo.tar.gz", self.fake_md5_2)])
         self.assertEqual(branch, None)
-        branch = self.db2.branch_to_pull_upstream_from(version2.upstream_version,
+        branch = self.db2.branch_to_pull_upstream_from("package",
+                version2.upstream_version,
                 [("foo.tar.gz", self.fake_md5_1)])
         self.assertEqual(branch, None)
-        branch = self.db2.branch_to_pull_upstream_from(version2.upstream_version,
+        branch = self.db2.branch_to_pull_upstream_from("package",
+                version2.upstream_version,
                 [("foo.tar.gz", self.fake_md5_2)])
         self.assertEqual(branch, None)
         # And we don't get a branch for the one that already has
         # the version
-        branch = self.db1.branch_to_pull_upstream_from(
+        branch = self.db1.branch_to_pull_upstream_from("package",
                 version1.upstream_version, [("foo.tar.gz", self.fake_md5_1)])
         self.assertEqual(branch, None)
         self.up_tree2.pull(self.up_tree1.branch)
         self.db2.tag_upstream_version(version1.upstream_version)
         # And we get the greatest branch when two lesser branches
         # have what we are looking for.
-        branch = self.db3.branch_to_pull_upstream_from(
+        branch = self.db3.branch_to_pull_upstream_from("package",
                 version1.upstream_version, [("foo.tar.gz", self.fake_md5_1)])
         self.assertEqual(branch, self.db2)
         # If the branches have diverged then we don't get a branch.
         self.up_tree3.commit("three")
-        branch = self.db3.branch_to_pull_upstream_from(
+        branch = self.db3.branch_to_pull_upstream_from("package",
                 version1.upstream_version, [("foo.tar.gz", self.fake_md5_1)])
         self.assertEqual(branch, None)
 
@@ -693,12 +695,12 @@
         revid = self.do_commit_with_md5(self.tree1, "one", self.fake_md5_2)
         self.db1.tag_version(version)
         self.assertNotEqual(self.tree2.branch.last_revision(), revid)
-        self.db2.pull_version_from_branch(self.db1, version)
+        self.db2.pull_version_from_branch(self.db1, "package", version)
         self.assertEqual(self.tree2.branch.last_revision(), revid)
         self.assertEqual(self.up_tree2.branch.last_revision(), up_revid)
         self.assertEqual(self.db2.revid_of_version(version), revid)
         self.assertEqual(self.db2.revid_of_upstream_version(
-            version.upstream_version), up_revid)
+            "package", version.upstream_version), up_revid)
 
     def test_pull_from_lesser_branch_with_upstream(self):
         version = Version("0.1-1")
@@ -709,12 +711,12 @@
         self.db1.tag_version(version)
         self.assertNotEqual(self.tree2.branch.last_revision(), revid)
         self.assertNotEqual(self.up_tree2.branch.last_revision(), up_revid)
-        self.db2.pull_version_from_branch(self.db1, version)
+        self.db2.pull_version_from_branch(self.db1, "package", version)
         self.assertEqual(self.tree2.branch.last_revision(), revid)
         self.assertEqual(self.up_tree2.branch.last_revision(), up_revid)
         self.assertEqual(self.db2.revid_of_version(version), revid)
         self.assertEqual(self.db2.revid_of_upstream_version(
-            version.upstream_version), up_revid)
+            "package", version.upstream_version), up_revid)
 
     def test_pull_upstream_from_branch(self):
         version = "0.1"
@@ -722,9 +724,9 @@
                 self.fake_md5_1)
         self.db1.tag_upstream_version(version)
         self.assertNotEqual(self.up_tree2.branch.last_revision(), up_revid)
-        self.db2.pull_upstream_from_branch(self.db1, version)
+        self.db2.pull_upstream_from_branch(self.db1, "package", version)
         self.assertEqual(self.up_tree2.branch.last_revision(), up_revid)
-        self.assertEqual(self.db2.revid_of_upstream_version(version),
+        self.assertEqual(self.db2.revid_of_upstream_version("package", version),
                 up_revid)
 
     def check_changes(self, changes, added=[], removed=[], modified=[],
@@ -781,7 +783,7 @@
         rh = branch.revision_history()
         self.assertEqual(len(rh), 1)
         self.assertEqual(self.db1.revid_of_upstream_version(
-            version.upstream_version), rh[0])
+            "package", version.upstream_version), rh[0])
         rev = branch.repository.get_revision(rh[0])
         self.assertEqual(rev.message,
                 "Import upstream version %s" % str(version.upstream_version))
@@ -817,7 +819,8 @@
         branch = tree.branch
         rh = branch.revision_history()
         self.assertEqual(len(rh), 2)
-        self.assertEqual(self.db1.revid_of_upstream_version(version2.upstream_version), rh[1])
+        self.assertEqual(
+            self.db1.revid_of_upstream_version("package", version2.upstream_version), rh[1])
         rev = branch.repository.get_revision(rh[1])
         self.assertEqual(rev.message,
                 "Import upstream version %s" % str(version2.upstream_version))
@@ -849,7 +852,7 @@
         rh = branch.revision_history()
         self.assertEqual(len(rh), 1)
         self.assertEqual(self.db1.revid_of_upstream_version(
-            version.upstream_version), rh[0])
+            "package", version.upstream_version), rh[0])
         rev = branch.repository.get_revision(rh[0])
         self.assertEqual(rev.message,
                 "Import upstream version %s" % str(version.upstream_version))
@@ -877,7 +880,7 @@
         rh = branch.revision_history()
         self.assertEqual(len(rh), 1)
         self.assertEqual(self.db1.revid_of_upstream_version(
-            version.upstream_version), rh[0])
+            "package", version.upstream_version), rh[0])
         rev = branch.repository.get_revision(rh[0])
         self.assertEqual(rev.message,
                 "Import upstream version %s" % str(version.upstream_version))
@@ -1316,8 +1319,8 @@
         self.assertEqual(self.db1.revid_of_version(version2), rh1[2])
         self.assertEqual(self.db1.revid_of_version(version3), rh1[3])
         self.assertEqual(
-                self.db1.revid_of_upstream_version(version1.upstream_version),
-                up_rh1[0])
+            self.db1.revid_of_upstream_version("package", version1.upstream_version),
+            up_rh1[0])
         self.tree1.lock_read()
         self.addCleanup(self.tree1.unlock)
         self.assertFalse(self.db1.is_version_native(version1))
@@ -1369,11 +1372,11 @@
         self.assertEqual(self.db1.revid_of_version(version2), rh1[2])
         self.assertEqual(self.db1.revid_of_version(version3), rh1[3])
         self.assertEqual(
-                self.db1.revid_of_upstream_version(version1.upstream_version),
-                up_rh1[0])
+            self.db1.revid_of_upstream_version("package", version1.upstream_version),
+            up_rh1[0])
         self.assertEqual(
-                self.db1.revid_of_upstream_version(version3.upstream_version),
-                up_rh1[1])
+            self.db1.revid_of_upstream_version("package", version3.upstream_version),
+            up_rh1[1])
         self.tree1.lock_read()
         self.addCleanup(self.tree1.unlock)
         self.assertFalse(self.db1.is_version_native(version1))
@@ -1424,11 +1427,11 @@
         self.assertEqual(self.db1.revid_of_version(version2), rh1[2])
         self.assertEqual(self.db1.revid_of_version(version3), rh1[3])
         self.assertEqual(
-                self.db1.revid_of_upstream_version(version1.upstream_version),
-                up_rh1[0])
+            self.db1.revid_of_upstream_version("package", version1.upstream_version),
+            up_rh1[0])
         self.assertEqual(
-                self.db1.revid_of_upstream_version(version3.upstream_version),
-                up_rh1[1])
+            self.db1.revid_of_upstream_version("package", version3.upstream_version),
+            up_rh1[1])
         self.tree1.lock_read()
         self.addCleanup(self.tree1.unlock)
         self.assertFalse(self.db1.is_version_native(version1))

=== modified file 'tests/test_merge_package.py'
--- tests/test_merge_package.py	2011-06-13 23:01:14 +0000
+++ tests/test_merge_package.py	2011-06-15 16:39:26 +0000
@@ -120,10 +120,10 @@
         v3 = "1.2"
         v4 = "1.10"
         db1 = DistributionBranch(ubup.branch, ubup.branch)
-        self.assertEqual(db1.has_upstream_version(v3), True)
+        self.assertEqual(db1.has_upstream_version("package", v3), True)
         # This version is in the diverged debian upstream tree and will
         # hence not be present in the target ubuntu packaging branch.
-        self.assertEqual(db1.has_upstream_version(v4), False)
+        self.assertEqual(db1.has_upstream_version("package", v4), False)
 
         # The ubuntu upstream branch tip.
         ubuu_tip = ubuu.branch.revision_history()[-1]
@@ -143,11 +143,11 @@
 
         # Check the versions present in the tree with the fixed ancestry.
         db2 = DistributionBranch(ubup.branch, ubup.branch)
-        self.assertEqual(db2.has_upstream_version(v3), True)
+        self.assertEqual(db2.has_upstream_version("package", v3), True)
         # The ancestry has been fixed and the missing debian upstream
         # version should now be present in the target ubuntu packaging
         # branch.
-        self.assertEqual(db2.has_upstream_version(v4), True)
+        self.assertEqual(db2.has_upstream_version("package", v4), True)
 
         # Now let's take a look at the fixed ubuntu packaging branch.
         ubup_tip_post_fix = ubup.branch.revision_history()[-1]

=== modified file 'tests/test_util.py'
--- tests/test_util.py	2011-06-13 23:01:14 +0000
+++ tests/test_util.py	2011-06-15 16:39:26 +0000
@@ -24,6 +24,7 @@
     import md5
 import os
 import shutil
+import tarfile
 
 try:
     from debian.changelog import Changelog, Version
@@ -40,6 +41,7 @@
 from bzrlib.plugins.builddeb.errors import (MissingChangelogError,
     AddChangelogError,
     InconsistentSourceFormatError,
+    MultipleUpstreamTarballsNotSupported,
     NoPreviousUpload,
     )
 from bzrlib.plugins.builddeb.tests import (
@@ -50,6 +52,7 @@
 from bzrlib.plugins.builddeb.util import (
     dget,
     dget_changes,
+    extract_orig_tarballs,
     find_bugs_fixed,
     find_changelog,
     find_extra_authors,
@@ -837,3 +840,46 @@
         self.assertEquals(
             "Inconsistency between source format and version: version is not native, "
             "format is native.", str(e))
+
+
+class TestExtractOrigTarballs(TestCaseInTempDir):
+
+    def create_tarball(self, package, version, compression, part=None):
+        basedir = "%s-%s" % (package, version)
+        os.mkdir(basedir)
+        try:
+            f = open(os.path.join(basedir, "README"), 'w')
+            try:
+                f.write("Hi\n")
+            finally:
+                f.close()
+            tar_path = os.path.abspath("%s_%s.orig.tar.%s" % (package, version,
+                compression))
+            tf = tarfile.open(tar_path, 'w:%s' % compression)
+            try:
+                tf.add(basedir)
+            finally:
+                tf.close()
+        finally:
+            shutil.rmtree(basedir)
+        return tar_path
+
+    def test_single_orig_tar_gz(self):
+        tar_path = self.create_tarball("package", "0.1", "gz")
+        os.mkdir("target")
+        extract_orig_tarballs([tar_path], "target", strip_components=1)
+        self.assertEquals(os.listdir("target"), ["README"])
+
+    def test_single_orig_tar_bz2(self):
+        tar_path = self.create_tarball("package", "0.1", "bz2")
+        os.mkdir("target")
+        extract_orig_tarballs([tar_path], "target", strip_components=1)
+        self.assertEquals(os.listdir("target"), ["README"])
+
+    def test_multiple_tarballs(self):
+        base_tar_path = self.create_tarball("package", "0.1", "bz2")
+        tar_path_extra = self.create_tarball("package", "0.1", "bz2", part="extra")
+        os.mkdir("target")
+        self.assertRaises(MultipleUpstreamTarballsNotSupported,
+            extract_orig_tarballs,
+            [base_tar_path, tar_path_extra], "target")

=== modified file 'upstream/pristinetar.py'
--- upstream/pristinetar.py	2011-06-14 12:26:21 +0000
+++ upstream/pristinetar.py	2011-06-15 16:39:26 +0000
@@ -29,6 +29,7 @@
 import tempfile
 
 from bzrlib.plugins.builddeb.errors import (
+    MultipleUpstreamTarballsNotSupported,
     PackageVersionNotPresent,
     PerFileTimestampsNotSupported,
     )
@@ -114,6 +115,9 @@
         self.branch = branch
         self.tree = tree
 
+    def __repr__(self):
+        return "<%s at %s>" % (self.__class__.__name__, self.branch.base)
+
     def tag_name(self, version, distro=None):
         """Gets the tag name for the upstream part of version.
 
@@ -147,7 +151,7 @@
             raise PackageVersionNotPresent(package, version, self)
         return [target_filename]
 
-    def _has_version(self, tag_name, md5=None):
+    def _has_version(self, tag_name, tarballs=None):
         if not self.branch.tags.has_tag(tag_name):
             return False
         revid = self.branch.tags.lookup_tag(tag_name)
@@ -158,8 +162,11 @@
                 return False
         finally:
             self.branch.unlock()
-        if md5 is None:
+        if tarballs is None:
             return True
+        if len(tarballs) != 1:
+            raise MultipleUpstreamTarballsNotSupported()
+        (filename, md5) = tarballs[0]
         rev = self.branch.repository.get_revision(revid)
         try:
             return rev.properties['deb-md5'] == md5
@@ -168,10 +175,10 @@
                 "associated 'deb-md5' property" % tag_name)
             return True
 
-    def version_as_revision(self, package, version):
+    def version_as_revision(self, package, version, tarballs=None):
         assert isinstance(version, str)
         for tag_name in self.possible_tag_names(version):
-            if self._has_version(tag_name):
+            if self._has_version(tag_name, tarballs):
                 return self.branch.tags.lookup_tag(tag_name)
         tag_name = self.tag_name(version)
         try:
@@ -179,10 +186,10 @@
         except NoSuchTag:
             raise PackageVersionNotPresent(package, version, self)
 
-    def has_version(self, package, version, md5=None):
+    def has_version(self, package, version, tarballs=None):
         assert isinstance(version, str), str(type(version))
         for tag_name in self.possible_tag_names(version):
-            if self._has_version(tag_name, md5=md5):
+            if self._has_version(tag_name, tarballs=tarballs):
                 return True
         return False