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

[Jelmer Vernooij]

Importing and building of packages with multiple upstream tarballs now works.

There are still two caveats:

 * when exporting the base component before generating a pristine tar delta, we don't exclude non-base components. This probably causes the pristine tar delta to be bigger than it needs to be
 * Needs more tests

[lp:~jelmer/bzr-builddeb/multiple-upstream-tarballs]

625. By Jelmer Vernooij on 2011-10-03

merge lp:bzr-builddeb.

Unmerged revisions

=== modified file 'cmds.py'
--- cmds.py	2011-09-09 13:20:42 +0000
+++ cmds.py	2011-09-27 00:50:26 +0000
@@ -556,7 +556,7 @@
                     'entry yourself, review the merge, and then commit.')
 
     def _do_merge(self, tree, tarball_filenames, package, version,
-            current_version, upstream_branch, upstream_revision, merge_type,
+            current_version, upstream_branch, upstream_revisions, merge_type,
             force):
         db = DistributionBranch(tree.branch, tree.branch, tree=tree)
         dbs = DistributionBranchSet()
@@ -565,7 +565,7 @@
                 in tarball_filenames]
         conflicts = db.merge_upstream(tarballs, package, version,
                 current_version, upstream_branch=upstream_branch,
-                upstream_revision=upstream_revision,
+                upstream_revisions=upstream_revisions,
                 merge_type=merge_type, force=force)
         return conflicts
 
@@ -712,15 +712,15 @@
                     raise BzrCommandError("merge-upstream takes only a "
                         "single --revision")
                 upstream_revspec = revision[0]
-                upstream_revision = upstream_revspec.as_revision_id(
-                    upstream_branch)
+                upstream_revisions = { None: upstream_revspec.as_revision_id(
+                    upstream_branch) }
             else:
-                upstream_revision = None
+                upstream_revisions = None
 
-            if version is None and upstream_revision is not None:
+            if version is None and upstream_revisions is not None:
                 # Look up the version from the upstream revision
                 version = upstream_branch_source.get_version(package,
-                    current_version, upstream_revision)
+                    current_version, upstream_revisions)
             elif version is None and primary_upstream_source is not None:
                 version = primary_upstream_source.get_latest_version(
                     package, current_version)
@@ -735,9 +735,9 @@
             assert isinstance(version, str)
             note("Using version string %s." % (version))
             # Look up the revision id from the version string
-            if upstream_revision is None and upstream_branch_source is not None:
+            if upstream_revisions is None and upstream_branch_source is not None:
                 try:
-                    upstream_revision = upstream_branch_source.version_as_revision(
+                    upstream_revisions = upstream_branch_source.version_as_revisions(
                         package, version)
                 except PackageVersionNotPresent:
                     raise BzrCommandError(
@@ -748,15 +748,15 @@
             if need_upstream_tarball:
                 target_dir = tempfile.mkdtemp() # FIXME: Cleanup?
                 locations = primary_upstream_source.fetch_tarballs(
-                    package, version, target_dir)
+                    package, version, target_dir, components=[None])
                 source_format = get_source_format(tree)
                 v3 = (source_format in [
                     FORMAT_3_0_QUILT, FORMAT_3_0_NATIVE])
                 tarball_filenames = self._get_tarballs(config, tree, package,
-                    version, upstream_branch, upstream_revision, v3,
+                    version, upstream_branch, upstream_revisions, v3,
                     locations)
                 conflicts = self._do_merge(tree, tarball_filenames, package,
-                    version, current_version, upstream_branch, upstream_revision,
+                    version, current_version, upstream_branch, upstream_revisions,
                     merge_type, force)
             if (current_version is not None and
                 Version(current_version) >= Version(version)):
@@ -886,9 +886,9 @@
                             "sure it is tagged as %r." % (last_version,
                                     db.pristine_upstream_source.tag_name(
                                         last_version.upstream_version)))
-                    upstream_tip = db.pristine_upstream_source.version_as_revision(
+                    upstream_tips = db.pristine_upstream_source.version_as_revisions(
                         changelog.package, last_version.upstream_version)
-                    db.extract_upstream_tree(upstream_tip, tempdir)
+                    db.extract_upstream_tree(upstream_tips, tempdir)
                 else:
                     db._create_empty_upstream_tree(tempdir)
                 self.import_many(db, files_list, orig_target)
@@ -955,19 +955,24 @@
         if db.pristine_upstream_source.has_version(None, version):
             raise BzrCommandError("Version %s is already present." % version)
         tagged_versions = {}
-        for tag, tag_version, revid in db.pristine_upstream_source.iter_versions():
-            tagged_versions[Version(tag_version)] = revid
+        for tversion, tcomponents in db.pristine_upstream_source.iter_versions():
+            tagged_versions[Version(version)] = tcomponents
         tag_order = sorted(tagged_versions.keys())
         if tag_order:
-            parents = [tagged_versions[tag_order[-1]]]
+            base_revisions = tagged_versions[tag_order[-1]]
         else:
-            parents = []
-        if parents:
+            base_revisions = {}
+        if base_revisions:
             if upstream is not None:
                 # See bug lp:309682
-                upstream.repository.fetch(branch.repository, parents[0])
-            db.extract_upstream_tree(parents[0], tempdir)
+                for parent in base_revisions.values():
+                    upstream.repository.fetch(branch.repository, parent)
+            db.extract_upstream_tree(base_revisions, tempdir)
+            parents = {}
+            for name, base_revid in base_revisions.iteritems():
+                parents[name] = [base_revid]
         else:
+            parents = {}
             db._create_empty_upstream_tree(tempdir)
         tree = db.branch.basis_tree()
         tree.lock_read()
@@ -983,7 +988,7 @@
         tarballs = [(location, None, md5sum_filename(location))]
         for (component, tag_name, revid) in db.import_upstream_tarballs(
                 tarballs, None, version, parents, upstream_branch=upstream,
-                upstream_revision=upstream_revid):
+                upstream_revisions={ None: upstream_revid }):
             if component is None:
                 self.outf.write('Imported %s as tag:%s.\n' % (
                     location, tag_name))
@@ -1224,9 +1229,8 @@
                 dh_make.run_dh_make(tree, package_name, version, use_v3=v3)
             finally:
                 tree.unlock()
-        note('Package prepared in %s'
-                % urlutils.unescape_for_display(tree.basedir,
-                    self.outf.encoding))
+        note('Package prepared in %s',
+            urlutils.unescape_for_display(tree.basedir, self.outf.encoding))
 
 
 class cmd_dep3_patch(Command):
 
=== modified file 'debian/changelog'
--- debian/changelog	2011-09-09 13:21:35 +0000
+++ debian/changelog	2011-09-27 00:50:26 +0000
@@ -1,8 +1,10 @@
 bzr-builddeb (2.7.9) UNRELEASED; urgency=low
 
   * Support .tar.xz Debian files rather than .tar.lzma.
