feat: Add the ability to match the version of a release

As we move to containerized deploys we don't want to have to build a new image to
incorporate he updated hash from the release branch. This adds the ability to expose a
JSON blog with a "version" key that Doof can monitor to determine if a release was deployed.

Author: blarghmatey

bot.py

@@ -456,7 +456,7 @@ async def _web_application_release(
         )
 
     async def _wait_for_deploy_with_alerts(
-        self, *, repo_info, release_pr, hash_url, watch_branch
+        self, *, repo_info, release_pr, hash_url, watch_branch, expected_version
     ):
         """
         Wait for a deployment, but alert with a a timeout
@@ -471,6 +471,7 @@ async def _wait_for_deploy_with_alerts(
                 repo_url=repo_url,
                 hash_url=hash_url,
                 watch_branch=watch_branch,
+                expected_version=expected_version,
                 timeout_seconds=timeout_seconds,
             ):
                 break
@@ -490,12 +491,15 @@ async def _wait_for_deploy_rc(self, *, repo_info, manager, release_pr):
         """
         repo_url = repo_info.repo_url
         channel_id = repo_info.channel_id
+        # Get the expected version from the release PR title
+        expected_version = release_pr.version
 
         await self._wait_for_deploy_with_alerts(
             repo_info=repo_info,
             release_pr=release_pr,
             hash_url=repo_info.rc_hash_url,
             watch_branch="release-candidate",
+            expected_version=expected_version,
         )
 
         rc_server = remove_path_from_url(repo_info.rc_hash_url)
@@ -525,17 +529,15 @@ async def _wait_for_deploy_prod(self, *, repo_info, manager, release_pr):
         """
         repo_url = repo_info.repo_url
         channel_id = repo_info.channel_id
-        version = await get_version_tag(
-            github_access_token=self.github_access_token,
-            repo_url=repo_url,
-            commit_hash="origin/release",
-        )
+        # Get the expected version from the release PR title (which should match the tag)
+        expected_version = release_pr.version
 
         await self._wait_for_deploy_with_alerts(
             repo_info=repo_info,
             release_pr=release_pr,
             hash_url=repo_info.prod_hash_url,
             watch_branch="release",
+            expected_version=expected_version,
         )
 
         await set_release_label(
@@ -550,7 +552,7 @@ async def _wait_for_deploy_prod(self, *, repo_info, manager, release_pr):
         await self.say(
             channel_id=channel_id,
             text=(
-                f"My evil scheme {version} for {repo_info.name} has been released to production at {prod_server}. "
+                f"My evil scheme {expected_version} for {repo_info.name} has been released to production at {prod_server}. "
                 "And by 'released', I mean completely...um...leased."
             ),
         )

wait_for_deploy.py

@@ -1,27 +1,67 @@
 """Wait for hash on server to match with deployed code"""
 import asyncio
+import json
+import logging
 import time
 
 from async_subprocess import check_output
 from client_wrapper import ClientWrapper
-from release import init_working_dir
+from lib import init_working_dir # Import from lib.py
+from version import get_version_tag
 
+log = logging.getLogger(__name__)
 
-async def fetch_release_hash(hash_url):
-    """Fetch the hash from the release"""
+
+async def fetch_release_hash(hash_url, *, expected_version=None):
+    """
+    Fetch the hash from the release URL.
+
+    Handles both plain text hash responses and JSON responses containing a 'hash' key.
+    """
     client = ClientWrapper()
     response = await client.get(hash_url)
     response.raise_for_status()
-    release_hash = response.content.decode().strip()
+    content = response.content.decode().strip()
+    release_hash = None
+
+    try:
+        data = json.loads(content)
+        if isinstance(data, dict):
+            # If we expect a specific version, check it first
+            if expected_version and "version" in data:
+                deployed_version = str(data["version"]).strip()
+                if deployed_version != expected_version:
+                    raise Exception(
+                        f"Version mismatch at {hash_url}: Expected '{expected_version}', but found '{deployed_version}'"
+                    )
+            # If version matches (or wasn't checked), get the hash
+            if "hash" in data:
+                release_hash = str(data["hash"]).strip()
+    except json.JSONDecodeError:
+        # Content is not JSON, treat it as a plain hash
+        pass
+
+    if release_hash is None:
+        # Fallback: Treat the entire content as the hash if JSON parsing failed
+        # or the 'hash' key wasn't found.
+        release_hash = content
+
     if len(release_hash) != 40:
+        # Validate the final hash string
         raise Exception(
-            f"Expected release hash from {hash_url} but got: {release_hash}"
+            f"Expected a 40-character release hash from {hash_url} but got: '{release_hash}'"
         )
     return release_hash
 
 
 async def wait_for_deploy(
-    *, github_access_token, repo_url, hash_url, watch_branch, timeout_seconds=60 * 60
+    *,
+    github_access_token,
+    repo_url,
+    hash_url,
+    watch_branch,
+    expected_version,
+    timeout_seconds=60 * 60,
 ):
     """
     Wait until server is finished with the deploy
@@ -31,6 +71,7 @@ async def wait_for_deploy(
         repo_url (str): The repository URL which has the latest commit hash to check
         hash_url (str): The deployment URL which has the commit of the deployed app
         watch_branch (str): The branch in the repository which has the latest commit
+        expected_version (str or None): The version string expected to be found at the hash_url, or None to skip version check.
         timeout_seconds (int): The number of seconds to wait before timing out the deploy
 
     Returns:
@@ -44,9 +85,27 @@ async def wait_for_deploy(
             ["git", "rev-parse", f"origin/{watch_branch}"], cwd=working_dir
         )
         latest_hash = output.decode().strip()
-    while await fetch_release_hash(hash_url) != latest_hash:
+
+    if expected_version:
+        log.info(f"Expecting version '{expected_version}' for hash {latest_hash[:7]}")
+    else:
+        log.info(f"No specific version expected for hash {latest_hash[:7]}. Proceeding without version check.")
+
+    while True:
+        try:
+            current_hash = await fetch_release_hash(hash_url, expected_version=expected_version)
+            if current_hash == latest_hash:
+                log.info(f"Hash {latest_hash[:7]} confirmed at {hash_url}")
+                break # Hashes match, deploy successful
+            else:
+                log.info(f"Waiting for hash {latest_hash[:7]} at {hash_url}, currently {current_hash[:7]}")
+        except Exception as e: # pylint: disable=broad-except
+            log.error(f"Error checking deploy status at {hash_url}: {e}")
+            # Optionally, decide if specific errors should stop the wait
+
         if (time.time() - start_time) > timeout_seconds:
-            return False
+            log.error(f"Timeout waiting for hash {latest_hash[:7]} at {hash_url}")
+            return False # Timeout reached
         await asyncio.sleep(30)
 
     return True