Merge ~nacc/git-ubuntu:lp-importer-no-publish-parent into git-ubuntu:master

[Nish Aravamudan]

Robie,

I think this implements what you and Colin want.

[Server Team CI bot (server-team-bot)]

FAILED: Continuous integration, rev:e18dd529d2d7cb7a0d789ddbefe2fe6b1b0b74d1
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/161/
Executed test runs:
    SUCCESS: Checkout
    SUCCESS: Style Check
    SUCCESS: Unit Tests
    FAILED: Integration Tests

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/161/rebuild

review: Needs Fixing (continuous-integration)

[Server Team CI bot (server-team-bot)]

PASSED: Continuous integration, rev:e18dd529d2d7cb7a0d789ddbefe2fe6b1b0b74d1
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/166/
Executed test runs:
    SUCCESS: Checkout
    SUCCESS: Style Check
    SUCCESS: Unit Tests
    SUCCESS: Integration Tests
    IN_PROGRESS: Declarative: Post Actions

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/166/rebuild

review: Approve (continuous-integration)

[Server Team CI bot (server-team-bot)]

PASSED: Continuous integration, rev:454a165784906469f197b7abef16bd4f73f45f4b
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/175/
Executed test runs:
    SUCCESS: Checkout
    SUCCESS: Style Check
    SUCCESS: Unit Tests
    SUCCESS: Integration Tests
    IN_PROGRESS: Declarative: Post Actions

Click here to trigger a rebuild:
https://jenkins.ubuntu.com/server/job/git-ubuntu-ci/175/rebuild

review: Approve (continuous-integration)

Unmerged commits

454a165... by Nish Aravamudan on 2017-10-04

import: drop publishing parent functionality