+  * Support importing and building packages with multiple upstream
+    tarballs. LP: #653757, LP: #664834
 
- -- Jelmer Vernooij <[e-mail]>  Fri, 09 Sep 2011 15:21:22 +0200
+ -- Jelmer Vernooij <[e-mail]>  Tue, 27 Sep 2011 02:40:03 +0200
 
 bzr-builddeb (2.7.8) unstable; urgency=low
 
 
=== modified file 'dh_make.py'
--- dh_make.py	2011-09-09 13:20:42 +0000
+++ dh_make.py	2011-09-27 00:50:26 +0000
@@ -79,9 +79,9 @@
 def import_upstream(tarball, package_name, version, use_v3=False):
     tree = _get_tree(package_name)
     if tree.branch.last_revision() != mod_revision.NULL_REVISION:
-        parents = [tree.branch.last_revision()]
+        parents = { None: [tree.branch.last_revision()] }
     else:
-        parents = []
+        parents = {}
     tarball_filenames  = _get_tarballs(tree, tarball,
             package_name, version, use_v3=use_v3)
     db = import_dsc.DistributionBranch(tree.branch, tree.branch, tree=tree,
 
=== modified file 'import_dsc.py'
--- import_dsc.py	2011-09-09 13:20:42 +0000
+++ import_dsc.py	2011-09-27 00:50:26 +0000
@@ -60,6 +60,7 @@
 
 from bzrlib.plugins.builddeb.bzrtools_import import import_dir
 from bzrlib.plugins.builddeb.errors import (
+    MultipleUpstreamTarballsNotSupported,
     PackageVersionNotPresent,
     UpstreamAlreadyImported,
     UpstreamBranchAlreadyMerged,
@@ -556,6 +557,7 @@
                 tarballs=upstream_tarballs):
             return False
 
+
         up_branch = self.pristine_upstream_branch
         up_branch.lock_read()
         try:
@@ -563,10 +565,14 @@
             other_up_branch = branch.pristine_upstream_branch
             other_up_branch.lock_read()
             try:
+                pristine_upstream_revids = branch.pristine_upstream_source.version_as_revisions(package, version)
+                if pristine_upstream_revids.keys() != [None]:
+                    raise MultipleUpstreamTarballsNotSupported()
+                pristine_upstream_revid = pristine_upstream_revids[None]
                 graph = other_up_branch.repository.get_graph(
                         up_branch.repository)
                 return graph.is_ancestor(up_branch.last_revision(),
-                        branch.pristine_upstream_source.version_as_revision(package, version))
+                        pristine_upstream_revid)
             finally:
                 other_up_branch.unlock()
         finally:
@@ -680,7 +686,11 @@
         :param version: the upstream version string
         """
         assert isinstance(version, str)
-        pull_revision = pull_branch.pristine_upstream_source.version_as_revision(package, version)
+        pull_revisions = pull_branch.pristine_upstream_source.version_as_revisions(
+            package, version)
+        if pull_revisions.keys() != [None]:
+            raise MultipleUpstreamTarballsNotSupported()
+        pull_revision = pull_revisions[None]
         mutter("Pulling upstream part of %s from revision %s" % \
                 (version, pull_revision))
         assert self.pristine_upstream_tree is not None, \
@@ -774,12 +784,17 @@
                     break
         real_parents = [p[2] for p in parents]
         if need_upstream_parent:
-            parent_revid = self.pristine_upstream_source.version_as_revision(package,
-                version.upstream_version, tarballs)
-            if len(parents) > 0:
-                real_parents.insert(1, parent_revid)
-            else:
-                real_parents = [parent_revid]
+            upstream_revids = self.pristine_upstream_source.version_as_revisions(
+                package, version.upstream_version, tarballs)
+            def key(a):
+                if a is None:
+                    return None
+                return a
+            for component in sorted(upstream_revids.keys(), key=key):
+                if len(real_parents) > 0:
+                    real_parents.insert(1, upstream_revids[component])
+                else:
+                    real_parents = [upstream_revids[component]]
         return real_parents
 
     def _fetch_upstream_to_branch(self, revid):
@@ -793,7 +808,7 @@
 
     def import_upstream(self, upstream_part, package, version, upstream_parents,
             upstream_tarballs, upstream_branch=None,
-            upstream_revision=None, timestamp=None, author=None,
+            upstream_revisions=None, timestamp=None, author=None,
             file_ids_from=None):
         """Import an upstream part on to the upstream branch.
 
@@ -814,25 +829,31 @@
         # TODO: this method needs a lot of work for when we will make
         # the branches writeable by others.
         assert isinstance(version, str)
-        mutter("Importing upstream version %s from %s with parents %s" \
-                % (version, upstream_part, str(upstream_parents)))
+        mutter("Importing upstream version %s from %s with parents %r" \
+                % (version, upstream_part, upstream_parents))
         assert self.pristine_upstream_tree is not None, \
             "Can't import upstream with no tree"
         other_branches = self.get_other_branches()
         ret = []
         for (tarball, component, md5) in upstream_tarballs:
+            parents = upstream_parents.get(component, [])
+            if upstream_revisions is not None:
+                revid = upstream_revisions[component]
+            else:
+                revid = None
             upstream_trees = [o.pristine_upstream_branch.basis_tree()
                 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()
+                if revid is None:
+                    # FIXME: This is wrong for component tarballs
+                    revid = upstream_branch.last_revision()
                 self.pristine_upstream_branch.fetch(upstream_branch,
-                        last_revision=upstream_revision)
+                        last_revision=revid)
                 upstream_branch.tags.merge_to(self.pristine_upstream_branch.tags)
-                upstream_parents.append(upstream_revision)
+                parents.append(revid)
                 target_tree = self.pristine_upstream_branch.repository.revision_tree(
-                            upstream_revision)
+                            revid)
             if file_ids_from is not None:
                 upstream_trees = file_ids_from + upstream_trees
             if self.tree:
@@ -841,8 +862,8 @@
             else:
                 self_tree = self.branch.basis_tree()
                 self_tree.lock_read()
-            if len(upstream_parents) > 0:
-                parent_revid = upstream_parents[0]
+            if len(parents) > 0:
+                parent_revid = parents[0]
             else:
                 parent_revid = NULL_REVISION
             self.pristine_upstream_tree.pull(self.pristine_upstream_tree.branch,
@@ -857,16 +878,22 @@
                         target_tree=target_tree)
             finally:
                 self_tree.unlock()
