[ACIX-648] create unique qualification tags for agent 6 (#36349)

Author: sabrina-datadog

tasks/libs/common/git.py

@@ -16,6 +16,8 @@
 if TYPE_CHECKING:
     from collections.abc import Iterable
 
+TAG_BATCH_SIZE = 3
+
 
 @contextmanager
 def clone(ctx, repo, branch, options=""):
@@ -344,3 +346,20 @@ def create_tree(ctx, base_branch):
         blob["content"] = content
         tree["tree"].append(blob)
     return tree
+
+
+def push_tags_in_batches(ctx, tags, force_option="", delete=False):
+    """
+    Push or delete tags to remote in batches
+    """
+    if not tags:
+        return
+
+    tags_list = ' '.join(tags)
+    command = "push --delete" if delete else "push"
+
+    for idx in range(0, len(tags), TAG_BATCH_SIZE):
+        batch_tags = tags[idx : idx + TAG_BATCH_SIZE]
+        ctx.run(f"git {command} origin {' '.join(batch_tags)}{force_option}")
+
+    print(f"{'Deleted' if delete else 'Pushed'} tags: {tags_list}")

tasks/release.py

@@ -34,6 +34,7 @@
     get_last_commit,
     get_last_release_tag,
     is_agent6,
+    push_tags_in_batches,
     try_git_command,
 )
 from tasks.libs.common.gomodules import get_default_modules
@@ -84,7 +85,6 @@
 from tasks.release_metrics.metrics import get_prs_metrics, get_release_lead_time
 
 BACKPORT_LABEL_COLOR = "5319e7"
-TAG_BATCH_SIZE = 3
 QUALIFICATION_TAG = "qualification"
 
 
@@ -211,12 +211,8 @@ def _tag_modules():
                 tags.extend(new_tags)
 
         if push:
-            tags_list = ' '.join(tags)
             set_gitconfig_in_ci(ctx)
-            for idx in range(0, len(tags), TAG_BATCH_SIZE):
-                batch_tags = tags[idx : idx + TAG_BATCH_SIZE]
-                ctx.run(f"git push origin {' '.join(batch_tags)}{force_option}")
-            print(f"Pushed tag {tags_list}")
+            push_tags_in_batches(ctx, tags, force_option)
         print(f"Created module tags for version {agent_version}")
 
     if skip_agent_context:
@@ -266,21 +262,20 @@ def _tag_version():
         tags = __tag_single_module(ctx, get_default_modules()["."], agent_version, commit, force_option, devel)
 
         set_gitconfig_in_ci(ctx)
-        # create or update the qualification tag using the force option (points tag to next RC)
         if is_agent6(ctx) and (start_qual or is_qualification(ctx, "6.53.x")):
+            # remove all the qualification tags if it is the final version
             if FINAL_VERSION_RE.match(agent_version):
-                ctx.run(f"git push --delete origin {QUALIFICATION_TAG}")
+                qualification_tags = [tag for _, tag in get_qualification_tags(ctx, release_branch)]
+                push_tags_in_batches(ctx, qualification_tags, delete=True)
+            # create or update the qualification tag on the current commit
             else:
-                force_option = __get_force_option(not start_qual)
                 tags += __tag_single_module(
-                    ctx, get_default_modules()["."], QUALIFICATION_TAG, commit, force_option, False
+                    ctx, get_default_modules()["."], f"{QUALIFICATION_TAG}-{int(time.time())}", commit, "", False
                 )
 
         if push:
-            tags_list = ' '.join(tags)
-            ctx.run(f"git push origin {tags_list}{force_option}")
-            print(f"Pushed tag {tags_list}")
-        print(f"Created tags for version {agent_version}")
+            push_tags_in_batches(ctx, tags, force_option)
+            print(f"Created tags for version {agent_version}")
 
     if skip_agent_context:
         _tag_version()
@@ -541,16 +536,36 @@ def create_rc(ctx, release_branch, patch_version=False, upstream="origin"):
 
 @task
 def is_qualification(ctx, release_branch, output=False):
+    if qualification_tag_query(ctx, release_branch):
+        if output:
+            print('true')
+        return True
+    if output:
+        print("false")
+    return False
+
+
+def qualification_tag_query(ctx, release_branch, sort=False):
     with agent_context(ctx, release_branch):