diff --git a/gitubuntu/importer.py b/gitubuntu/importer.py
index 7248ee6..e96fe17 100644
--- a/gitubuntu/importer.py
+++ b/gitubuntu/importer.py
@@ -413,7 +413,6 @@ def main(
 def get_changelog_for_commit(
     repo,
     tree_hash,
-    publish_parent_commit,
     changelog_parent_commit,
 ):
     """Extract changes to debian/changelog in this publish
@@ -425,10 +424,6 @@ def get_changelog_for_commit(
         cmd = ['diff-tree', '-p', changelog_parent_commit,
                tree_hash, '--', 'debian/changelog']
         raw_clog_entry = repo.git_run(cmd).stdout
-    elif publish_parent_commit is not None:
-        cmd = ['diff-tree', '-p', publish_parent_commit,
-                tree_hash, '--', 'debian/changelog']
-        raw_clog_entry = repo.git_run(cmd).stdout
 
     changelog_entry = b''
     changelog_entry_found = False
@@ -453,10 +448,14 @@ def get_changelog_for_commit(
         changelog_entry_found = True
     return changelog_entry
 
-def _commit_import(repo, spi, tree_hash, namespace,
-    publish_parent_commit,
-    changelog_parent_commit, upload_parent_commit,
-    unapplied_parent_commit
+def _commit_import(
+    repo,
+    spi,
+    tree_hash,
+    namespace,
+    changelog_parent_commit,
+    upload_parent_commit,
+    unapplied_parent_commit,
 ):
     """Commit a tree object into the repository with the specified
     parents
@@ -469,7 +468,6 @@ def _commit_import(repo, spi, tree_hash, namespace,
     Arguments:
     spi - A SourcePackageInformation instance for this publish
     tree_hash - SHA1 from git-dsc-commit --tree-only of this publish
-    publish_parent_commit = SHA1 of publishing parent
     changelog_parent_commit = SHA1 of changelog parent
     upload_parent_commit = SHA1 of upload parent
     unapplied_parent_commit = SHA1 of unapplied-patches import parent
@@ -495,7 +493,6 @@ def _commit_import(repo, spi, tree_hash, namespace,
     changelog_entry = get_changelog_for_commit(
         repo,
         tree_hash,
-        publish_parent_commit,
         changelog_parent_commit
     )
     msg = (b'Import %s version %b to %b\n\nImported using git-ubuntu import.' %
@@ -504,8 +501,7 @@ def _commit_import(repo, spi, tree_hash, namespace,
 
     parents = []
 
-    if publish_parent_commit is None and \
-        changelog_parent_commit is None and \
+    if changelog_parent_commit is None and \
         upload_parent_commit is None and \
         unapplied_parent_commit is None and \
         target_head_name in repo.local_branch_names:
@@ -514,9 +510,6 @@ def _commit_import(repo, spi, tree_hash, namespace,
     else:
         msg += b'\n'
 
-    if publish_parent_commit is not None:
-        parents.append(publish_parent_commit)
-        msg += b'\nPublish parent: %b' % publish_parent_commit.encode()
     if changelog_parent_commit is not None:
         parents.append(changelog_parent_commit)
         msg += b'\nChangelog parent: %b' % changelog_parent_commit.encode()
@@ -555,7 +548,6 @@ def commit_unapplied_patches_import(
     spi,
     import_tree_hash,
     namespace,
-    publish_parent_commit,
     changelog_parent_commit,
     upload_parent_commit,
 ):
@@ -564,7 +556,6 @@ def commit_unapplied_patches_import(
         spi,
         import_tree_hash,
         namespace,
-        publish_parent_commit,
         changelog_parent_commit,
         upload_parent_commit,
         # unapplied trees do not have a distinct unapplied parent
@@ -576,7 +567,6 @@ def commit_applied_patches_import(
     spi,
     import_tree_hash,
     namespace,
-    publish_parent_commit,
     changelog_parent_commit,
     unapplied_parent_commit
 ):
@@ -585,7 +575,6 @@ def commit_applied_patches_import(
         spi,
         import_tree_hash,
         namespace,
-        publish_parent_commit,
         changelog_parent_commit,
         # uploads will be unapplied trees currently, so applied trees
         # can not have them as direct parents
@@ -839,16 +828,12 @@ def parse_parentfile(parentfile, pkgname):
     The parent overrides file specifies parent-child relationship(s),
     where the importer may not be able to determine them automatically.
     The format of the file is:
-    <pkgname> <child version> <publish parent version> <changelog parent version>
+    <pkgname> <child version> <changelog parent version>
     with one override per line.
 
     <child version> is the published version to which this override
     applies.
 
-    The <publish parent version> is the prior version published in the
-    same series/pocket, or the immediately preceding series/pocket, if
-    this is the first publish in a series/pocket.
-
     The <changelog parent version> is the prior version in the
     child publish's debian/changelog.
 
@@ -865,7 +850,7 @@ def parse_parentfile(parentfile, pkgname):
                 if line.startswith('#'):
                     continue
                 m = re.match(
-                    r'(?P<pkgname>\S*)\s*(?P<childversion>\S*)\s*(?P<parent1version>\S*)\s*(?P<parent2version>\S*)',
+                    r'(?P<pkgname>\S*)\s*(?P<childversion>\S*)\s*(?P<parent2version>\S*)',
                     line
                     )
                 if m is None:
@@ -873,61 +858,15 @@ def parse_parentfile(parentfile, pkgname):
                 if m.group('pkgname') != pkgname:
                     continue
                 _PARENT_OVERRIDES[m.group('childversion')] = {
-                    'publish_parent':m.group('parent1version'),
-                    'changelog_parent':m.group('parent2version')
-                    }
+                    'changelog_parent': m.group('parent2version')
+                }
     except FileNotFoundError:
         pass
 
 def override_parents(repo, spi, namespace):
-    unapplied_publish_parent_commit = None
     unapplied_changelog_parent_commit = None
-    applied_publish_parent_commit = None
     applied_changelog_parent_commit = None
 
-    unapplied_publish_parent_tag = repo.get_import_tag(
-        _PARENT_OVERRIDES[spi.version]['publish_parent'],
-        namespace
-    )
-    applied_publish_parent_tag = repo.get_applied_tag(
-        _PARENT_OVERRIDES[spi.version]['publish_parent'],
-        namespace
-    )
-    if unapplied_publish_parent_tag is not None:
-        # sanity check that version from d/changelog of the
-        # tagged commit matches ours
-        parent_publish_version, _ = \
-            repo.get_changelog_versions_from_treeish(
-                str(unapplied_publish_parent_tag.peel().id),
-                                                    )
-        if parent_publish_version != _PARENT_OVERRIDES[spi.version]['publish_parent']:
-            logging.error('Found a tag corresponding to publish parent '
-                'override version %s, but d/changelog version (%s) '
-                'differs. Will orphan commit.',
-                _PARENT_OVERRIDES[spi.version]['publish_parent'],
-                parent_publish_version
-            )
-        else:
-            unapplied_publish_parent_commit = str(unapplied_publish_parent_tag.peel().id)
-            if applied_publish_parent_tag is not None:
-                applied_publish_parent_commit = str(applied_publish_parent_tag.peel().id)
-            logging.debug('Overriding publish parent (tag) to %s',
-                repo.tag_to_pretty_name(unapplied_publish_parent_tag)
-            )
-    else:
-        if _PARENT_OVERRIDES[spi.version]['publish_parent'] == '-':
-            logging.debug('Not setting publish parent as '
-                         'specified in override file.'
-                        )
-        else:
-            raise ParentOverrideError(
-                "Specified publish parent override (%s) for version (%s) "
-                "not found in tags. Unable to proceed." % (
-                    _PARENT_OVERRIDES[spi.version]['publish_parent'],
-                    spi.version
-                )
-            )
-
     unapplied_changelog_parent_tag = repo.get_import_tag(
         _PARENT_OVERRIDES[spi.version]['changelog_parent'],
         namespace
@@ -973,9 +912,7 @@ def override_parents(repo, spi, namespace):
                 )
             )
     return (
-        unapplied_publish_parent_commit,
         unapplied_changelog_parent_commit,
-        applied_publish_parent_commit,
         applied_changelog_parent_commit,
     )
 
@@ -1163,7 +1100,6 @@ def import_unapplied_spi(repo, spi, namespace, skip_orig, ubuntu_sinfo):
 
     logging.debug('Tip version is %s', unapplied_tip_version)
 
-    unapplied_publish_parent_commit = None
     unapplied_changelog_parent_commit = None
     upload_parent_commit = None
     unapplied_parent_commit = None
@@ -1176,38 +1112,20 @@ def import_unapplied_spi(repo, spi, namespace, skip_orig, ubuntu_sinfo):
 
         try:
             (
-                unapplied_publish_parent_commit,
                 unapplied_changelog_parent_commit,
-                _,
                 _
             ) = override_parents(repo, spi, namespace)
         except ParentOverrideError as e:
             logging.error("%s" % e)
-            return 1
+            return
     else:
-        # Get parent from publishing history (which is the last
-        # published version in the corresponding series)
-        try:
-            unapplied_publish_parent_commit = str(unapplied_tip_head.peel().id)
-        except AttributeError:
-            try:
-                unapplied_publish_parent_head = repo.get_head_by_name(spi.parent_head_name(namespace))
-                unapplied_publish_parent_commit = str(unapplied_publish_parent_head.peel().id)
-            except AttributeError:
-                pass
-        finally:
-            try:
-                unapplied_publish_parent_tag = repo.nearest_import_tag(unapplied_publish_parent_commit, namespace)
-                logging.debug('Publishing parent (tag) is %s',
-                    repo.tag_to_pretty_name(unapplied_publish_parent_tag)
-                            )
-            except AttributeError:
-                pass
-
         if version_compare(str(spi.version), unapplied_tip_version) <= 0:
-            logging.warn('Version to import (%s) is not after %s tip (%s)',
-                         spi.version, pretty_head_name, unapplied_tip_version
-                        )
+            logging.warn(
+                 "Version to import (%s) is not after %s tip (%s)",
+                 spi.version,
+                 pretty_head_name,
+                 unapplied_tip_version,
+            )
 
         # Walk changelog backwards until we find an imported version
         for version in import_tree_versions:
@@ -1224,56 +1142,51 @@ def import_unapplied_spi(repo, spi, namespace, skip_orig, ubuntu_sinfo):
                 # tree's debian/changelog, as it wasn't used
                 if (version not in _PARENT_OVERRIDES and
                     parent_changelog_version != version
-                   ):
-                    logging.error('Found a tag corresponding to '
-                                  'parent version %s, but d/changelog '
-                                  'version (%s) differs. Will '
-                                  'orphan commit.' % (
-                                  version,
-                                  parent_changelog_version
-                                  )
-                                 )
+                ):
+                    logging.error(
+                        "Found a tag corresponding to parent version "
+                        "%s, but d/changelog version (%s) differs. Will "
+                        "orphan commit.",
+                        version,
+                        parent_changelog_version,
+                    )
                 else:
                     unapplied_changelog_parent_commit = str(unapplied_changelog_parent_tag.peel().id)
-                    logging.debug('Changelog parent (tag) is %s',
+                    logging.debug("Changelog parent (tag) is %s",
                         repo.tag_to_pretty_name(unapplied_changelog_parent_tag)
-                                )
+                    )
                 break
 
-    # If the two parents are tree-identical, then favor publication
-    # history. This deals with copy-forwards between series and with
-    # syncs.
-    if repo.treeishs_identical(unapplied_publish_parent_commit, unapplied_changelog_parent_commit):
-        unapplied_changelog_parent_commit = None
-
     # check if the version to import has already been uploaded to
     # this head -- we leverage the above code to perform a 'dry-run'
-    # of the import tree, to obtain the (up to) two parents
+    # of the import tree, to obtain the changelog parent
     upload_tag = repo.get_upload_tag(spi.version, namespace)
     import_tag = repo.get_import_tag(spi.version, namespace)
-    if upload_tag and not import_tag:
+    if import_tag:
+        if str(import_tag.peel().tree.id) != unapplied_import_tree_hash:
+            logging.error(
+                "Found import tag %s, but the corresponding tree "
+                "does not match the published version. Will orphan commit.",
+                repo.tag_to_pretty_name(import_tag),
+            )    
+            unapplied_changelog_parent_commit = None
+        else:
+            repo.update_head_to_commit(
+                spi.head_name(namespace),
+                str(import_tag.peel().id),
+            )
+            return
+    elif upload_tag:
         if str(upload_tag.peel().tree.id) != unapplied_import_tree_hash:
-            logging.warn('Found upload tag %s, '
-                         'but the corresponding tree '
-                         'does not match the published '
-                         'version. Will import %s as '
-                         'normal, ignoring the upload tag.',
-                         repo.tag_to_pretty_name(upload_tag),
-                         spi.version
-                        )
+            logging.warn(
+                "Found upload tag %s, but the corresponding tree "
+                "does not match the published version. Will import %s as "
+                "normal, ignoring the upload tag.",
+                repo.tag_to_pretty_name(upload_tag),
+                spi.version,
+            )
         else:
             upload_parent_commit = str(upload_tag.peel().id)
-            if unapplied_publish_parent_commit is not None:
-                try:
-                    repo.git_run(['merge-base', '--is-ancestor',
-                                  unapplied_publish_parent_commit,
-                                  upload_parent_commit
-                                 ]
-                                )
-                    unapplied_publish_parent_commit = None
-                except CalledProcessError as e:
-                    if e.returncode != 1:
-                        raise
 
             if unapplied_changelog_parent_commit is not None:
                 try:
@@ -1292,10 +1205,9 @@ def import_unapplied_spi(repo, spi, namespace, skip_orig, ubuntu_sinfo):
         spi,
         unapplied_import_tree_hash,
         namespace,
-        unapplied_publish_parent_commit,
         unapplied_changelog_parent_commit,
         upload_parent_commit,
-                                        )
+    )
 
     update_devel_branches(
         repo=repo,
@@ -1349,7 +1261,6 @@ def import_applied_spi(repo, spi, namespace, ubuntu_sinfo):
 
     logging.debug('Tip version is %s', applied_tip_version)
 
-    applied_publish_parent_commit = None
     applied_changelog_parent_commit = None
 
     if spi.version in _PARENT_OVERRIDES:
@@ -1359,8 +1270,6 @@ def import_applied_spi(repo, spi, namespace, ubuntu_sinfo):
 
         (
             _,
-            _,
-            applied_publish_parent_commit,
             applied_changelog_parent_commit,
         ) = override_parents(
             repo,
@@ -1368,17 +1277,6 @@ def import_applied_spi(repo, spi, namespace, ubuntu_sinfo):
             namespace,
          )
     else:
-        # Get parent from publishing history (which is the last
-        # published version in the corresponding series)
-        try:
-            applied_publish_parent_commit = str(applied_tip_head.peel().id)
-        except AttributeError:
-            try:
-                applied_publish_parent_head = repo.get_head_by_name(spi.applied_parent_head_name(namespace))
-                applied_publish_parent_head_commit = str(applied_publish_parent_head.peel().id)
-            except AttributeError:
-                pass
-
         if version_compare(str(spi.version), applied_tip_version) <= 0:
             logging.warn('Version to import (%s) is not after %s tip (%s)',
                          spi.version, pretty_head_name, applied_tip_version
@@ -1415,11 +1313,26 @@ def import_applied_spi(repo, spi, namespace, ubuntu_sinfo):
                                 )
                 break
 
-    # If the two parents are tree-identical, then favor publication
-    # history. This deals with copy-forwards between series and with
-    # syncs.
-    if repo.treeishs_identical(applied_publish_parent_commit, applied_changelog_parent_commit):
-        applied_changelog_parent_commit = None
+    applied_tag = repo.get_applied_tag(version, namespace)
+    if applied_tag:
+        # XXX: What should be checked here? The result of pushing all
+        # the patches? How to do it most non-destructively? (Might be
+        # able to use our new helper to get treeish after running a
+        # command, in this case, `quilt push -a`)
+        # if str(applied_tag.peel().tree.id) != applied_import_tree_hash:
+        #     logging.error(
+        #         "Found patches-applied import tag %s, but the "
+        #         "corresponding tree does not match the published "
+        #         "version. Will orphan commit.",
+        #        repo.tag_to_pretty_name(applied_tag),
+        #    )    
+        #    applied_changelog_parent_commit = None
+        #else:
+        repo.update_head_to_commit(
+            spi.applied_head_name(namespace),
+            str(applied_tag.peel().id),
+        )
+        return
 
     # Assume no patches to apply
     applied_import_tree_hash = unapplied_import_tree_hash
@@ -1459,7 +1372,6 @@ def import_applied_spi(repo, spi, namespace, ubuntu_sinfo):
         spi,
         applied_import_tree_hash,
         namespace,
-        applied_publish_parent_commit,
         applied_changelog_parent_commit,
         unapplied_parent_commit,
     )
diff --git a/gitubuntu/importlocal.py b/gitubuntu/importlocal.py
index 16f3a6b..13f8690 100644
--- a/gitubuntu/importlocal.py
+++ b/gitubuntu/importlocal.py
@@ -209,7 +209,6 @@ def main(
     changelog_entry = get_changelog_for_commit(
         repo=repo,
         tree_hash=unapplied_import_tree_hash,
-        publish_parent_commit=None,
         changelog_parent_commit=unapplied_changelog_parent_commit,
     )
 
diff --git a/gitubuntu/parent_overrides.txt b/gitubuntu/parent_overrides.txt
index 9393c8d..6045bfc 100644
--- a/gitubuntu/parent_overrides.txt
+++ b/gitubuntu/parent_overrides.txt
@@ -1,4 +1,4 @@
-# pkgname child-version publish-parent-version changelog-parent-version
-clamav 0.91.2-3ubuntu2.1~feisty1 0.92~dfsg-2~feisty1 0.91.2-3ubuntu2.1
-memcached 1.1.12-1 1.4.2-1 -
-golang-golang-x-net-dev 1:0.0+git20150817.66f0418-1 0.0+git20151007.b846920+dfsg-1 0.0+git20150226.3d87fd6-3
+# pkgname child-version changelog-parent-version
+clamav 0.91.2-3ubuntu2.1~feisty1 0.91.2-3ubuntu2.1
+memcached 1.1.12-1 -
+golang-golang-x-net-dev 1:0.0+git20150817.66f0418-1 0.0+git20150226.3d87fd6-3
diff --git a/man/man1/git-ubuntu-import.1 b/man/man1/git-ubuntu-import.1
index 129ecd9..cbcc8cc 100644
--- a/man/man1/git-ubuntu-import.1
+++ b/man/man1/git-ubuntu-import.1
@@ -33,9 +33,6 @@ Import the orig tarballs for <publish> using "gbp import-orig
 --pristine-tar", unless they have already been imported and the imported
 tarballs are identical.
 .PP
-Find a <publish parent>: the most recent patches-unapplied import to the
-same series and pocket\&.
-.PP
 Find a <changelog parent>: the most recent changelog entry with a
 corresponding patches-unapplied import\&.
 .PP
@@ -43,8 +40,7 @@ Find a <upload parent>: a upload-tag in the repository for the same
 version as <publish> with git-tree-identical contents as <publish>\&.
 .PP
 Commit the git tree corresponding to a patches-unapplied extraction of
-<publish> using all of <publish parent>, <changelog parent> and <upload
-parent> as parents\&.
+<publish> using <changelog parent> and <upload parent> as parents\&.
 .PP
 If this is the first patches-unapplied import of a given version, create
 a tag in refs/tags/import/ pointing to the new commit\&.
@@ -62,9 +58,6 @@ For each <publish> in <distribution> since the most recent
 patches-applied import in the local repository\&:
 .RS 4
 .PP
-Find a <publish parent>: the most recent patches-applied import to the
-same series and pocket\&.
-.PP
 Find a <changelog parent>: the most recent changelog entry with a
 corresponding patches-applied import\&.
 .PP
@@ -72,8 +65,8 @@ Find a <unapplied parent>: the corresponding patches-unapplied import of
 <publish>'s version\&.
 .PP
 Commit each git tree corresponding to the application of the next quilt
-patch in <publish> using all of <publish parent>, <changelog parent> and
-<unapplied parent> as parent\&.
+patch in <publish> using <changelog parent> and <unapplied parent> as
+parents\&.
 As each quilt patch is applied, the <unapplied parent> becomes the
 result of the immediately prior patch's application\&.
 .PP