+            if component is None:
+                exclude = [tb[1] for tb in upstream_tarballs if tb[1] is not None]
+            else:
+                exclude = []
             (tag, revid) = self.pristine_upstream_source.import_component_tarball(
-                package, version, self.pristine_upstream_tree, upstream_parents, component,
-                md5, tarball, author=author, timestamp=timestamp)
+                package, version, self.pristine_upstream_tree, parents,
+                component, md5, tarball, author=author, timestamp=timestamp,
+                exclude=exclude)
+            self.pristine_upstream_branch.generate_revision_history(revid)
             ret.append((component, tag, revid))
             self.branch.fetch(self.pristine_upstream_branch)
             self.branch.tags.set_tag(tag, revid)
         return ret
 
     def import_upstream_tarballs(self, tarballs, package, version, parents,
-        upstream_branch=None, upstream_revision=None):
+        upstream_branch=None, upstream_revisions=None):
         """Import an upstream part to the upstream branch.
 
         :param tarballs: List of tarballs / components to extract
@@ -876,7 +903,7 @@
             parents.
         :param upstream_branch: An upstream branch to associate with the
             tarball.
-        :param upstream_revision: Upstream revision id
+        :param upstream_revisions: Upstream revision ids dictionary
         :param md5sum: hex digest of the md5sum of the tarball, if known.
         :return: list with (component, tag, revid) tuples
         """
@@ -885,7 +912,7 @@
             return self.import_upstream(tarball_dir, package, version, parents,
                 tarballs,
                 upstream_branch=upstream_branch,
-                upstream_revision=upstream_revision)
+                upstream_revisions=upstream_revisions)
         finally:
             shutil.rmtree(tarball_dir)
 
@@ -1052,8 +1079,11 @@
                 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.pristine_upstream_source.version_as_revision(
+                pull_revids = pull_branch.pristine_upstream_source.version_as_revisions(
                     package, pull_version.upstream_version)
+                if pull_revids.keys() != [None]:
+                    raise MultipleUpstreamTarballsNotSupported()
+                pull_revid = pull_revids[None]
                 mutter("Initialising upstream from %s, version %s",
                     str(pull_branch), str(pull_version))
                 parents.append(pull_revid)
@@ -1062,7 +1092,8 @@
                         last_revision=pull_revid)
                 pull_branch.pristine_upstream_branch.tags.merge_to(
                         self.pristine_upstream_branch.tags)
-        return parents
+        # FIXME: What about other versions ?
+        return { None: parents }
 
     def get_changelog_from_source(self, dir):
         cl_filename = os.path.join(dir, "debian", "changelog")
@@ -1245,16 +1276,16 @@
         finally:
             extractor.cleanup()
 
-    def extract_upstream_tree(self, upstream_tip, basedir):
+    def extract_upstream_tree(self, upstream_tips, basedir):
         """Extract upstream_tip to a tempdir as a working tree."""
         # TODO: should stack rather than trying to use the repository,
         # as that will be more efficient.
-        # 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.pristine_upstream_branch or self.branch
+        assert upstream_tips.keys() == [None]
         dir_to = source_branch.bzrdir.sprout(to_location,
-                revision_id=upstream_tip,
+                revision_id=upstream_tips[None],
                 accelerator_tree=self.tree)
         try:
             self.pristine_upstream_tree = dir_to.open_workingtree()
@@ -1263,8 +1294,6 @@
             self.pristine_upstream_tree = dir_to.create_workingtree()
         self.pristine_upstream_branch = self.pristine_upstream_tree.branch
 
-    _extract_upstream_tree = extract_upstream_tree
-
     def _create_empty_upstream_tree(self, basedir):
         to_location = os.path.join(basedir, "upstream")
         to_transport = get_transport(to_location)
@@ -1314,7 +1343,7 @@
         assert isinstance(previous_version, str), \
             "Should pass upstream version as str, not Version."
         try:
-            upstream_tip = self.pristine_upstream_source.version_as_revision(
+            upstream_tips = self.pristine_upstream_source.version_as_revisions(
                     package, previous_version)
         except PackageVersionNotPresent:
             raise BzrCommandError("Unable to find the tag for the "
@@ -1322,10 +1351,16 @@
                     "%s" % (
                 previous_version,
                 self.pristine_upstream_source.tag_name(previous_version)))
-        self.extract_upstream_tree(upstream_tip, tempdir)
+        self.extract_upstream_tree(upstream_tips, tempdir)
+
+    def has_merged_upstream_revisions(self, this_revision, upstream_repository, upstream_revisions):
+        graph = self.branch.repository.get_graph(
+            other_repository=upstream_repository)
+        return all(graph.is_ancestor(upstream_revision, this_revision)
+                for upstream_revision in upstream_revisions.values())
 
     def merge_upstream(self, tarball_filenames, package, version, previous_version,
-            upstream_branch=None, upstream_revision=None, merge_type=None,
+            upstream_branch=None, upstream_revisions=None, merge_type=None,
             force=False):
         assert isinstance(version, str), \
             "Should pass version as str not %s" % str(type(version))
@@ -1344,12 +1379,10 @@
                 upstream_branch.lock_read()
             try:
                 if upstream_branch is not None:
-                    if upstream_revision is None:
-                        upstream_revision = upstream_branch.last_revision()
-                    graph = self.branch.repository.get_graph(
-                            other_repository=upstream_branch.repository)
-                    if not force and graph.is_ancestor(upstream_revision,
-                            self.branch.last_revision()):
+                    if upstream_revisions is None:
+                        upstream_revisions = { None: upstream_branch.last_revision() }
+                    if (not force and
+                        self.has_merged_upstream_revisions(self.branch.last_revision(), upstream_branch.repository, upstream_revisions)):
                         raise UpstreamBranchAlreadyMerged
                 upstream_tarballs = [
                     (os.path.abspath(fn), component, md5sum_filename(fn)) for
@@ -1358,13 +1391,14 @@
                 tarball_dir = self._extract_tarballs_to_tempdir(upstream_tarballs)
                 try:
                     # FIXME: should use upstream_parents()?
-                    parents = []
+                    parents = { None: [] }
                     if self.pristine_upstream_branch.last_revision() != NULL_REVISION:
-                        parents = [self.pristine_upstream_branch.last_revision()]
+                        parents = { None: [self.pristine_upstream_branch.last_revision()] }
                     for (component, tag, revid) in self.import_upstream(tarball_dir,
-                            package, version, parents, upstream_tarballs=upstream_tarballs,
+                            package, version, parents,
+                            upstream_tarballs=upstream_tarballs,
                             upstream_branch=upstream_branch,
-                            upstream_revision=upstream_revision):
+                            upstream_revisions=upstream_revisions):
                         self._fetch_upstream_to_branch(revid)
                 finally:
                     shutil.rmtree(tarball_dir)
@@ -1377,10 +1411,10 @@
                         # missing a proper history link and a criss-cross merge
                         # then recurses and finds no deeper ancestor.
                         # Use the previous upstream import as the from revision
-                        if len(parents) == 0:
+                        if len(parents[None]) == 0:
                             from_revision = NULL_REVISION
                         else:
-                            from_revision = parents[0]
+                            from_revision = parents[None][0]
                         conflicts = self.tree.merge_from_branch(
                                 self.pristine_upstream_branch, merge_type=merge_type,
                                 from_revision=from_revision)
 
=== modified file 'merge_package.py'
--- merge_package.py	2011-06-15 13:21:22 +0000
+++ merge_package.py	2011-09-27 00:50:26 +0000
@@ -31,7 +31,9 @@
     from debian_bundle.changelog import Version
 
 from bzrlib.plugins.builddeb.errors import (
-    SharedUpstreamConflictsWithTargetPackaging)
+    MultipleUpstreamTarballsNotSupported,
+    SharedUpstreamConflictsWithTargetPackaging,
+    )
 from bzrlib.plugins.builddeb.import_dsc import DistributionBranch
 from bzrlib.plugins.builddeb.util import find_changelog
 
