[patch] move broadcast to slack utils

terc1997 · terc1997 · commit 624dd79e9a61 · 2025-12-12T17:30:22.000-03:00
diff --git a/.secrets.baseline b/.secrets.baseline
@@ -3,7 +3,7 @@
     "files": "^.secrets.baseline$",
     "lines": null
   },
-  "generated_at": "2025-12-11T13:22:20Z",
+  "generated_at": "2025-12-12T20:28:52Z",
   "plugins_used": [
     {
       "name": "AWSKeyDetector"
@@ -82,15 +82,15 @@
         "hashed_secret": "053f5ed451647be0bbb6f67b80d6726808cad97e",
         "is_secret": false,
         "is_verified": false,
-        "line_number": 55,
+        "line_number": 42,
         "type": "Secret Keyword",
         "verified_result": null
       },
       {
         "hashed_secret": "4f75456d6c1887d41ed176f7ad3e2cfff3fdfd91",
         "is_secret": false,
         "is_verified": false,
-        "line_number": 64,
+        "line_number": 51,
         "type": "Secret Keyword",
         "verified_result": null
       }
diff --git a/bin/mas-devops-notify-slack b/bin/mas-devops-notify-slack
@@ -30,21 +30,8 @@ def _getToolchainLink() -> str:
         return toolchainLink
     return ""
 
-def _broadcast(channels: str, message: list):
-    channelList = [ch.strip() for ch in channels.split(",")]
-    responses = []
-    for channel in channelList:
-        try:
-            if channel:
-                response = SlackUtil.postMessageBlocks(channel, message)
-                responses.append(response.data.get("ok", False))
-        except Exception as e:
-            print(f"Failed to send message to channel {channel}: {e}")
-            responses.append(False)
-    return all(responses) if responses else True
-    
 
-def notifyProvisionFyre(channels: str, rc: int) -> bool:
+def notifyProvisionFyre(channels: list[str], rc: int, additionalMsg: str = "") -> bool:
     """Send Slack notification about Fyre OCP cluster provisioning status."""
     name = _getClusterName()
     toolchainLink = _getToolchainLink()
@@ -64,16 +51,21 @@ def notifyProvisionFyre(channels: str, rc: int) -> bool:
             SlackUtil.buildSection(f"- Username: `{username}`\n- Password: `{password}`"),
             SlackUtil.buildSection(f"<https://beta.fyre.ibm.com/development/vms|Fyre Dashboard>{toolchainLink}")
         ]
+        if additionalMsg:
+            message.append(SlackUtil.buildSection(additionalMsg))
     else:
         message = [
             SlackUtil.buildHeader(f":glyph-fail: Your IBM DevIT Fyre OCP cluster ({name}) failed to deploy"),
             SlackUtil.buildSection(f"<https://beta.fyre.ibm.com/development/vms|Fyre Dashboard>{toolchainLink}")
         ]
-
-    return _broadcast(channels, message)
+    
+    response = SlackUtil.postMessageBlocks(channels, message)
+    if isinstance(response, list):
+        return all([res.data.get("ok", False) for res in response])
+    return response.data.get("ok", False)
 
 
-def notifyProvisionRoks(channels: str, rc: int, additionalDetails: str = "") -> bool:
+def notifyProvisionRoks(channels: list[str], rc: int, additionalMsg: str = "") -> bool:
     """Send Slack notification about ROKS cluster provisioning status."""
     name = _getClusterName()
     toolchainLink = _getToolchainLink()
@@ -89,15 +81,18 @@ def notifyProvisionRoks(channels: str, rc: int, additionalDetails: str = "") ->
             SlackUtil.buildSection(f"{url}"),
             SlackUtil.buildSection(f"<https://cloud.ibm.com/kubernetes/clusters|IBM Cloud Dashboard>{toolchainLink}")
         ]
