[Pkg-bazaar-commits] ./bzr-builddeb/trunk.old r244: Handle more transitions between native and non-native.
James Westby
jw+debian at jameswestby.net
Wed Dec 10 08:32:50 UTC 2008
------------------------------------------------------------
revno: 244
committer: James Westby <jw+debian at jameswestby.net>
branch nick: 2.0
timestamp: Wed 2008-07-30 15:06:21 +0100
message:
Handle more transitions between native and non-native.
modified:
import_dsc.py
tests/test_import_dsc.py
------------------------------------------------------------
revno: 235.1.2
committer: James Westby <jw+debian at jameswestby.net>
branch nick: import
timestamp: Wed 2008-07-30 15:03:02 +0100
message:
Handle more transitions between native and non-native.
modified:
import_dsc.py
tests/test_import_dsc.py
-------------- next part --------------
=== modified file 'import_dsc.py'
--- a/import_dsc.py 2008-07-24 16:36:59 +0000
+++ b/import_dsc.py 2008-07-30 14:06:21 +0000
@@ -1452,7 +1452,7 @@
real_parents = [parent_revid]
return real_parents
- def import_upstream(self, upstream_part, version, md5):
+ def import_upstream(self, upstream_part, version, md5, upstream_parents):
"""Import an upstream part on to the upstream branch.
This imports the upstream part of the code and places it on to
@@ -1461,16 +1461,24 @@
:param upstream_part: the path of a directory containing the
unpacked upstream part of the source package.
:param version: the Version of the package that is being imported.
+ :param md5: the md5 of the upstream part.
+ :param upstream_parents: the parents to give the upstream revision
"""
# Should we just dump the upstream part on whatever is currently
# there, or try and pull all of the other upstream versions
# from lesser branches first? For now we'll just dump it on.
# TODO: this method needs a lot of work for when we will make
# the branches writeable by others.
- mutter("Importing upstream version %s from %s" \
- % (version, upstream_part))
+ mutter("Importing upstream version %s from %s with parents %s" \
+ % (version, upstream_part, str(upstream_parents)))
assert self.upstream_tree is not None, \
"Can't import upstream with no tree"
+ if len(upstream_parents) > 0:
+ parent_revid = upstream_parents[0]
+ else:
+ parent_revid = NULL_REVISION
+ self.upstream_tree.pull(self.upstream_tree.branch, overwrite=True,
+ stop_revision=parent_revid)
other_branches = self.get_other_branches()
def get_last_revision_tree(br):
return br.repository.revision_tree(br.last_revision())
@@ -1478,6 +1486,7 @@
for o in other_branches]
import_dir(self.upstream_tree, upstream_part,
file_ids_from=upstream_trees + [self.tree])
+ self.upstream_tree.set_parent_ids(upstream_parents)
revid = self.upstream_tree.commit("Import upstream version %s" \
% (str(version.upstream_version),),
revprops={"deb-md5":md5})
@@ -1615,27 +1624,45 @@
assert not path.endswith(".orig.tar.gz")
return (path, md5)
- def _init_upstream_from_other(self, versions):
- parents = self.get_parents(versions)
- if len(parents) > 0:
- branch = parents[0][0]
- pull_version = parents[0][1]
- # FIXME: This means that we won't initialise the upstream
- # if the last version is native but others weren't. I don't
- # think that is correct.
- if not branch.is_version_native(pull_version):
- pull_revid = branch.revid_of_upstream_version(pull_version)
- mutter("Initialising upstream from %s, version %s" \
- % (str(branch), str(pull_version)))
- up_pull_branch = branch.upstream_tree.branch
- else:
- pull_revid = branch.revid_of_version(pull_version)
- mutter("Non-native package following a native one, "
- "pulling upstream from packaging branch %s, "
- "version %s" % (str(branch), str(pull_version)))
- up_pull_branch = branch.tree.branch
- self.upstream_tree.pull(up_pull_branch,
- stop_revision=pull_revid)
+ def upstream_parents(self, versions):
+ """Get the parents for importing a new upstream.
+
+ The upstream parents will be the last upstream version,
+ except for some cases when the last version was native.
+
+ :return: the list of revision ids to use as parents when
+ importing the specified upstream version.
+ """
+ parents = []
+ first_parent = self.upstream_branch.last_revision()
+ if first_parent != NULL_REVISION:
+ parents = [first_parent]
+ last_contained_version = self.last_contained_version(versions)
+ if last_contained_version is not None:
+ # If the last version was native, and was not from the same
+ # 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)):
+ revid = self.revid_of_version(last_contained_version)
+ parents.append(revid)
+ self.upstream_branch.fetch(self.branch,
+ last_revision=revid)
+ if first_parent == NULL_REVISION:
+ pull_parents = self.get_parents(versions)
+ if len(pull_parents) > 0:
+ pull_branch = pull_parents[0][0]
+ pull_version = pull_parents[0][1]
+ if not pull_branch.is_version_native(pull_version):
+ pull_revid = \
+ pull_branch.revid_of_upstream_version(pull_version)
+ mutter("Initialising upstream from %s, version %s" \
+ % (str(pull_branch), str(pull_version)))
+ parents.append(pull_revid)
+ self.upstream_branch.fetch(
+ pull_branch.upstream_branch,
+ last_revision=pull_revid)
+ return parents
def get_changelog_from_source(self, dir):
cl_filename = os.path.join(dir, "debian", "changelog")
@@ -1672,11 +1699,9 @@
imported_upstream = True
# Check whether we should pull first if this initialises
# from another branch:
- if (self.upstream_tree.branch.last_revision()
- == NULL_REVISION):
- self._init_upstream_from_other(versions)
+ upstream_parents = self.upstream_parents(versions)
self.import_upstream(upstream_part, version,
- upstream_md5)
+ upstream_md5, upstream_parents)
else:
mutter("We already have the needed upstream part")
parents = self.get_parents_with_upstream(version, versions,
=== modified file 'tests/test_import_dsc.py'
--- a/tests/test_import_dsc.py 2008-07-24 16:36:59 +0000
+++ b/tests/test_import_dsc.py 2008-07-30 14:06:21 +0000
@@ -2006,7 +2006,7 @@
os.mkdir(basedir)
write_to_file(os.path.join(basedir, "README"), "Hi\n")
write_to_file(os.path.join(basedir, "BUGS"), "")
- self.db1.import_upstream(basedir, version, self.fake_md5_1)
+ self.db1.import_upstream(basedir, version, self.fake_md5_1, [])
tree = self.up_tree1
branch = tree.branch
rh = branch.revision_history()
@@ -2026,13 +2026,14 @@
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, version1, self.fake_md5_1)
+ self.db1.import_upstream(basedir, version1, self.fake_md5_1, [])
basedir = name + "-" + str(version2.upstream_version)
os.mkdir(basedir)
write_to_file(os.path.join(basedir, "README"), "Now even better\n")
write_to_file(os.path.join(basedir, "BUGS"), "")
write_to_file(os.path.join(basedir, "NEWS"), "")
- self.db1.import_upstream(basedir, version2, self.fake_md5_2)
+ self.db1.import_upstream(basedir, version2, self.fake_md5_2,
+ [self.up_tree1.branch.last_revision()])
tree = self.up_tree1
branch = tree.branch
rh = branch.revision_history()
@@ -2051,6 +2052,11 @@
def test_import_package_init_from_other(self):
version1 = Version("0.1-1")
version2 = Version("0.2-1")
+ up_revid1 = self.up_tree1.commit("upstream one")
+ self.db1.tag_upstream_version(version1)
+ self.tree1.pull(self.up_tree1.branch)
+ revid1 = self.tree1.commit("one")
+ self.db1.tag_version(version1)
builder = SourcePackageBuilder("package", version1)
builder.add_default_control()
builder.build()
@@ -2392,6 +2398,150 @@
self.assertTrue(self.db1.is_version_native(version1))
self.assertFalse(self.db1.is_version_native(version2))
+ def test_import_to_native_and_back_same_upstream(self):
+ """Non-native to native and back all in the same upstream version.
+
+ As the native version was on the same upstream as a non-native
+ version we assume that it was accidental, and so don't include
+ the native revision in the upstream branch's history.
+ """
+ version1 = Version("1.0-1")
+ version2 = Version("1.0-2")
+ version3 = Version("1.0-3")
+ builder = SourcePackageBuilder("package", version1)
+ builder.add_default_control()
+ builder.build()
+ self.db1.import_package(builder.dsc_name())
+ builder.native = True
+ builder.new_version(version2)
+ builder.build()
+ self.db1.import_package(builder.dsc_name())
+ builder.native = False
+ builder.new_version(version3)
+ builder.build()
+ self.db1.import_package(builder.dsc_name())
+ rh1 = self.tree1.branch.revision_history()
+ up_rh1 = self.up_tree1.branch.revision_history()
+ self.assertEqual(len(rh1), 4)
+ self.assertEqual(len(up_rh1), 1)
+ rev_tree1 = self.tree1.branch.repository.revision_tree(rh1[1])
+ rev_tree2 = self.tree1.branch.repository.revision_tree(rh1[2])
+ rev_tree3 = self.tree1.branch.repository.revision_tree(rh1[3])
+ self.assertEqual(rev_tree1.get_parent_ids(), [up_rh1[0]])
+ self.assertEqual(rev_tree2.get_parent_ids(), [rh1[1]])
+ self.assertEqual(rev_tree3.get_parent_ids(), [rh1[2]])
+ self.assertEqual(self.db1.revid_of_version(version1), rh1[1])
+ 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),
+ up_rh1[0])
+ self.assertFalse(self.db1.is_version_native(version1))
+ self.assertTrue(self.db1.is_version_native(version2))
+ self.assertFalse(self.db1.is_version_native(version3))
+
+ def test_import_to_native_and_back_new_upstream(self):
+ """Non-native to native and back with a new upstream version.
+
+ As the native version was on the same upstream as a non-native
+ version we assume that it was accidental, and so don't include
+ the native revision in the upstream branch's history.
+
+ As we get a new upstream we want to link that to the previous
+ upstream.
+ """
+ version1 = Version("1.0-1")
+ version2 = Version("1.0-2")
+ version3 = Version("1.1-1")
+ builder = SourcePackageBuilder("package", version1)
+ builder.add_default_control()
+ builder.build()
+ self.db1.import_package(builder.dsc_name())
+ builder.native = True
+ builder.new_version(version2)
+ builder.build()
+ self.db1.import_package(builder.dsc_name())
+ builder.native = False
+ builder.new_version(version3)
+ builder.build()
+ self.db1.import_package(builder.dsc_name())
+ rh1 = self.tree1.branch.revision_history()
+ up_rh1 = self.up_tree1.branch.revision_history()
+ self.assertEqual(len(rh1), 4)
+ self.assertEqual(len(up_rh1), 2)
+ rev_tree1 = self.tree1.branch.repository.revision_tree(rh1[1])
+ rev_tree2 = self.tree1.branch.repository.revision_tree(rh1[2])
+ rev_tree3 = self.tree1.branch.repository.revision_tree(rh1[3])
+ up_rev_tree1 = \
+ self.up_tree1.branch.repository.revision_tree(up_rh1[0])
+ up_rev_tree2 = \
+ self.up_tree1.branch.repository.revision_tree(up_rh1[1])
+ self.assertEqual(rev_tree1.get_parent_ids(), [up_rh1[0]])
+ self.assertEqual(rev_tree2.get_parent_ids(), [rh1[1]])
+ self.assertEqual(rev_tree3.get_parent_ids(), [rh1[2], up_rh1[1]])
+ self.assertEqual(up_rev_tree2.get_parent_ids(), [up_rh1[0]])
+ self.assertEqual(self.db1.revid_of_version(version1), rh1[1])
+ 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),
+ up_rh1[0])
+ self.assertEqual(self.db1.revid_of_upstream_version(version3),
+ up_rh1[1])
+ self.assertFalse(self.db1.is_version_native(version1))
+ self.assertTrue(self.db1.is_version_native(version2))
+ self.assertFalse(self.db1.is_version_native(version3))
+
+ def test_import_to_native_and_back_all_different_upstreams(self):
+ """Non-native to native and back with all different upstreams.
+
+ In this case we want to assume the package was "intended" to
+ be native, and so we include the native version in the upstream
+ history (i.e. the upstream part of the last version has
+ the second version's packaging branch revision as the second
+ parent).
+ """
+ version1 = Version("1.0-1")
+ version2 = Version("1.1")
+ version3 = Version("1.2-1")
+ builder = SourcePackageBuilder("package", version1)
+ builder.add_default_control()
+ builder.build()
+ self.db1.import_package(builder.dsc_name())
+ builder.native = True
+ builder.new_version(version2)
+ builder.build()
+ self.db1.import_package(builder.dsc_name())
+ builder.native = False
+ builder.new_version(version3)
+ builder.build()
+ self.db1.import_package(builder.dsc_name())
+ rh1 = self.tree1.branch.revision_history()
+ up_rh1 = self.up_tree1.branch.revision_history()
+ self.assertEqual(len(rh1), 4)
+ self.assertEqual(len(up_rh1), 2)
+ rev_tree1 = self.tree1.branch.repository.revision_tree(rh1[1])
+ rev_tree2 = self.tree1.branch.repository.revision_tree(rh1[2])
+ rev_tree3 = self.tree1.branch.repository.revision_tree(rh1[3])
+ up_rev_tree1 = \
+ self.up_tree1.branch.repository.revision_tree(up_rh1[0])
+ up_rev_tree2 = \
+ self.up_tree1.branch.repository.revision_tree(up_rh1[1])
+ self.assertEqual(rev_tree1.get_parent_ids(), [up_rh1[0]])
+ self.assertEqual(rev_tree2.get_parent_ids(), [rh1[1]])
+ self.assertEqual(rev_tree3.get_parent_ids(), [rh1[2], up_rh1[1]])
+ self.assertEqual(up_rev_tree2.get_parent_ids(), [up_rh1[0], rh1[2]])
+ self.assertEqual(self.db1.revid_of_version(version1), rh1[1])
+ 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),
+ up_rh1[0])
+ self.assertEqual(self.db1.revid_of_upstream_version(version3),
+ up_rh1[1])
+ self.assertFalse(self.db1.is_version_native(version1))
+ self.assertTrue(self.db1.is_version_native(version2))
+ self.assertFalse(self.db1.is_version_native(version3))
+ # TODO: test that file-ids added in the native version
+ # are used in the second non-native upstream
+
class SourcePackageBuilder(object):
More information about the Pkg-bazaar-commits
mailing list