@@ -59,8 +61,11 @@
     for branch in (source, target):
         db = DistributionBranch(branch, branch)
         uver = _latest_version(branch).upstream_version
-        results.append((Version(uver),
-                    db.pristine_upstream_source.version_as_revision(None, uver)))
+        upstream_revids = db.pristine_upstream_source.version_as_revisions(None, uver)
+        if upstream_revids.keys() != [None]:
+            raise MultipleUpstreamTarballsNotSupported()
+        upstream_revid = upstream_revids[None]
+        results.append((Version(uver), upstream_revid))
 
     return results
 
@@ -136,7 +141,7 @@
             try:
                 # Extract the merge target's upstream tree into a temporary
                 # directory.
-                db.extract_upstream_tree(ut_revid, tempdir)
+                db.extract_upstream_tree({None: ut_revid}, tempdir)
                 tmp_target_utree = db.pristine_upstream_tree
 
                 # Merge upstream branch tips to obtain a shared upstream parent.
 
=== modified file 'tests/blackbox/test_merge_upstream.py'
--- tests/blackbox/test_merge_upstream.py	2011-07-20 19:14:43 +0000
+++ tests/blackbox/test_merge_upstream.py	2011-09-27 00:50:26 +0000
@@ -98,7 +98,7 @@
             [(self.tar.tarball, None, md5sum_filename(self.tar.tarball))],
             "foo",
             str(self.tar.version),
-            [tree.branch.last_revision()])
+            { None: [tree.branch.last_revision()]} )
         package_builder = SourcePackageBuilder("foo",
             str(self.tar.version)+"-1")
         package_builder.add_default_control()
 
=== modified file 'tests/test_import_dsc.py'
--- tests/test_import_dsc.py	2011-09-09 13:20:42 +0000
+++ tests/test_import_dsc.py	2011-09-27 00:50:26 +0000
@@ -213,14 +213,15 @@
         db.tag_version(version)
         self.assertEqual(db.revid_of_version(version), revid)
 
-    def test_upstream_version_as_revid(self):
+    def test_upstream_versions_as_revid(self):
         db = self.db1
         tree = self.up_tree1
         version = "0.1"
         revid = tree.commit("one")
         db.tag_upstream_version(version)
         self.assertEqual(
-            db.pristine_upstream_source.version_as_revision("package", version), revid)
+            db.pristine_upstream_source.version_as_revisions("package", version), 
+            { None: revid })
 
     def test_contained_versions(self):
         db = self.db1
@@ -710,8 +711,8 @@
         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.pristine_upstream_source.version_as_revision(
-            "package", version.upstream_version), up_revid)
+        self.assertEqual(self.db2.pristine_upstream_source.version_as_revisions(
+            "package", version.upstream_version), {None: up_revid})
 
     def test_pull_from_lesser_branch_with_upstream(self):
         version = Version("0.1-1")
@@ -726,8 +727,8 @@
         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.pristine_upstream_source.version_as_revision(
-            "package", version.upstream_version), up_revid)
+        self.assertEqual(self.db2.pristine_upstream_source.version_as_revisions(
+            "package", version.upstream_version), {None: up_revid})
 
     def test_pull_upstream_from_branch(self):
         version = "0.1"
@@ -737,8 +738,9 @@
         self.assertNotEqual(self.up_tree2.branch.last_revision(), up_revid)
         self.db2.pull_upstream_from_branch(self.db1, "package", version)
         self.assertEqual(self.up_tree2.branch.last_revision(), up_revid)
-        self.assertEqual(self.db2.pristine_upstream_source.version_as_revision("package", version),
-                up_revid)
+        self.assertEqual(
+            self.db2.pristine_upstream_source.version_as_revisions("package", version),
+            {None: up_revid})
 
     def check_changes(self, changes, added=[], removed=[], modified=[],
                       renamed=[]):
@@ -785,7 +787,7 @@
                 element in contents]
         self.build_tree_contents(contents)
         self.db1.import_upstream(basedir, "package", version.upstream_version,
-            [], [(None, None, None)])
+              {}, [(None, None, None)])
         return version
 
     def test_import_upstream(self):
@@ -794,8 +796,8 @@
         branch = tree.branch
         rh = branch.revision_history()
         self.assertEqual(len(rh), 1)
-        self.assertEqual(self.db1.pristine_upstream_source.version_as_revision(
-            "package", version.upstream_version), rh[0])
+        self.assertEqual(self.db1.pristine_upstream_source.version_as_revisions(
+            "package", version.upstream_version), {None: rh[0]})
         rev = branch.repository.get_revision(rh[0])
         self.assertEqual(rev.message,
                 "Import upstream version %s" % str(version.upstream_version))
@@ -819,7 +821,7 @@
         write_to_file(os.path.join(basedir, "README"), "Hi\n")
         write_to_file(os.path.join(basedir, "BUGS"), "")
         write_to_file(os.path.join(basedir, "COPYING"), "")
-        self.db1.import_upstream(basedir, "package", version1.upstream_version, [],
+        self.db1.import_upstream(basedir, "package", version1.upstream_version, {},
             [(None, None, None)])
         basedir = name + "-" + str(version2.upstream_version)
         os.mkdir(basedir)
@@ -827,13 +829,15 @@
         write_to_file(os.path.join(basedir, "BUGS"), "")
         write_to_file(os.path.join(basedir, "NEWS"), "")
         self.db1.import_upstream(basedir, "package", version2.upstream_version,
-                [self.up_tree1.branch.last_revision()], [(None, None, None)])
+                { None: [self.up_tree1.branch.last_revision()] }, [(None, None, None)])
         tree = self.up_tree1
         branch = tree.branch
         rh = branch.revision_history()
         self.assertEqual(len(rh), 2)
         self.assertEqual(
-            self.db1.pristine_upstream_source.version_as_revision("package", version2.upstream_version), rh[1])
+            self.db1.pristine_upstream_source.version_as_revisions(
+                "package", version2.upstream_version),
+            {None: rh[1]})
         rev = branch.repository.get_revision(rh[1])
         self.assertEqual(rev.message,
                 "Import upstream version %s" % str(version2.upstream_version))
