Update Splice from CCI (#403)

Signed-off-by: DA Automation <splice-maintainers@digitalasset.com>
Co-authored-by: DA Automation <splice-maintainers@digitalasset.com>

Author: canton-network-da

.github/actions/scripts/notification-scripts/failure_github_issue.py

@@ -3,220 +3,39 @@
 # Copyright (c) 2024 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-import re
-from gql import gql, Client
-from gql.transport.requests import RequestsHTTPTransport
-from abc import ABC, abstractmethod
 from failure_notification_args import FailureArgs
+import os
+from git import Repo
 
 GH_ORGANIZATION="DACH-NY"
 GH_REPO="cn-test-failures"
 GH_FAILURES_PROJECT=48
 
-class ProjectFields:
-  def __init__(self, data: list[dict[str, str]]):
-    self.data = data
+class FailureGithubIssue():
 
-  def get_field_id(self, name: str) -> str:
-    return [f for f in self.data if f["name"] == name][0]["id"]
-
-class FailureGithubIssue(ABC):
-
-
-  def get_repo_id(self, client: Client, organization: str, repo_name: str) -> str:
-    query = gql(
-    """
-    query getRepoId($owner: String!, $name: String!) {
-      repository(owner: $owner, name: $name) {
-        id
-      }
-    }
-    """
-    )
-    params = {
-      "owner": organization,
-      "name": repo_name
-    }
-    response = client.execute(query, params)
-    return response["repository"]["id"]
-
-  def get_project_id(self, client: Client, organization: str, project_number: str) -> str:
-    query = gql(
-    """
-      query getProjectId($organization: String!, $projectNumber: Int!) {
-        organization(login: $organization) {
-          projectV2(number: $projectNumber) {
-            id
-          }
-        }
-      }
-    """
-    )
-    params = {
-      "organization": organization,
-      "projectNumber": project_number
-    }
-    response = client.execute(query, params)
-    return response["organization"]["projectV2"]["id"]
-
-  def create_issue(self, client: Client, repo_id: str, title: str, body: str) -> str:
-    query = gql(
-    """
-    mutation createIssue($repositoryId: ID!, $title: String!, $body: String!) {
-      createIssue(input: {
-        repositoryId: $repositoryId,
-        title: $title,
-        body: $body
-      }) {
-        issue {
-          id
-        }
-      }
-    }
-    """
-    )
-    params = {
-      "repositoryId": repo_id,
-      "title": title,
-      "body": body
-    }
-    response = client.execute(query, params)
-    return response["createIssue"]["issue"]["id"]
-
-  def add_issue_to_project(self, client: Client, project_id: str, issue_id: str) -> str:
-    query = gql(
-    """
-      mutation addToProject($projectId: ID!, $contentId: ID!) {
-        addProjectV2ItemById(input: {
-          projectId: $projectId,
-          contentId: $contentId
-        }) { item { id } }
-      }
-    """
-    )
-    params = {
-      "projectId": project_id,
-      "contentId": issue_id
-    }
-    response = client.execute(query, params)
-    return response["addProjectV2ItemById"]["item"]["id"]
-
-  def get_issue_number(self, client: Client, issue_id: str) -> str:
-    query = gql(
-    """
-    query getIssueNumber($issueId: ID!) {
-      node(id: $issueId) {
-        ... on Issue {
-          number
-        }
-      }
-    }
-    """
-    )
-    params = {
-      "issueId": issue_id
-    }
-    response = client.execute(query, params)
-    return response["node"]["number"]
-
-  def get_project_fields(self, client: Client, project_id: str) -> ProjectFields:
-    query = gql(
-    """
-      query getFields($projectId: ID!) {
-        node(id: $projectId) {
-          ... on ProjectV2 {
-            fields(first: 20) {
-              nodes {
-                ... on ProjectV2FieldCommon {
-                  id
-                  name
-                }
-              }
-            }
-          }
-        }
-      }
-    """
-    )
-    params = {
-      "projectId": project_id
-    }
-    response = client.execute(query, params)
-    return ProjectFields(response["node"]["fields"]["nodes"])
-
-  def set_field_value(self, client: Client, project_id: str, item_id: str, field_id: str, value: str) -> str:
-    query = gql(
-    """
-    mutation setProjectItemValue($projectId: ID!, $itemId: ID!, $fieldId: ID!, $value: String!) {
-      updateProjectV2ItemFieldValue(
-        input: {
-          projectId: $projectId
-          itemId: $itemId
-          fieldId: $fieldId
-          value: {
-            text: $value
-          }
-        }
-      )
-      {
-        projectV2Item {
-          id
-        }
-      }
-    }
-
-    """
-    )
-
-    params = {
-      "projectId": project_id,
-      "itemId": item_id,
-      "fieldId": field_id,
-      "value": value
-    }
-    response = client.execute(query, params)
-    return response["updateProjectV2ItemFieldValue"]["projectV2Item"]["id"]
-
-  @abstractmethod
   def get_msg(self) -> tuple[str, str]:
-    pass
-
-  @abstractmethod
-  def get_workflow_name(self) -> str:
-    pass
-
-  def report_failure(self) -> str:
-    if not re.match(self.args.branch_pattern, self.args.branch):
-      print(f"Branch {self.args.branch} does not match pattern {self.args.branch_pattern}, skipping notification")
-      exit(0)
-
-    (title, body) = self.get_msg()
-
-    if self.args.dry_run:
-      print(f"Creating an issue with title: {title} and body: {body}")
-      return
-
-    transport = RequestsHTTPTransport(url="https://api.github.com/graphql",
-                                      headers={'Authorization': 'token ' + self.args.github_token})
-    client = Client(transport=transport, fetch_schema_from_transport=True)
-
-    repo_id = self.get_repo_id(client, GH_ORGANIZATION, GH_REPO)
-    project_id = self.get_project_id(client, GH_ORGANIZATION, GH_FAILURES_PROJECT)
-    fields = self.get_project_fields(client, project_id)
-    cluster_field_id = fields.get_field_id("Cluster")
-    job_field_id = fields.get_field_id("Job")
-
-    issue_id = self.create_issue(client, repo_id, title, body)
-    issue_project_item_id = self.add_issue_to_project(client, project_id, issue_id)
-    if self.args.cluster:
-      self.set_field_value(client, project_id, issue_project_item_id, cluster_field_id, self.args.cluster)
-    workflow_name = self.get_workflow_name()
-    self.set_field_value(client, project_id, issue_project_item_id, job_field_id, f"{workflow_name}:{self.args.job_name}")
-
-    issue_number = self.get_issue_number(client, issue_id)
-    issue_url = f"https://github.com/{GH_ORGANIZATION}/{GH_REPO}/issues/{issue_number}"
-
-    return issue_url
+    GITHUB_SERVER_URL=os.environ.get('GITHUB_SERVER_URL')
+    GITHUB_REPOSITORY=os.environ.get('GITHUB_REPOSITORY')
+    GIT_SHA=os.environ.get('GITHUB_SHA')
+    branch_url=f"{GITHUB_SERVER_URL}/{GITHUB_REPOSITORY}/tree/{self.args.branch}"
+    github_url=f"{GITHUB_SERVER_URL}/{GITHUB_REPOSITORY}/commit/{GIT_SHA}"
+    # Unfortunately, github does not provide a way to get the job number, s.a. https://github.com/orgs/community/discussions/129314
+    # so we can only link to the run, not directly to the failed job
+    job_url=f"{GITHUB_SERVER_URL}/{GITHUB_REPOSITORY}/actions/runs/{self.args.gha_run_id}"
+    repo = Repo(search_parent_directories=True)
+    commit_msg = repo.head.commit.summary
+    commit_sha_short = GIT_SHA[:7]
+
+    title = f"GHA Run {self.args.gha_run_id} : job {self.args.job_name} Failed :fire:"
+    body = f"""
+[GitHub Actions Run]({job_url}).
+Branch: [{self.args.branch}]({branch_url})
+Workflow: {self.args.gha_workflow_name}
+Commit: [{commit_sha_short}]({github_url}) {commit_msg}
+Actor: {os.environ.get('GITHUB_ACTOR')}
+"""
+
+    return (title, body)
 
   def __init__(self, args: FailureArgs):
     self.args = args

.github/actions/scripts/notification-scripts/failure_github_issue_gha.py

@@ -3,15 +3,51 @@
 # Copyright (c) 2024 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-from failure_github_issue import *
+from failure_github_issue import FailureGithubIssue
+from slack_notification import SlackNotification
 from failure_notification_args import *
-from failure_github_issue_gha import *
-from slack_notification_gha import *
+import requests
+import sys
+import os
 
 if __name__ == "__main__":
-  print("Parsing arguments")
   args = parse_args()
-  print(f"Creating issue with args {args}")
-  gh_url = GHAFailureGithubIssue(args).report_failure()
-  GHASlackNotification(args).send_notification(gh_url)
-  print("Sent notification")
+
+  gh = FailureGithubIssue(args)
+  (gh_title, gh_msg) = gh.get_msg()
+  workflow_name = args.gha_workflow_name
+  job_name = args.job_name
+
+  slack_msg = SlackNotification(args).build_msg("##GH_ISSUE##")
+  channel = os.environ.get('NOTIFICATION_SLACK_CHANNEL')
+
+  token = os.environ.get('FAILURE_NOTIFICATIONS_TOKEN')
+  if not token:
+    print("FAILURE_NOTIFICATIONS_TOKEN is not set")
+    sys.exit(1)
+
+  r = requests.post(
+    url = os.environ.get('FAILURE_NOTIFICATIONS_URL'),
+    headers = {
+      "Authorization": f"Bearer {token}",
+    },
+    json={
+      "issue": {
+        "title": gh_title,
+        "body": gh_msg,
+        "workflow_name": workflow_name,
+        "job_name": job_name,
+      },
+      "slack_notification": {
+        "msg": slack_msg,
+        "channel": channel,
+      }
+    },
+  )
+  if r.status_code != 200:
+    print(f"Error sending notifications: {r.text}")
+    sys.exit(1)
+  else:
+    print(f"Sent notification: {r.text}")
+    sys.exit(0)
+

.github/actions/scripts/notification-scripts/failure_notification.py

@@ -1,40 +1,15 @@
 # Copyright (c) 2024 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-import os
-import json
-import requests
-import sys
-import re
-from abc import ABC, abstractmethod
 from failure_notification_args import FailureArgs
 
-class SlackNotification(ABC):
-  @abstractmethod
+class SlackNotification():
   def build_msg(self, gh_url: str):
-    pass
-
-  def send_notification(self, gh_url: str):
-
-    if not re.match(self.args.branch_pattern, self.args.branch):
-      print(f"Branch {self.args.branch} does not match pattern {self.args.branch_pattern}, skipping notification")
-      sys.exit(0)
-
-    text = self.build_msg(gh_url)
-    msg = {"text": text, "channel": self.args.slack_channel}
-
-    print(f"Notification: {json.dumps(msg)}")
-
-    if not self.args.dry_run:
-      requests.post(
-        "https://slack.com/api/chat.postMessage",
-        json=msg,
-        headers={
-          "Authorization": f"Bearer {os.environ.get('SLACK_ACCESS_TOKEN')}",
-          "Content-Type": "application/json"})
+    cluster_text = f" on cluster {self.args.cluster}" if self.args.cluster else ""
+    text=f"""*GHA job {self.args.gha_workflow_name}:{self.args.job_name} {self.args.gha_run_id} failed {cluster_text}:dumpster-fire:.
+    (<{gh_url}|Issue in GitHub>)"""
 
+    return text
 
   def __init__(self, args: FailureArgs):
     self.args = args
-
-