-        if additionalDetails != "":
-            message.append(SlackUtil.buildSection(additionalDetails))
+        if additionalMsg:
+            message.append(SlackUtil.buildSection(additionalMsg))
     else:
         message = [
             SlackUtil.buildHeader(f":glyph-fail: Your IBM Cloud ROKS cluster ({name}) failed to deploy"),
             SlackUtil.buildSection(f"<https://cloud.ibm.com/kubernetes/clusters|IBM Cloud Dashboard>{toolchainLink}")
         ]
 
-    return _broadcast(channels, message)
+    response = SlackUtil.postMessageBlocks(channels, message)
+    if isinstance(response, list):
+        return all([res.data.get("ok", False) for res in response])
+    return response.data.get("ok", False)
 
 
 if __name__ == "__main__":
@@ -106,21 +101,21 @@ if __name__ == "__main__":
     SLACK_CHANNEL = os.getenv("SLACK_CHANNEL", "")
     if SLACK_TOKEN == "" or SLACK_CHANNEL == "":
         sys.exit(0)
-
+    
+    # Parse comma-separated channel list
+    channelList = [ch.strip() for ch in SLACK_CHANNEL.split(",")]
+    
     # Initialize the properties we need
     parser = argparse.ArgumentParser()
 
     # Primary Options
     parser.add_argument("--action", required=True)
     parser.add_argument("--rc", required=True, type=int)
-    parser.add_argument("--add-details")
+    parser.add_argument("--msg", required=False, default="")
     
     args, unknown = parser.parse_known_args()
 
     if args.action == "ocp-provision-fyre":
-        notifyProvisionFyre(SLACK_CHANNEL, args.rc)
+        notifyProvisionFyre(channelList, args.rc, args.msg)
     elif args.action == "ocp-provision-roks":
-        if args.add_details:
-            notifyProvisionRoks(SLACK_CHANNEL, args.rc, args.add_details)
-        else:
-            notifyProvisionRoks(SLACK_CHANNEL, args.rc)
+        notifyProvisionRoks(channelList, args.rc, args.msg)
diff --git a/src/mas/devops/slack.py b/src/mas/devops/slack.py
@@ -39,73 +39,93 @@ def client(cls) -> WebClient:
 
     # Post message to Slack
     # -----------------------------------------------------------------------------