@@ -858,14 +862,14 @@
             tf.add(basedir)
         finally:
             tf.close()
-        self.db1.import_upstream(basedir, "package", version.upstream_version, [],
+        self.db1.import_upstream(basedir, "package", version.upstream_version, {},
                 upstream_tarballs=[(os.path.abspath(tar_path), None, self.fake_md5_1)])
         tree = self.up_tree1
         branch = tree.branch
         rh = branch.revision_history()
         self.assertEqual(len(rh), 1)
-        self.assertEqual(self.db1.pristine_upstream_source.version_as_revision(
-            "package", version.upstream_version), rh[0])
+        self.assertEqual(self.db1.pristine_upstream_source.version_as_revisions(
+            "package", version.upstream_version), {None: rh[0]})
         rev = branch.repository.get_revision(rh[0])
         self.assertEqual(rev.message,
                 "Import upstream version %s" % str(version.upstream_version))
@@ -887,13 +891,13 @@
         finally:
             tf.close()
         self.db1.import_upstream(basedir, "package", version.upstream_version,
-            [], upstream_tarballs=[(os.path.abspath(tar_path), None, self.fake_md5_1)])
+            {}, upstream_tarballs=[(os.path.abspath(tar_path), None, self.fake_md5_1)])
         tree = self.up_tree1
         branch = tree.branch
         rh = branch.revision_history()
         self.assertEqual(len(rh), 1)
-        self.assertEqual(self.db1.pristine_upstream_source.version_as_revision(
-            "package", version.upstream_version), rh[0])
+        self.assertEqual(self.db1.pristine_upstream_source.version_as_revisions(
+            "package", version.upstream_version), {None: rh[0]})
         rev = branch.repository.get_revision(rh[0])
         self.assertEqual(rev.message,
                 "Import upstream version %s" % str(version.upstream_version))
@@ -936,13 +940,13 @@
         finally:
             f.close()
         self.db1.import_upstream(basedir, "package", version.upstream_version,
-            [], upstream_tarballs=[(os.path.abspath(tar_path), None, self.fake_md5_1)])
+            {}, upstream_tarballs=[(os.path.abspath(tar_path), None, self.fake_md5_1)])
         tree = self.up_tree1
         branch = tree.branch
         rh = branch.revision_history()
         self.assertEqual(len(rh), 1)
-        self.assertEqual(self.db1.pristine_upstream_source.version_as_revision(
-            "package", version.upstream_version), rh[0])
+        self.assertEqual(self.db1.pristine_upstream_source.version_as_revisions(
+            "package", version.upstream_version), {None: rh[0]})
         rev = branch.repository.get_revision(rh[0])
         self.assertEqual(rev.message,
                 "Import upstream version %s" % str(version.upstream_version))
@@ -1381,8 +1385,9 @@
         self.assertEqual(self.db1.revid_of_version(version2), rh1[2])
         self.assertEqual(self.db1.revid_of_version(version3), rh1[3])
         self.assertEqual(
-            self.db1.pristine_upstream_source.version_as_revision("package", version1.upstream_version),
-            up_rh1[0])
+            self.db1.pristine_upstream_source.version_as_revisions(
+                "package", version1.upstream_version),
+            {None: up_rh1[0]})
         self.tree1.lock_read()
         self.addCleanup(self.tree1.unlock)
         self.assertFalse(self.db1.is_version_native(version1))
@@ -1434,11 +1439,13 @@
         self.assertEqual(self.db1.revid_of_version(version2), rh1[2])
         self.assertEqual(self.db1.revid_of_version(version3), rh1[3])
         self.assertEqual(
-            self.db1.pristine_upstream_source.version_as_revision("package", version1.upstream_version),
-            up_rh1[0])
+            self.db1.pristine_upstream_source.version_as_revisions("package",
+                version1.upstream_version),
+            {None: up_rh1[0]})
         self.assertEqual(
-            self.db1.pristine_upstream_source.version_as_revision("package", version3.upstream_version),
-            up_rh1[1])
+            self.db1.pristine_upstream_source.version_as_revisions("package",
+                version3.upstream_version),
+            {None: up_rh1[1]})
         self.tree1.lock_read()
         self.addCleanup(self.tree1.unlock)
         self.assertFalse(self.db1.is_version_native(version1))
@@ -1489,11 +1496,13 @@
         self.assertEqual(self.db1.revid_of_version(version2), rh1[2])
         self.assertEqual(self.db1.revid_of_version(version3), rh1[3])
         self.assertEqual(
-            self.db1.pristine_upstream_source.version_as_revision("package", version1.upstream_version),
-            up_rh1[0])
+            self.db1.pristine_upstream_source.version_as_revisions("package",
+                version1.upstream_version),
+            { None: up_rh1[0] })
         self.assertEqual(
-            self.db1.pristine_upstream_source.version_as_revision("package", version3.upstream_version),
-            up_rh1[1])
+            self.db1.pristine_upstream_source.version_as_revisions("package",
+                version3.upstream_version),
+            { None: up_rh1[1] })
         self.tree1.lock_read()
         self.addCleanup(self.tree1.unlock)
         self.assertFalse(self.db1.is_version_native(version1))
@@ -1604,7 +1613,7 @@
             tf.close()
         conflicts = db.merge_upstream([(tarball_filename, None)], "foo", "0.2", "0.1",
             upstream_branch=upstream_tree.branch,
-            upstream_revision=upstream_rev)
+            upstream_revisions={None: upstream_rev})
         self.assertEqual(0,  conflicts)
 
     def test_merge_upstream_initial_with_removed_debian(self):
@@ -1644,7 +1653,7 @@
             tf.close()
         conflicts = db.merge_upstream([(tarball_filename, None)], "foo", "0.2", "0.1",
             upstream_branch=upstream_tree.branch,
-            upstream_revision=upstream_rev)
+            upstream_revisions={None: upstream_rev})
         # ./debian conflicts.
         self.assertEqual(3,  conflicts)
 
@@ -1686,7 +1695,7 @@
         db.merge_upstream([(builder.tar_name(), None)], "package", str(version2),
             version1.upstream_version,
             upstream_branch=upstream_tree.branch,
-            upstream_revision=upstream_rev)
+            upstream_revisions={None: upstream_rev})
         rh1 = tree.branch.revision_history()
         self.assertEqual(2, len(rh1))
         packaging_upstream_tip = tree.get_parent_ids()[1]
