[patch] remove pipeline name from the messages

Author: anilprajapatiibm

bin/mas-devops-notify-slack

@@ -97,82 +97,53 @@ def notifyProvisionRoks(channels: list[str], rc: int, additionalMsg: str | None
     return response.data.get("ok", False)
 
 
-def notifyPipelineStart(channels: list[str], pipelineName: str, instanceId: str | None = None) -> bool:
+def notifyPipelineStart(channels: list[str], instanceId: str | None = None) -> dict | None:
     """Send Slack notification about pipeline start and create thread."""
     namespace = f"mas-{instanceId}-pipelines"
-    pipelineRunName = os.getenv("PIPELINERUN_NAME", "")
     if instanceId is None or instanceId == "":
         print("instanceId must be set")
         sys.exit(1)
-    if namespace == "" or pipelineRunName == "":
-        print("PIPELINE_NAMESPACE and PIPELINERUN_NAME env vars must be set")
-        sys.exit(1)
-    
+
     # Check if thread already exists
-    threadInfo = SlackUtil.getThreadConfigMap(namespace, pipelineRunName)
+    threadInfo = SlackUtil.getThreadConfigMap(namespace, instanceId)
     if threadInfo is not None:
         print("Pipeline start notification already sent")
-        return True
-    
+        return threadInfo
+
     # Send pipeline started message
     toolchainLink = _getToolchainLink()
     instanceInfo = f"\nInstance ID: `{instanceId}`" if instanceId else ""
     message = [
-        SlackUtil.buildHeader(f"🚀 MAS {pipelineName.title()} Pipeline Started"),
-        SlackUtil.buildSection(f"Pipeline Run: `{pipelineRunName}`{instanceInfo}\n{toolchainLink}")
+        SlackUtil.buildHeader("🚀 MAS Pipeline Started"),
+        SlackUtil.buildSection(f"Pipeline Run: {instanceInfo}\n{toolchainLink}")
     ]
     response = SlackUtil.postMessageBlocks(channels[0], message)
     if response.data.get("ok", False):
         threadId = response["ts"]
         channelId = response["channel"]
         # Store thread information in ConfigMap
-        SlackUtil.createThreadConfigMap(namespace, pipelineRunName, channelId, threadId, pipelineName)
+        SlackUtil.createThreadConfigMap(namespace, channelId, threadId, instanceId)
         return True
     else:
         print("Failed to send pipeline start Slack message")
         return False
 
 
-def notifyAnsibleStart(channels: list[str], taskName: str, pipelineName: str, instanceId: str | None = None) -> bool:
+def notifyAnsibleStart(channels: list[str], taskName: str, instanceId: str | None = None) -> bool:
     """Send Slack notification about Ansible task start."""
     namespace = f"mas-{instanceId}-pipelines"
-    pipelineRunName = os.getenv("PIPELINERUN_NAME", "")
     if instanceId is None or instanceId == "":
         print("instanceId must be set")
         sys.exit(1)
-    if namespace == "" or pipelineRunName == "":
-        print("PIPELINE_NAMESPACE and PIPELINERUN_NAME env vars must be set")
-        sys.exit(1)
-    
+
     # Get thread information, create if doesn't exist
-    threadInfo = SlackUtil.getThreadConfigMap(namespace, pipelineRunName)
+    threadInfo = SlackUtil.getThreadConfigMap(namespace, instanceId)
     if threadInfo is None:
         print("No thread found - creating pipeline start notification")
-        # Send pipeline started message
-        toolchainLink = _getToolchainLink()
-        instanceInfo = f"\nInstance ID: `{instanceId}`" if instanceId else ""
-        message = [
-            SlackUtil.buildHeader(f"🚀 MAS {pipelineName.title()} Pipeline Started"),
-            SlackUtil.buildSection(f"Pipeline Run: `{pipelineRunName}`{instanceInfo}\n{toolchainLink}")
-        ]
-        response = SlackUtil.postMessageBlocks(channels[0], message)
-        if response.data.get("ok", False):
-            threadId = response["ts"]
-            channelId = response["channel"]
-            # Store thread information in ConfigMap
-            SlackUtil.createThreadConfigMap(namespace, pipelineRunName, channelId, threadId, pipelineName)
-            threadInfo = {
-                "threadId": threadId,
-                "channelId": channelId,
-                "pipelineName": pipelineName
-            }
-        else:
-            print("Failed to send pipeline start Slack message")
-            return False
-    
+        notifyPipelineStart(channels, instanceId)
     threadId = threadInfo.get("threadId")
     channelId = threadInfo.get("channelId")
-    
+
     # Send task start message as thread reply
     taskMessage = [
         SlackUtil.buildSection(f"⏳ **{taskName}** - Started")
@@ -183,43 +154,18 @@ def notifyAnsibleStart(channels: list[str], taskName: str, pipelineName: str, in
     return response.data.get("ok", False)
 
 
-def notifyAnsibleComplete(channels: list[str], rc: int, taskName: str, pipelineName: str, instanceId: str | None = None) -> bool:
+def notifyAnsibleComplete(channels: list[str], rc: int, taskName: str, instanceId: str | None = None) -> bool:
     """Send Slack notification about Ansible task completion status."""
     namespace = f"mas-{instanceId}-pipelines"
-    pipelineRunName = os.getenv("PIPELINERUN_NAME", "")
     if instanceId is None or instanceId == "":
         print("instanceId must be set")
         sys.exit(1)
-    if namespace == "" or pipelineRunName == "":
-        print("PIPELINE_NAMESPACE and PIPELINERUN_NAME env vars must be set")
-        sys.exit(1)
-    
+
     # Get thread information, create if doesn't exist
-    threadInfo = SlackUtil.getThreadConfigMap(namespace, pipelineRunName)
+    threadInfo = SlackUtil.getThreadConfigMap(namespace, instanceId)
     if threadInfo is None:
         print("No thread found - creating pipeline start notification")
-        # Send pipeline started message
-        toolchainLink = _getToolchainLink()
-        instanceInfo = f"\nInstance ID: `{instanceId}`" if instanceId else ""
-        message = [
-            SlackUtil.buildHeader(f"🚀 MAS {pipelineName.title()} Pipeline Started"),
-            SlackUtil.buildSection(f"Pipeline Run: `{pipelineRunName}`{instanceInfo}\n{toolchainLink}")
-        ]
-        response = SlackUtil.postMessageBlocks(channels[0], message)
-        if response.data.get("ok", False):
-            threadId = response["ts"]
-            channelId = response["channel"]
-            # Store thread information in ConfigMap
-            SlackUtil.createThreadConfigMap(namespace, pipelineRunName, channelId, threadId, pipelineName)
-            threadInfo = {
-                "threadId": threadId,
-                "channelId": channelId,
-                "pipelineName": pipelineName
-            }
-        else:
-            print("Failed to send pipeline start Slack message")
-            return False
-    
+        notifyPipelineStart(channels, instanceId)
     # Send task completion message as thread reply
     threadId = threadInfo.get("threadId")
     channelId = threadInfo.get("channelId")
@@ -240,15 +186,14 @@ def notifyAnsibleComplete(channels: list[str], rc: int, taskName: str, pipelineN
     return response.data.get("ok", False)
 
 
-def notifyPipelineComplete(channels: list[str], rc: int, pipelineName: str, instanceId: str | None = None) -> bool:
+def notifyPipelineComplete(channels: list[str], rc: int, instanceId: str | None = None) -> bool:
     """Send Slack notification about pipeline completion and cleanup ConfigMap."""
     namespace = f"mas-{instanceId}-pipelines"
-    pipelineRunName = os.getenv("PIPELINERUN_NAME", "")
-    if namespace == "" or pipelineRunName == "":
-        print("PIPELINE_NAMESPACE and PIPELINERUN_NAME env vars must be set")
+    if instanceId is None or instanceId == "":
+        print("instanceId must be set")
         sys.exit(1)
     # Get thread information
-    threadInfo = SlackUtil.getThreadConfigMap(namespace, pipelineRunName)
+    threadInfo = SlackUtil.getThreadConfigMap(namespace, instanceId)
     if threadInfo is None:
         print("No thread information found - pipeline may not have started properly")
         return False
@@ -281,12 +226,12 @@ def notifyPipelineComplete(channels: list[str], rc: int, pipelineName: str, inst
         status = "Failed"
         additionalInfo = f"\nPipeline failed with return code: `{rc}`"
     message = [
-        SlackUtil.buildHeader(f"{emoji} MAS {pipelineName.title()} Pipeline {status}"),
-        SlackUtil.buildSection(f"Pipeline Run: `{pipelineRunName}`{instanceInfo}{durationText}{additionalInfo}")
+        SlackUtil.buildHeader(f"{emoji} MAS Pipeline {status}"),
+        SlackUtil.buildSection(f"Pipeline Run: {instanceInfo}{durationText}{additionalInfo}")
     ]
     response = SlackUtil.postMessageBlocks(channelId, message, threadId)
     # Clean up ConfigMap
-    SlackUtil.deleteThreadConfigMap(namespace, pipelineRunName)
+    SlackUtil.deleteThreadConfigMap(namespace, instanceId)
     if isinstance(response, list):
         return all([res.data.get("ok", False) for res in response])
     return response.data.get("ok", False)
@@ -310,7 +255,6 @@ if __name__ == "__main__":
     parser.add_argument("--rc", required=True, type=int)
     parser.add_argument("--msg", required=False, default=None)
     parser.add_argument("--task-name", required=False, default="")
-    parser.add_argument("--pipeline-name", required=False, default="")
     parser.add_argument("--instance-id", required=False, default=None)
 
     args, unknown = parser.parse_known_args()
@@ -320,10 +264,10 @@ if __name__ == "__main__":
     elif args.action == "ocp-provision-roks":
         notifyProvisionRoks(channelList, args.rc, args.msg)
     elif args.action == "pipeline-start":
-        notifyPipelineStart(channelList, args.pipeline_name, args.instance_id)
+        notifyPipelineStart(channelList, args.instance_id)
     elif args.action == "ansible-start":
-        notifyAnsibleStart(channelList, args.task_name, args.pipeline_name, args.instance_id)
+        notifyAnsibleStart(channelList, args.task_name, args.instance_id)
     elif args.action == "ansible-complete":
-        notifyAnsibleComplete(channelList, args.rc, args.task_name, args.pipeline_name, args.instance_id)
+        notifyAnsibleComplete(channelList, args.rc, args.task_name, args.instance_id)
     elif args.action == "pipeline-complete":
-        notifyPipelineComplete(channelList, args.rc, args.pipeline_name, args.instance_id)
+        notifyPipelineComplete(channelList, args.rc, args.instance_id)

src/mas/devops/slack.py

@@ -14,7 +14,7 @@
 from slack_sdk import WebClient
 from slack_sdk.web.slack_response import SlackResponse
 from kubernetes import client, config
-from datetime import datetime
+from datetime import datetime, timezone
 import logging
 
 logger = logging.getLogger(__name__)
@@ -271,16 +271,15 @@ def buildDivider(cls) -> dict:
         Returns:
             dict: Slack block kit divider element
         """
-    def createThreadConfigMap(cls, namespace: str, pipelineRunName: str, channelId: str, threadId: str, pipelineName: str) -> bool:
+    def createThreadConfigMap(cls, namespace: str, channelId: str, threadId: str, instanceId: str) -> bool:
         """
         Create a ConfigMap to store Slack thread information for a pipeline run.
 
         Parameters:
             namespace (str): Kubernetes namespace for the ConfigMap
-            pipelineRunName (str): Unique identifier for the pipeline run
             channelId (str): Slack channel ID where the thread was created
             threadId (str): Slack thread timestamp
-            pipelineName (str): Name of the pipeline (install/update/upgrade/uninstall)
+            instanceId (str): Name of the Mas Instance ID
 
         Returns:
             bool: True if ConfigMap was created successfully, False otherwise
@@ -292,7 +291,7 @@ def createThreadConfigMap(cls, namespace: str, pipelineRunName: str, channelId:
             except Exception:
                 config.load_kube_config()
             v1 = client.CoreV1Api()
-            configmap_name = f"slack-thread-{pipelineRunName}"
+            configmap_name = f"slack-thread-{instanceId}"
             configmap = client.V1ConfigMap(
                 metadata=client.V1ObjectMeta(
                     name=configmap_name,
@@ -301,8 +300,8 @@ def createThreadConfigMap(cls, namespace: str, pipelineRunName: str, channelId:
                 data={
                     "threadId": threadId,
                     "channelId": channelId,
-                    "pipelineName": pipelineName,
-                    "startTime": datetime.utcnow().isoformat() + "Z"
+                    "instanceId": instanceId,
+                    "startTime": datetime.now(timezone.utc)
                 }
             )
             v1.create_namespaced_config_map(namespace=namespace, body=configmap)
@@ -312,13 +311,13 @@ def createThreadConfigMap(cls, namespace: str, pipelineRunName: str, channelId:
             logger.error(f"Failed to create ConfigMap: {e}")
             return False
 
-    def getThreadConfigMap(cls, namespace: str, pipelineRunName: str) -> dict | None:
+    def getThreadConfigMap(cls, namespace: str, instanceId: str) -> dict | None:
         """
         Retrieve Slack thread information from a ConfigMap.
 
         Parameters:
             namespace (str): Kubernetes namespace containing the ConfigMap
-            pipelineRunName (str): Unique identifier for the pipeline run
+            instanceId (str): Unique identifier for the pipeline run
 
         Returns:
             dict | None: Dictionary containing threadId, channelId, pipelineName, and startTime, or None if not found
@@ -330,21 +329,21 @@ def getThreadConfigMap(cls, namespace: str, pipelineRunName: str) -> dict | None
             except Exception:
                 config.load_kube_config()
             v1 = client.CoreV1Api()
-            configmap_name = f"slack-thread-{pipelineRunName}"
+            configmap_name = f"slack-thread-{instanceId}"
             configmap = v1.read_namespaced_config_map(name=configmap_name, namespace=namespace)
             logger.debug(f"Retrieved ConfigMap {configmap_name} from namespace {namespace}")
             return configmap.data
         except client.exceptions.ApiException as e:
             if e.status == 404:
-                logger.debug(f"ConfigMap slack-thread-{pipelineRunName} not found in namespace {namespace}")
+                logger.debug(f"ConfigMap slack-thread-{instanceId} not found in namespace {namespace}")
             else:
                 logger.error(f"Failed to retrieve ConfigMap: {e}")
             return None
         except Exception as e:
             logger.error(f"Failed to retrieve ConfigMap: {e}")
             return None
 
-    def deleteThreadConfigMap(cls, namespace: str, pipelineRunName: str) -> bool:
+    def deleteThreadConfigMap(cls, namespace: str, instanceId: str) -> bool:
         """
         Delete the ConfigMap containing Slack thread information.
 
@@ -363,13 +362,13 @@ def deleteThreadConfigMap(cls, namespace: str, pipelineRunName: str) -> bool:
                 config.load_kube_config()
 
             v1 = client.CoreV1Api()
-            configmap_name = f"slack-thread-{pipelineRunName}"
+            configmap_name = f"slack-thread-{instanceId}"
             v1.delete_namespaced_config_map(name=configmap_name, namespace=namespace)
             logger.info(f"Deleted ConfigMap {configmap_name} from namespace {namespace}")
             return True
         except client.exceptions.ApiException as e:
             if e.status == 404:
-                logger.warning(f"ConfigMap slack-thread-{pipelineRunName} not found in namespace {namespace}")
+                logger.warning(f"ConfigMap slack-thread-{instanceId} not found in namespace {namespace}")
             else:
                 logger.error(f"Failed to delete ConfigMap: {e}")
             return False