SERVER-42240: Fix what build burn_in_tags looks at and cleanup

1 files changed, 81 insertions, 24 deletions

diff --git a/buildscripts/burn_in_tags_bypass_compile_and_fetch_binaries.py b/buildscripts/burn_in_tags_bypass_compile_and_fetch_binaries.py
index eb92ddd36c9..59005aadd83 100644
--- a/buildscripts/burn_in_tags_bypass_compile_and_fetch_binaries.py
+++ b/buildscripts/burn_in_tags_bypass_compile_and_fetch_binaries.py
@@ -1,35 +1,92 @@
 #!/usr/bin/env python3
 """Bypass compile and fetch binaries for burn_in_tags."""
+import logging
+import sys
 
-from urllib.parse import urlparse
-from buildscripts.bypass_compile_and_fetch_binaries import (
-    find_suitable_build_id, generate_bypass_expansions, parse_args, read_evg_config,
-    requests_get_json, write_out_bypass_compile_expansions)
+import click
+from evergreen.api import RetryingEvergreenApi
+import structlog
+from structlog.stdlib import LoggerFactory
 
+from buildscripts.bypass_compile_and_fetch_binaries import generate_bypass_expansions, \
+    write_out_bypass_compile_expansions
 
-def main():  # pylint: disable=too-many-locals,too-many-statements
-    """Execute Main program."""
+structlog.configure(logger_factory=LoggerFactory())
+LOGGER = structlog.get_logger(__name__)
 
-    args = parse_args()
-    evg_config = read_evg_config()
-    if evg_config is None:
-        print("Could not find ~/.evergreen.yml config file. Default compile bypass to false.")
-        return
+EVG_CONFIG_FILE = ".evergreen.yml"
 
-    api_server = "{url.scheme}://{url.netloc}".format(
-        url=urlparse(evg_config.get("api_server_host")))
-    revision_url = f"{api_server}/rest/v1/projects/{args.project}/revisions/{args.revision}"
-    revisions = requests_get_json(revision_url)
-    build_id = find_suitable_build_id(revisions["builds"], args)
-    if not build_id:
-        print("Could not find build id for revision {args.revision} on project {args.project}."
-              " Default compile bypass to false.")
-        return
 
-    expansions = generate_bypass_expansions(args.project, args.buildVariant, args.revision,
-                                            build_id)
-    write_out_bypass_compile_expansions(args.outFile, **expansions)
+def _retrieve_used_build_id(build):
+    """
+    Determine what build_id should be used for downloading artifacts.
+
+    If bypass_compile was used by the main compile task, then our expansions should use the
+    same references.
+
+    :param build: Evergreen build containing the compile task to use.
+    :return: build_id that should be used for expansions.
+    """
+    log = LOGGER.bind(build_id=build.id)
+    tasks = build.get_tasks()
+    possible_compile_tasks = {task for task in tasks if task.display_name == "compile"}
+    if len(possible_compile_tasks) != 1:
+        log.warning("Could not find 'compile' task")
+        raise ValueError(f"Compile task not found in {build.id}")
+
+    compile_task = possible_compile_tasks.pop()
+
+    # We will use the 'Binaries' artifact to see what build_id to use.
+    binary_artifacts = [
+        artifact for artifact in compile_task.artifacts if artifact.name == "Binaries"
+    ]
+    for artifact in binary_artifacts:
+        log.info("Checking artifact for build_id", url=artifact.url)
+        build_id = artifact.url.split("/")[-1].split(".")[0]
+        prefix = "mongo-"
+        return build_id[len(prefix):]
+
+    log.warning("Count not determine build_id")
+    raise ValueError(f"Could not determine build id for bypass compile in {build.id}")
+
+
+@click.command()
+@click.option("--project", required=True, help="The evergreen project.")
+@click.option("--build-variant", required=True, help="Build variant where compile is running.")
+@click.option("--revision", required=True, help="Base revision of the build.")
+@click.option("--out-file", required=True, help="File to write macros expansions to.")
+@click.option("--version-id", required=True, help="Evergreen version id of the current build.")
+def main(project, build_variant, revision, out_file, version_id):
+    """
+    Create a file with expansions that can be used to bypass compile.
+
+    This is used for dynamically generated build variants that can use a base build variants
+    compile artifacts to run against.
+    \f
+
+    :param project: The evergreen project.
+    :param build_variant: The build variant whose artifacts we want to use.
+    :param revision: The base revision being run against.
+    :param out_file: File to write expansions to.
+    :param version_id: Evergreen version id being run against.
+    """
+    logging.basicConfig(
+        format="[%(asctime)s - %(name)s - %(levelname)s] %(message)s",
+        level=logging.DEBUG,
+        stream=sys.stdout,
+    )
+
+    evg_api = RetryingEvergreenApi.get_api(config_file=EVG_CONFIG_FILE)
+
+    version = evg_api.version_by_id(version_id)
+    build_id = _retrieve_used_build_id(version.build_by_variant(build_variant))
+
+    LOGGER.info("Creating expansions files", project=project, build_variant=build_variant,
+                revision=revision, build_id=build_id)
+
+    expansions = generate_bypass_expansions(project, build_variant, revision, build_id)
+    write_out_bypass_compile_expansions(out_file, **expansions)
 
 
 if __name__ == "__main__":
-    main()
+    main()  # pylint: disable=no-value-for-parameter