@@ -1765,7 +1774,7 @@
             version2.upstream_version,
             version1.upstream_version,
             upstream_branch=upstream_tree.branch,
-            upstream_revision=upstream_rev2)
+            upstream_revisions={None: upstream_rev2})
         self.assertEqual("a-id", tree.path2id("b"))
 
     def test_merge_upstream_rename_on_top(self):
@@ -1802,7 +1811,7 @@
             version2.upstream_version,
             version1.upstream_version,
             upstream_branch=upstream_tree.branch,
-            upstream_revision=upstream_rev2)
+            upstream_revisions={None:upstream_rev2})
         self.assertEqual("a-id", tree.path2id("b"))
 
     def test_merge_upstream_rename_in_packaging_branch(self):
 
=== modified file 'tests/test_upstream.py'
--- tests/test_upstream.py	2011-09-09 13:20:42 +0000
+++ tests/test_upstream.py	2011-09-27 00:50:26 +0000
@@ -25,7 +25,6 @@
 from base64 import standard_b64encode
 
 import bz2
-import gzip
 import os
 import tarfile
 import zipfile
@@ -432,6 +431,20 @@
         self.tree.commit("msg")
         self.assertEquals("2.1+bzr2", source.get_latest_version("foo", "1.0"))
 
+    def test_version_as_revisions(self):
+        revid1 = self.tree.commit("msg")
+        self.tree.branch.tags.set_tag("2.1", self.tree.branch.last_revision())
+        config = DebBuildConfig(
+            [('user.conf', True), ('default.conf', False)],
+            branch=self.tree.branch)
+        source = UpstreamBranchSource(self.tree.branch,
+            {"2.1": self.tree.branch.last_revision()},
+            config=config)
+        revid2 = self.tree.commit("msg")
+        self.assertEquals(revid2,
+            source.version_as_revision("foo", "2.1+bzr2"))
+        self.assertEquals({None: revid1}, source.version_as_revisions("foo", "2.1"))
+
     def test_version_as_revision(self):
         revid1 = self.tree.commit("msg")
         self.tree.branch.tags.set_tag("2.1", self.tree.branch.last_revision())
@@ -699,14 +712,24 @@
 class TestUpstreamTagVersion(TestCase):
 
     def test_simple_upstream(self):
-        self.assertEqual('2.1', upstream_tag_version('upstream-2.1'))
+        self.assertEqual((None, '2.1'), upstream_tag_version('upstream-2.1'))
 
     def test_distro_upstream(self):
-        self.assertEqual('2.1',
+        self.assertEqual((None, '2.1'),
             upstream_tag_version('upstream-debian-2.1'))
 
     def test_git_upstream(self):
-        self.assertEqual('2.1', upstream_tag_version('upstream/2.1'))
+        self.assertEqual((None, '2.1'), upstream_tag_version('upstream/2.1'))
+
+    def test_git_upstream_component(self):
+        self.assertEqual(("lib", '2.1'), upstream_tag_version('upstream/2.1/lib'))
+
+    def test_simple_upstream_component(self):
+        self.assertEqual(("lib", '2.1'), upstream_tag_version('upstream-2.1/lib'))
+
+    def test_distro_upstream_component(self):
+        self.assertEqual(("lib", '2.1'),
+            upstream_tag_version('upstream-debian-2.1/lib'))
 
 
 class PristineTarSourceTests(TestCaseWithTransport):
@@ -766,14 +789,31 @@
         rev.properties["deb-pristine-delta"] = standard_b64encode("bla")
         self.assertEquals("bla", self.source.pristine_tar_delta(rev))
 
-    def test_version_as_revision_missing(self):
+    def test_version_as_revisions_missing(self):
         self.assertRaises(PackageVersionNotPresent,
-            self.source.version_as_revision, None, "1.2")
-
-    def test_version_as_revision(self):
-        revid1 = self.tree.commit("msg")
-        self.tree.branch.tags.set_tag("upstream-2.1", revid1)
-        self.assertEquals(revid1, self.source.version_as_revision(None, "2.1"))
+            self.source.version_as_revisions, None, "1.2")
+
+    def test_version_as_revisions_single(self):
+        revid1 = self.tree.commit("msg")
+        self.tree.branch.tags.set_tag("upstream-2.1", revid1)
+        self.assertEquals({None: revid1},
+            self.source.version_as_revisions(None, "2.1"))
+
+    def test_version_component_as_revision(self):
+        revid1 = self.tree.commit("msg")
+        self.tree.branch.tags.set_tag("upstream-2.1/lib", revid1)
+        self.assertEquals(revid1,
+            self.source.version_component_as_revision(None, "2.1", "lib"))
+
+    def test_version_as_revisions(self):
+        revid1 = self.tree.commit("msg")
+        revid2 = self.tree.commit("msg")
+        self.tree.branch.tags.set_tag("upstream-2.1", revid1)
+        self.tree.branch.tags.set_tag("upstream-2.1/lib", revid2)
+        self.assertEquals({ None: revid1, "lib": revid2 },
+                self.source.version_as_revisions(None, "2.1", [
+            ("upstream_2.1.orig.tar.gz", None, "somemd5sum"),
+            ("upstream_2.1.orig-lib.tar.gz", "lib", "othermd5sum")]))
 
 
 class TarfileSourceTests(TestCaseWithTransport):
 
=== modified file 'upstream/__init__.py'
--- upstream/__init__.py	2011-09-07 20:11:50 +0000
+++ upstream/__init__.py	2011-09-27 00:50:26 +0000
@@ -75,15 +75,16 @@
         """
         raise NotImplementedError(self.get_latest_version)
 
-    def version_as_revision(self, package, version):
-        """Lookup the revision id for a particular version.
+    def version_as_revisions(self, package, version, tarballs=None):
+        """Lookup the revision ids for a particular version.
 
         :param package: Package name
-        :package version: Version string
+        :param version: Version string
         :raise PackageVersionNotPresent: When the specified version was not
             found
+        :return: dictionary mapping component names to revision ids
         """
-        raise NotImplementedError(self.version_as_revision)
+        raise NotImplementedError(self.version_as_revisions)
 
     def has_version(self, package, version, md5=None):
         """Check whether this upstream source contains a particular package.
@@ -94,12 +95,14 @@
         """
         raise NotImplementedError(self.has_version)
 
-    def fetch_tarballs(self, package, version, target_dir):
+    def fetch_tarballs(self, package, version, target_dir, components=None):
         """Fetch the source tarball for a particular version.
 
         :param package: Name of the package
         :param version: Version string of the version to fetch
         :param target_dir: Directory in which to store the tarball
+        :param components: List of component names to fetch; may be None,
+            in which case the backend will have to find out.
         :return: Paths of the fetched tarballs
         """
         raise NotImplementedError(self.fetch_tarballs)