-    def postMessageBlocks(cls, channelName: str, messageBlocks: list, threadId: str = "") -> SlackResponse:
-        if threadId == "":
-            logger.debug(f"Posting {len(messageBlocks)} block message to {channelName} in Slack")
-            response = cls.client.chat_postMessage(
-                channel=channelName,
-                blocks=messageBlocks,
-                text="Summary text unavailable",
-                mrkdwn=True,
-                parse="none",
-                unfurl_links=False,
-                unfurl_media=False,
-                link_names=True,
-                as_user=True,
-            )
-        else:
-            logger.debug(f"Posting {len(messageBlocks)} block message to {channelName} on thread {threadId} in Slack")
-            response = cls.client.chat_postMessage(
-                channel=channelName,
-                thread_ts=threadId,
-                blocks=messageBlocks,
-                text="Summary text unavailable",
-                mrkdwn=True,
-                parse="none",
-                unfurl_links=False,
-                unfurl_media=False,
-                link_names=True,
-                as_user=True,
-            )
-
-        if not response["ok"]:
-            logger.warning(response.data)
-            logger.warning("Failed to call Slack API")
-        return response
-
-    def postMessageText(cls, channelName, message, attachments=None, threadId=None):
-        if threadId is None:
-            logger.debug(f"Posting message to {channelName} in Slack")
-            response = cls.client.chat_postMessage(
-                channel=channelName,
-                text=message,
-                attachments=attachments,
-                mrkdwn=True,
-                parse="none",
-                unfurl_links=False,
-                unfurl_media=False,
-                link_names=True,
-                as_user=True,
-            )
-        else:
-            logger.debug(f"Posting message to {channelName} on thread {threadId} in Slack")
-            response = cls.client.chat_postMessage(
-                channel=channelName,
-                thread_ts=threadId,
-                text=message,
-                attachments=attachments,
-                mrkdwn=True,
-                parse="none",
-                unfurl_links=False,
-                unfurl_media=False,
-                link_names=True,
-                as_user=True,
-            )
-
-        if not response["ok"]:
-            logger.warning(response.data)
-            logger.warning("Failed to call Slack API")
-        return response
+    def postMessageBlocks(cls, channelList: str | list[str], messageBlocks: list, threadId: str = "") -> SlackResponse | list[SlackResponse]:
+        responses = []
+
+        if isinstance(channelList, str):
+            channelList = [channelList]
+        for channel in channelList:
+            logger.info(f"{channel}")
+            try:
+                if threadId == "":
+                    logger.debug(f"Posting {len(messageBlocks)} block message to {channel} in Slack")
+                    response = cls.client.chat_postMessage(
+                        channel=channel,
+                        blocks=messageBlocks,
+                        text="Summary text unavailable",
+                        mrkdwn=True,
+                        parse="none",
+                        unfurl_links=False,
+                        unfurl_media=False,
+                        link_names=True,
+                        as_user=True,
+                    )
+                else:
+                    logger.debug(f"Posting {len(messageBlocks)} block message to {channel} on thread {threadId} in Slack")
+                    response = cls.client.chat_postMessage(
+                        channel=channel,
+                        thread_ts=threadId,
+                        blocks=messageBlocks,
+                        text="Summary text unavailable",
+                        mrkdwn=True,
+                        parse="none",
+                        unfurl_links=False,
+                        unfurl_media=False,
+                        link_names=True,
+                        as_user=True,
+                    )
+
+                if not response["ok"]:
+                    logger.warning(response.data)
+                    logger.warning("Failed to call Slack API")
+                responses.append(response)
+            except Exception as e:
+                logger.error(f"Fail to send a message to {channel}: {e}")
+                raise
+
+        return responses if len(responses) > 1 else responses[0]
+
+    def postMessageText(cls, channelList: str | list[str], message: str, attachments=None, threadId: str = "") -> SlackResponse | list[SlackResponse]:
+        responses: list[str] = []
+
+        if isinstance(channelList, str):
+            channelList = [channelList]
+
+        for channel in channelList:
+            if threadId == "":
+                logger.debug(f"Posting message to {channel} in Slack")
+                response = cls.client.chat_postMessage(
+                    channel=channel,
+                    text=message,
+                    attachments=attachments,
+                    mrkdwn=True,
+                    parse="none",
+                    unfurl_links=False,
+                    unfurl_media=False,
+                    link_names=True,
+                    as_user=True,
+                )
+            else:
+                logger.debug(f"Posting message to {channel} on thread {threadId} in Slack")
+                response = cls.client.chat_postMessage(
+                    channel=channel,
+                    thread_ts=threadId,
+                    text=message,
+                    attachments=attachments,
+                    mrkdwn=True,
+                    parse="none",
+                    unfurl_links=False,
+                    unfurl_media=False,
+                    link_names=True,
+                    as_user=True,
+                )
+
+            if not response["ok"]:
+                logger.warning(response.data)
+                logger.warning("Failed to call Slack API")
+            responses.append(response)
+
+        return responses if len(responses) > 1 else responses[0]
 
     def createMessagePermalink(
         cls, slackResponse: SlackResponse = None, channelId: str = "", messageTimestamp: str = "", domain: str = "ibm-mas"
diff --git a/test/src/test_slack.py b/test/src/test_slack.py
@@ -21,3 +21,16 @@ def testSendMessage():
     assert response.data["ok"] is True
 
     assert "ts" in response.data
+
+
+def testBroadcast():
+    responses = SlackUtil.postMessageText(["#bot-test", "#bot-test"], "mas-devops unittest")
+
+    for response in responses:
+        assert "channel" in response.data
+        assert response.data["channel"] == "C06453F9KFC"
+
+        assert "ok" in response.data
+        assert response.data["ok"] is True
+
+        assert "ts" in response.data