-        try:
-            ctx.run(f"git tag | grep {QUALIFICATION_TAG}", hide=True)
-            if output:
-                print('true')
-            return True
-        except Failure:
-            if output:
-                print("false")
-            return False
+        sort_option = " --sort=-refname" if sort else ""
+        res = ctx.run(f"git ls-remote --tags{sort_option} origin '{QUALIFICATION_TAG}-*^{{}}'", hide=True)
+        if res.stdout:
+            return res.stdout.splitlines()
+        return None
+
+
+@task
+def get_qualification_tags(ctx, release_branch, latest_tag=False):
+    """Get the qualification tags in remote repository
+
+    Args:
+        latest_tag: if True, only return the latest commit and tag
+    """
+    qualification_tags = qualification_tag_query(ctx, release_branch, sort=True)
+    if latest_tag:
+        qualification_tags = [qualification_tags[0]]
+
+    return [ref.replace("^{}", "").split("\t") for ref in qualification_tags]
 
 
 @task
@@ -634,7 +649,8 @@ def get_qualification_rc_tag(ctx, release_branch):
     with agent_context(ctx, release_branch):
         err_msg = "Error: Expected exactly one release candidate tag associated with the qualification tag commit. Tags found:"
         try:
-            res = ctx.run(f"git tag --points-at $(git rev-list -n 1 {QUALIFICATION_TAG}) | grep 6.53")
+            latest_commit, _ = get_qualification_tags(ctx, release_branch, latest_tag=True)[0]
+            res = ctx.run(f"git tag --points-at {latest_commit} | grep 6.53")
         except Failure as err:
             raise Exit(message=f"{err_msg} []", code=1) from err
 

tasks/unit_tests/release_tests.py

@@ -7,7 +7,7 @@
 from collections import OrderedDict
 from contextlib import contextmanager
 from types import SimpleNamespace
-from unittest.mock import MagicMock, call, patch
+from unittest.mock import ANY, MagicMock, call, patch
 
 from invoke import Context, MockContext, Result
 from invoke.exceptions import Exit
@@ -1075,3 +1075,110 @@ def test_100_tags(self):
             mock_modules.return_value = mock_dict
             release.tag_modules(c, version="version")
         self.assertEqual(c.run.call_count, 34)