@@ -113,7 +116,7 @@
     """Upstream source that uses apt-source."""
 
     def fetch_tarballs(self, package, upstream_version, target_dir,
-            _apt_pkg=None):
+            _apt_pkg=None, components=None):
         if _apt_pkg is None:
             import apt_pkg
         else:
@@ -197,7 +200,7 @@
         note("get-orig-source did not create file with prefix %s", prefix)
         return None
 
-    def fetch_tarballs(self, package, version, target_dir):
+    def fetch_tarballs(self, package, version, target_dir, components=None):
         if self.larstiq:
             rules_name = 'rules'
         else:
@@ -279,7 +282,7 @@
             os.unlink(tempfilename)
         return self._xml_report_extract_upstream_version(stdout)
 
-    def fetch_tarballs(self, package, version, target_dir):
+    def fetch_tarballs(self, package, version, target_dir, components=None):
         note("Using uscan to look for the upstream tarball.")
         try:
             tempfilename = self._export_watchfile()
@@ -326,7 +329,7 @@
         finally:
             shutil.rmtree(tmpdir)
 
-    def fetch_tarballs(self, package, version, target_dir):
+    def fetch_tarballs(self, package, version, target_dir, components=None):
         note("Using the current branch without the 'debian' directory "
                 "to create the tarball")
         tarball_path = self._tarball_path(package, version, None, target_dir)
@@ -346,10 +349,10 @@
     def __repr__(self):
         return "%s(%r)" % (self.__class__.__name__, self._sources)
 
-    def fetch_tarballs(self, package, version, target_dir):
+    def fetch_tarballs(self, package, version, target_dir, components=None):
         for source in self._sources:
             try:
-                paths = source.fetch_tarballs(package, version, target_dir)
+                paths = source.fetch_tarballs(package, version, target_dir, components)
             except PackageVersionNotPresent:
                 pass
             else:
@@ -496,7 +499,7 @@
         self.path = path
         self.version = version
 
-    def fetch_tarballs(self, package, version, target_dir):
+    def fetch_tarballs(self, package, version, target_dir, components=None):
         if version != self.version:
             raise PackageVersionNotPresent(package, version, self)
         dest_name = new_tarball_name(package, version, self.path)
@@ -541,7 +544,7 @@
         else:
             self.project = project
 
-    def fetch_tarballs(self, package, version, target_dir):
+    def fetch_tarballs(self, package, version, target_dir, components=None):
         release = self.project.getRelease(version=version)
         if release is None:
             raise PackageVersionNotPresent(package, version, self)
 
=== modified file 'upstream/branch.py'
--- upstream/branch.py	2011-06-26 21:02:48 +0000
+++ upstream/branch.py	2011-09-27 00:50:26 +0000
@@ -28,7 +28,10 @@
 from bzrlib.revisionspec import RevisionSpec
 from bzrlib.trace import note
 
-from bzrlib.plugins.builddeb.errors import PackageVersionNotPresent
+from bzrlib.plugins.builddeb.errors import (
+    MultipleUpstreamTarballsNotSupported,
+    PackageVersionNotPresent,
+    )
 from bzrlib.plugins.builddeb.upstream import UpstreamSource
 from bzrlib.plugins.builddeb.util import (
     export,
@@ -228,7 +231,7 @@
         else:
             self.upstream_revision_map = upstream_revision_map
 
-    def version_as_revision(self, package, version):
+    def version_as_revision(self, package, version, tarballs=None):
         assert isinstance(version, str)
         if version in self.upstream_revision_map:
             revspec = self.upstream_revision_map[version]
@@ -242,6 +245,13 @@
                 raise PackageVersionNotPresent(package, version, self)
         raise PackageVersionNotPresent(package, version, self)
 
+    def version_as_revisions(self, package, version, tarballs=None):
+        # FIXME: Support multiple upstream locations if there are multiple
+        # components
+        if tarballs is not None and tarballs.keys() != [None]:
+            raise MultipleUpstreamTarballsNotSupported()
+        return { None: self.version_as_revision(package, version, tarballs) }
+
     def get_latest_version(self, package, current_version):
         return self.get_version(package, current_version,
             self.upstream_branch.last_revision())
@@ -254,7 +264,7 @@
         finally:
             self.upstream_branch.unlock()
 
-    def fetch_tarballs(self, package, version, target_dir):
+    def fetch_tarballs(self, package, version, target_dir, components=None):
         self.upstream_branch.lock_read()
         try:
             revid = self.version_as_revision(package, version)
 
=== modified file 'upstream/pristinetar.py'
--- upstream/pristinetar.py	2011-09-09 13:20:42 +0000
+++ upstream/pristinetar.py	2011-09-27 00:50:26 +0000
@@ -39,13 +39,17 @@
     subprocess_setup,
     )
 
-from bzrlib import osutils
+from bzrlib import (
+    osutils,
+    revision as _mod_revision,
+    )
 from bzrlib.errors import (
     BzrError,
     NoSuchRevision,
     NoSuchTag,
     )
 from bzrlib.trace import (
+    mutter,
     note,
     warning,
     )
@@ -156,42 +160,35 @@
         self.branch.tags.set_tag(tag_name, revid)
         return tag_name, revid
 
-    def import_tarballs(self, package, version, tree, parent_ids, tarballs,
-            timestamp=None, author=None):
-        """Import the upstream tarballs.
-
-        :param package: Package name
-        :param version: Package version
-        :param path: Path with tree to import
-        :param parent_ids: Parent revisions
-        :param tarballs: List of (path, component, md5)
-        :param timestamp: Optional timestamp for new commits
-        :param author: Optional author for new commits
-        :return: List of tuples with (component, tag, revid)
-        """
-        ret = []
-        for (tarball, component, md5) in tarballs:
-            (tag, revid) = self.import_component_tarball(
-                package, version, tree, parent_ids, component,
-                md5, tarball, author=author, timestamp=timestamp)
-            ret.append((component, tag, revid))
-        return ret
-
     def import_component_tarball(self, package, version, tree, parent_ids,
-            component=None, md5=None, tarball=None, author=None, timestamp=None):
+            component=None, md5=None, tarball=None, author=None, timestamp=None,
+            subdir=None, exclude=None):
         """Import a tarball.
 
         :param package: Package name
         :param version: Upstream version
+        :param parent_ids: Dictionary mapping component names to revision ids
         :param component: Component name (None for base)
+        :param exclude: Exclude directories
         """
