support releasing latest agents

Author: nammn

scripts/release/atomic_pipeline.py

@@ -12,7 +12,6 @@
 
 import requests
 from opentelemetry import trace
-from packaging.version import Version
 
 from lib.base_logger import logger
 from scripts.release.build.image_build_configuration import ImageBuildConfiguration
@@ -24,6 +23,7 @@
 )
 from scripts.release.detect_ops_manager_changes import (
     detect_ops_manager_changes,
+    get_currently_used_agents,
     get_all_agents_for_rebuild,
 )
 
@@ -407,6 +407,9 @@ def build_agent(build_configuration: ImageBuildConfiguration):
     if build_configuration.all_agents:
         agent_versions_to_build = get_all_agents_for_rebuild()
         logger.info("building all agents")
+    elif build_configuration.currently_used_agents:
+        agent_versions_to_build = get_currently_used_agents()
+        logger.info("building current used agents")
     else:
         agent_versions_to_build = detect_ops_manager_changes()
         logger.info("building agents for changed OM versions")

scripts/release/build/image_build_configuration.py

@@ -18,6 +18,7 @@ class ImageBuildConfiguration:
     platforms: Optional[List[str]] = None
     sign: bool = False
     all_agents: bool = False
+    currently_used_agents: bool = False
 
     def is_release_scenario(self) -> bool:
         return self.scenario == BuildScenario.RELEASE

scripts/release/detect_ops_manager_changes.py

@@ -3,8 +3,10 @@
 Detects changes to opsManagerMapping in release.json for triggering agent releases.
 Relies on git origin/master vs local release.json
 """
+import glob
 import json
 import logging
+import os
 import subprocess
 import sys
 from typing import Dict, List, Optional, Tuple
@@ -132,6 +134,71 @@ def get_all_agents_for_rebuild() -> List[Tuple[str, str]]:
     return list(set(agents))
 
 
+def get_currently_used_agents() -> List[Tuple[str, str]]:
+    """Returns list of (agent_version, tools_version) tuples for agents currently used in contexts"""
+    logger.info("Getting currently used agents from contexts")
+    agents = []
+
+    try:
+        release_data = load_current_release_json()
+        if not release_data:
+            logger.error("Could not load release.json")
+            return []
+
+        ops_manager_mapping = extract_ops_manager_mapping(release_data)
+        ops_manager_versions = ops_manager_mapping.get("ops_manager", {})
+
+        # Search all context files
+        context_pattern = "scripts/dev/contexts/**/*"
+        context_files = glob.glob(context_pattern, recursive=True)
+
+        for context_file in context_files:
+            if os.path.isfile(context_file):
+                try:
+                    with open(context_file, "r") as f:
+                        content = f.read()
+
+                        # Extract AGENT_VERSION from the context file
+                        for line in content.split('\n'):
+                            if line.startswith('export AGENT_VERSION='):
+                                agent_version = line.split('=')[1].strip()
+                                tools_version = get_tools_version_for_agent(agent_version)
+                                agents.append((agent_version, tools_version))
+                                logger.info(f"Found agent {agent_version} in {context_file}")
+                                break
+
+                        # Extract CUSTOM_OM_VERSION and map to agent version
+                        for line in content.split('\n'):
+                            if line.startswith('export CUSTOM_OM_VERSION='):
+                                om_version = line.split('=')[1].strip()
+                                if om_version in ops_manager_versions:
+                                    agent_tools = ops_manager_versions[om_version]
+                                    agent_version = agent_tools.get("agent_version")
+                                    tools_version = agent_tools.get("tools_version")
+                                    if agent_version and tools_version:
+                                        agents.append((agent_version, tools_version))
+                                        logger.info(f"Found OM version {om_version} -> agent {agent_version} in {context_file}")
+                                break
+
+                except Exception as e:
+                    logger.debug(f"Error reading context file {context_file}: {e}")
+
+        # Also add the main agentVersion from release.json
+        main_agent_version = release_data.get("agentVersion")
+        if main_agent_version:
+            tools_version = get_tools_version_for_agent(main_agent_version)
+            agents.append((main_agent_version, tools_version))
+            logger.info(f"Found main agent version from release.json: {main_agent_version}")
+
+        unique_agents = list(set(agents))
+        logger.info(f"Found {len(unique_agents)} currently used agents")
+        return unique_agents
+
+    except Exception as e:
+        logger.error(f"Error getting currently used agents: {e}")
+        return []
+
+
 def detect_ops_manager_changes() -> List[Tuple[str, str]]:
     """Returns (has_changes, changed_agents_list)"""
     logger.info("=== Detecting OM Mapping Changes (Local vs Base) ===")

scripts/release/pipeline_main.py

@@ -124,6 +124,7 @@ def image_build_config_from_args(args) -> ImageBuildConfiguration:
         sign=sign,
         parallel_factor=args.parallel_factor,
         all_agents=args.all_agents,
+        currently_used_agents=args.current_agents,
     )
 
 
@@ -257,6 +258,11 @@ def main():
         action="store_true",
         help="Build all agent images.",
     )
+    parser.add_argument(
+        "--current-agents",
+        action="store_true",
+        help="Build all currently used agent images.",
+    )
 
     args = parser.parse_args()