+
+
+class TestTagVersion(unittest.TestCase):
+    c = MockContext(run=Result("yolo"))
+
+    @patch('tasks.release.__tag_single_module')
+    @patch('tasks.release.push_tags_in_batches')
+    @patch('tasks.release.is_agent6', new=MagicMock(return_value=True))
+    @patch('tasks.release.is_qualification', new=MagicMock(return_value=False))
+    @patch('tasks.release.agent_context', new=MagicMock())
+    @patch.dict(os.environ, {'GITLAB_CI': 'false', 'GITHUB_ACTIONS': 'false'})
+    def test_not_in_qualification_phase(self, push_tags_in_batches_mock, tag_single_module_mock):
+        rc_version = "6.53.5-rc.2"
+        release.tag_version(self.c, start_qual=False, version=rc_version)
+        tag_single_module_mock.assert_called_with(self.c, ANY, rc_version, ANY, ANY, ANY)
+        assert tag_single_module_mock.call_count == 1
+        assert push_tags_in_batches_mock.call_count == 1
+
+    @patch('tasks.release.__tag_single_module')
+    @patch('tasks.release.push_tags_in_batches')
+    @patch('time.time', new=MagicMock(return_value=1234))
+    @patch('tasks.release.is_agent6', new=MagicMock(return_value=True))
+    @patch('tasks.release.is_qualification', new=MagicMock(return_value=False))
+    @patch('tasks.release.agent_context', new=MagicMock())
+    @patch.dict(os.environ, {'GITLAB_CI': 'false', 'GITHUB_ACTIONS': 'false'})
+    def test_start_qualification_phase(self, push_tags_in_batches_mock, tag_single_module_mock):
+        rc_version = "6.53.5-rc.2"
+        release.tag_version(self.c, start_qual=True, version=rc_version)
+        calls = tag_single_module_mock.call_args_list
+        calls[0].assert_called_with(self.c, ANY, rc_version, ANY, ANY, ANY)
+        calls[1].assert_called_with(self.c, ANY, "qualification-1234", ANY, ANY, ANY)
+        assert tag_single_module_mock.call_count == 2
+        assert push_tags_in_batches_mock.call_count == 1
+
+    @patch('tasks.release.__tag_single_module')
+    @patch('tasks.release.push_tags_in_batches')
+    @patch('time.time', new=MagicMock(return_value=2345))
+    @patch('tasks.release.is_agent6', new=MagicMock(return_value=True))
+    @patch('tasks.release.is_qualification', new=MagicMock(return_value=True))
+    @patch('tasks.release.agent_context', new=MagicMock())
+    @patch.dict(os.environ, {'GITLAB_CI': 'false', 'GITHUB_ACTIONS': 'false'})
+    def test_during_qualification_phase(self, push_tags_in_batches_mock, tag_single_module_mock):
+        rc_version = "6.53.5-rc.3"
+        release.tag_version(self.c, start_qual=False, version=rc_version)
+        calls = tag_single_module_mock.call_args_list
+        calls[0].assert_called_with(self.c, ANY, rc_version, ANY, ANY, ANY)
+        calls[1].assert_called_with(self.c, ANY, "qualification-2345", ANY, ANY, ANY)
+        assert tag_single_module_mock.call_count == 2
+        assert push_tags_in_batches_mock.call_count == 1
+
+    @patch('tasks.release.__tag_single_module')
+    @patch('tasks.release.push_tags_in_batches')
+    @patch('tasks.release.is_agent6', new=MagicMock(return_value=True))
+    @patch('tasks.release.is_qualification', new=MagicMock(return_value=True))
+    @patch('tasks.release.agent_context', new=MagicMock())
+    @patch('tasks.release.get_qualification_tags', new=MagicMock())
+    @patch.dict(os.environ, {'GITLAB_CI': 'false', 'GITHUB_ACTIONS': 'false'})
+    def test_end_qualification_phase(self, push_tags_in_batches_mock, tag_single_module_mock):
+        final_release_version = "6.53.5"
+        release.tag_version(self.c, start_qual=False, version=final_release_version)
+        tag_single_module_mock.assert_called_with(self.c, ANY, final_release_version, ANY, ANY, ANY)
+        assert tag_single_module_mock.call_count == 1
+        assert push_tags_in_batches_mock.call_count == 2
+
+
+class TestGetQualificationTags(unittest.TestCase):
+    c = MockContext(run=Result("yolo"))
+
+    @patch('tasks.release.qualification_tag_query')
+    @patch('tasks.release.agent_context', new=MagicMock())
+    def test_returns_all_tags(self, qualification_tag_query_mock):
+        qualification_tag_query_mock.return_value = ['hash2\tqualification_2345^{}', 'hash1\tqualification_1234^{}']
+        tags = release.get_qualification_tags(self.c, "6.53.x")
+        qualification_tag_query_mock.assert_called_with(self.c, "6.53.x", sort=True)
+        assert tags == [['hash2', 'qualification_2345'], ['hash1', 'qualification_1234']]
+        self.assertEqual(len(tags), 2)
+
+    @patch('tasks.release.qualification_tag_query')
+    @patch('tasks.release.agent_context', new=MagicMock())
+    def test_returns_only_one_tag(self, qualification_tag_query_mock):
+        qualification_tag_query_mock.return_value = ['hash2\tqualification_2345^{}', 'hash1\tqualification_1234^{}']
+        tags = release.get_qualification_tags(self.c, "6.53.x", latest_tag=True)
+        qualification_tag_query_mock.assert_called_with(self.c, "6.53.x", sort=True)
+        assert tags == [['hash2', 'qualification_2345']]
+        self.assertEqual(len(tags), 1)
+
+
+class TestIsQualification(unittest.TestCase):
+    c = MockContext(run=Result("yolo"))
+
+    @patch('builtins.print')
+    @patch('tasks.release.qualification_tag_query', new=MagicMock(return_value="hash1\tqualification_1234"))
+    def test_is_qualification(self, print_mock):
+        self.assertTrue(release.is_qualification(self.c, "6.53.x"))
+        assert print_mock.call_count == 0
+        self.assertTrue(release.is_qualification(self.c, "6.53.x", output=True))
+        print_mock.assert_called_with("true")
+        assert print_mock.call_count == 1
+
+    @patch('builtins.print')
+    @patch('tasks.release.qualification_tag_query', new=MagicMock(return_value=None))
+    def test_is_not_qualification(self, print_mock):
+        self.assertFalse(release.is_qualification(self.c, "6.53.x"))
+        assert print_mock.call_count == 0
+        self.assertFalse(release.is_qualification(self.c, "6.53.x", output=True))
+        print_mock.assert_called_with("false")
+        assert print_mock.call_count == 1