-        if component is not None:
-            raise BzrError("Importing non-base tarballs not yet supported")
-        tree.set_parent_ids(parent_ids)
+        if exclude is None:
+            exclude = []
+        def include_change(c):
+            if not exclude:
+                return True
+            path = c[1][1]
+            if path is None:
+                return True
+            for e in exclude:
+                if path == e or path.startswith(e+"/"):
+                    return False
+            else:
+                return True
         revprops = {}
         if md5 is not None:
             revprops["deb-md5"] = md5
-            delta = self.make_pristine_tar_delta(tree, tarball)
+            delta = self.make_pristine_tar_delta(tree, tarball, subdir=subdir,
+                    exclude=exclude)
             uuencoded = standard_b64encode(delta)
             if tarball.endswith(".tar.bz2"):
                 revprops["deb-pristine-delta-bz2"] = uuencoded
@@ -208,9 +205,32 @@
         message = "Import upstream version %s" % (version,)
         if component is not None:
             message += ", component %s" % component
-        revid = tree.commit(message, revprops=revprops, timestamp=timestamp,
-            timezone=timezone)
-        tag_name, _ = self.tag_version(version, revid=revid)
+        if len(parent_ids) == 0:
+            base_revid = _mod_revision.NULL_REVISION
+        else:
+            base_revid = parent_ids[0]
+        basis_tree = tree.branch.repository.revision_tree(base_revid)
+        tree.lock_write()
+        try:
+            builder = tree.branch.get_commit_builder(parents=parent_ids,
+                revprops=revprops, timestamp=timestamp, timezone=timezone)
+            builder.will_record_deletes()
+            try:
+                changes = [c for c in tree.iter_changes(basis_tree) if
+                           include_change(c)]
+                list(builder.record_iter_changes(tree, base_revid, changes))
+                builder.finish_inventory()
+            except:
+                builder.abort()
+                raise
+            revid = builder.commit(message)
+            tag_name, _ = self.tag_version(version, revid=revid, component=component)
+            tree.update_basis_by_delta(revid, builder.get_basis_delta())
+        finally:
+            tree.unlock()
+        mutter(
+            'imported %s version %s component %r as revid %s, tagged %s',
+            package, version, component, revid, tag_name)
         return tag_name, revid
 
     def fetch_component_tarball(self, package, version, component, target_dir):
@@ -219,13 +239,13 @@
             rev = self.branch.repository.get_revision(revid)
         except NoSuchRevision:
             raise PackageVersionNotPresent(package, version, self)
-        note("Using pristine-tar to reconstruct the needed tarball.")
         if self.has_pristine_tar_delta(rev):
             format = self.pristine_tar_format(rev)
         else:
             format = 'gz'
         target_filename = self._tarball_path(package, version, component,
                                              target_dir, format=format)
+        note("Using pristine-tar to reconstruct %s.", os.path.basename(target_filename))
         try:
             self.reconstruct_pristine_tar(revid, package, version, target_filename)
         except PristineTarError:
@@ -234,8 +254,15 @@
             raise PackageVersionNotPresent(package, version, self)
         return target_filename
 
-    def fetch_tarballs(self, package, version, target_dir):
-        return [self.fetch_component_tarball(package, version, None, target_dir)]
+    def fetch_tarballs(self, package, version, target_dir, components=None):
+        if components is None:
+            # Scan tags for components
+            try:
+                components = self._components_by_version()[version].keys()
+            except KeyError:
+                raise PackageVersionNotPresent(package, version, self)
+        return [self.fetch_component_tarball(package, version, component, target_dir)
+                for component in components]
 
     def _has_revision(self, revid, md5=None):
         self.branch.lock_read()
@@ -256,14 +283,16 @@
                 "revision %s", revid)
             return True
 
-    def version_as_revision(self, package, version, tarballs=None):
+    def version_as_revisions(self, package, version, tarballs=None):
         if tarballs is None:
-            return self.version_component_as_revision(package, version, component=None)
-        elif len(tarballs) > 1:
-            raise MultipleUpstreamTarballsNotSupported()
-        else:
-            return self.version_component_as_revision(package, version, tarballs[0][1],
-                tarballs[0][2])
+            # FIXME: What if there are multiple tarballs?
+            return {
+                None: self.version_component_as_revision(package, version, component=None) }
+        ret = {}
+        for (tarball, component, md5) in tarballs:
+            ret[component] = self.version_component_as_revision(
+                package, version, component, md5)
+        return ret
 
     def version_component_as_revision(self, package, version, component, md5=None):
         assert isinstance(version, str)
@@ -359,7 +388,7 @@
         finally:
             shutil.rmtree(tmpdir)
 
-    def make_pristine_tar_delta(self, tree, tarball_path):
+    def make_pristine_tar_delta(self, tree, tarball_path, subdir=None, exclude=None):
         tmpdir = tempfile.mkdtemp(prefix="builddeb-pristine-")
         try:
             dest = os.path.join(tmpdir, "orig")
@@ -367,22 +396,29 @@
             try:
                 for (dp, ie) in tree.inventory.iter_entries():
                     ie._read_tree_state(dp, tree)
-                export(tree, dest, format='dir')
+                export(tree, dest, format='dir', subdir=subdir)
             finally:
                 tree.unlock()
             return make_pristine_tar_delta(dest, tarball_path)
         finally:
             shutil.rmtree(tmpdir)
 
+    def _components_by_version(self):
+        ret = {}
+        for tag_name, tag_revid in self.branch.tags.get_tag_dict().iteritems():
+            if not is_upstream_tag(tag_name):
+                continue
+            (component, version) = upstream_tag_version(tag_name)
+            ret.setdefault(version, {})[component] = tag_revid
+        return ret
+
     def iter_versions(self):
         """Iterate over all upstream versions.
 
         :return: Iterator over (tag_name, version, revid) tuples
         """
-        for tag_name, tag_revid in self.branch.tags.get_tag_dict().iteritems():
-            if not is_upstream_tag(tag_name):
-                continue
-            yield (tag_name, upstream_tag_version(tag_name), tag_revid)
+        ret = self._components_by_version()
+        return ret.iteritems()
 
 
 def is_upstream_tag(tag):
@@ -398,7 +434,7 @@
     """Return the upstream version portion of an upstream tag name.
 
     :param tag: The string name of the tag.
-    :return: The version portion of the tag.
+    :return: tuple with version portion of the tag and component name
     """
     assert is_upstream_tag(tag), "Not an upstream tag: %s" % tag
     if tag.startswith('upstream/'):
@@ -409,4 +445,9 @@
             tag = tag[len('debian-'):]
         elif tag.startswith('ubuntu-'):
             tag = tag[len('ubuntu-'):]
-    return tag
+    if not '/' in tag:
+        return (None, tag)
+    (version, component) = tag.rsplit('/', 1)
+    if component == "":
+        component = None
+    return (component, version)