Post updates about releases to a different room (#3)

Author: bradtgmurray

base-config.yaml

@@ -11,6 +11,8 @@ linear:
     # IDs of Linear organizations that are allowed to use the bot.
     # Empty list disables the whitelist.
     allowed_organizations: []
+    # Label IDs for issues that are releases and should be shared to the release room
+    release_label_ids: []
 
 # Settings for reading data from GitLab for migration purposes
 gitlab:

linearbot/api/client.py

@@ -4,8 +4,8 @@
 
 from yarl import URL
 
-from .types import Issue, User, IssueMeta, IssueSummary, IssueCreateResponse, Label
-from .queries import (get_user_details, get_user, get_issue, get_issue_details, get_labels,
+from .types import Issue, User, IssueMeta, IssueSummary, IssueLabels, IssueCreateResponse, Label
+from .queries import (get_user_details, get_user, get_issue, get_issue_details, get_issue_labels, get_labels,
                       create_issue, create_comment, create_reaction, create_label, update_label)
 
 if TYPE_CHECKING:
@@ -158,6 +158,11 @@ async def get_issue_details(self, issue_identifier: str) -> IssueSummary:
         issue = IssueSummary.deserialize(resp["issue"])
         return issue
 
+    async def get_issue_labels(self, issue_id: UUID) -> List[UUID]:
+        resp = await self.request(get_issue_labels, variables={"issueID": str(issue_id)})
+        issue = IssueLabels.deserialize(resp["issue"])
+        return issue.label_ids
+
     async def get_all_labels(self) -> Dict[UUID, Dict[str, Label]]:
         teams = {}
         has_next_page = True
@@ -166,7 +171,11 @@ async def get_all_labels(self) -> Dict[UUID, Dict[str, Label]]:
             resp = await self.request(get_labels, variables={"cursor": cursor})
             for raw_label in resp["issueLabels"]["nodes"]:
                 label = Label.deserialize(raw_label)
-                teams.setdefault(label.team.id, {})[label.name] = label
+                team_id = getattr(label.team, 'id', None)
+                if team_id is not None:
+                    teams.setdefault(team_id, {})[label.name] = label
+                else:
+                    self.log.warning(f"Label {label.name} has no team ID")
             has_next_page = resp["issueLabels"]["pageInfo"]["hasNextPage"]
             cursor = resp["issueLabels"]["pageInfo"]["endCursor"]
         return teams

linearbot/api/queries.py

@@ -71,6 +71,15 @@
     }
 }"""
 
+# language=graphql
+get_issue_labels = """query GetIssueLabels($issueID: String!) {
+    issue(id: $issueID) {
+        id
+        title
+        labelIds
+    }
+}"""
+
 # language=graphql
 create_issue = """mutation CreateIssue($input: IssueCreateInput!) {
     issueCreate(input: $input) {

linearbot/api/types.py

@@ -178,6 +178,10 @@ class IssueSummary(IssueMeta):
     project: Optional[MinimalProject] = None
     state: Optional[IssueState] = None
 
+@dataclass
+class IssueLabels(MinimalIssue):
+    label_ids: Optional[List[UUID]] = field(json="labelIds", default=None)
+
 @dataclass(kw_only=True)
 class Issue(MinimalIssue, SerializableAttrs, LinearEventData):
     number: int

linearbot/bot.py

@@ -33,6 +33,7 @@ def do_update(self, helper: ConfigUpdateHelper) -> None:
         helper.copy("linear.client_id")
         helper.copy("linear.client_secret")
         helper.copy("linear.allowed_organizations")
+        helper.copy("linear.release_label_ids")
 
         helper.copy("gitlab.url")
         helper.copy("gitlab.token")
@@ -98,6 +99,7 @@ def get_config_class(cls) -> Type[BaseProxyConfig]:
     def on_external_config_update(self) -> None:
         self.config.load_and_update()
         self.linear_webhook.secret = self.config["linear.webhook_secret"]
+        self.linear_webhook.release_label_ids = {UUID(id) for id in self.config["linear.release_label_ids"]}
         self.linear_bot.authorization = self.config["linear.token"]
         self.oauth_client_id = self.config["linear.client_id"]
         self.oauth_client_secret = self.config["linear.client_secret"]

linearbot/webhook.py

@@ -1,4 +1,4 @@
-from typing import Set, List, TYPE_CHECKING
+from typing import Set, List, Optional, TYPE_CHECKING
 from uuid import UUID
 import asyncio
 import json
@@ -21,7 +21,6 @@
 spaces = re.compile(" +")
 space = " "
 
-
 class LinearWebhook:
     bot: 'LinearBot'
     secret: str
@@ -30,6 +29,8 @@ class LinearWebhook:
     handled_webhooks: Set[UUID]
     ignore_uuids: Set[UUID]
     messages: TemplateManager
+    release_label_ids: Set[UUID]
+
     # templates: TemplateManager
 
     def __init__(self, bot: 'LinearBot') -> None:
@@ -39,6 +40,7 @@ def __init__(self, bot: 'LinearBot') -> None:
         self.joined_rooms = set()
         self.handled_webhooks = set()
         self.ignore_uuids = set()
+        self.release_label_ids = set()
 
         self.messages = TemplateManager(self.bot.loader, "templates/messages")
         # self.templates = TemplateManager(self.bot.loader, "templates/mixins")
@@ -51,7 +53,8 @@ async def stop(self) -> None:
         if self.task_list:
             await asyncio.wait(self.task_list, timeout=1)
 
-    async def handle_webhook(self, room_id: RoomID, evt: LinearEvent) -> None:
+    async def handle_webhook(self, room_id: Optional[RoomID], release_room_id: Optional[RoomID],
+                             evt: LinearEvent) -> None:
         if evt.data.id in self.ignore_uuids:
             self.log.debug(f"Dropping webhook for {evt.type} {evt.data.id}"
                            " that was marked to be ignored")
@@ -98,12 +101,22 @@ def abort() -> None:
             content.external_url = evt.url
         query = {"ts": int(evt.created_at.timestamp() * 1000)}
 
-        await self.bot.client.send_message(room_id, content, query_params=query)
+        if room_id is not None:
+            await self.bot.client.send_message(room_id, content, query_params=query)
+
+        # Only post in the release room if the issue has one of the release labels
+        if release_room_id is not None:
+            issue_id = getattr(evt.data, 'issue_id', None)
+            if issue_id is not None:
+                label_ids = await self.bot.linear_bot.get_issue_labels(issue_id)
+                if set(label_ids) & self.release_label_ids:
+                    await self.bot.client.send_message(release_room_id, content, query_params=query)
 
-    async def _try_handle_webhook(self, delivery_id: UUID, room_id: RoomID, evt: LinearEvent
+    async def _try_handle_webhook(self, delivery_id: UUID, room_id: Optional[RoomID], release_room_id: Optional[RoomID],
+                                  evt: LinearEvent
                                   ) -> None:
         try:
-            await self.handle_webhook(room_id, evt)
+            await self.handle_webhook(room_id, release_room_id, evt)
         except Exception:
             self.log.exception(f"Error handling webhook {delivery_id}")
         finally:
@@ -123,12 +136,23 @@ async def webhook(self, request: Request) -> Response:
         try:
             room_id = RoomID(request.url.query["room_id"])
         except KeyError:
-            return Response(status=400, text="400: Bad Request\n"
-                                             "Missing `room_id` query parameter\n")
-        if room_id not in self.joined_rooms:
-            return Response(text="403: Forbidden\nThe bot is not in the room. "
+            room_id = None
+
+        if room_id is not None and room_id not in self.joined_rooms:
+            return Response(text=f"403: Forbidden\nThe bot is not in the room {room_id}. "
+                                 f"Please invite {self.bot.client.mxid} to the room.\n",
+                            status=403)
+
+        try:
+            release_room_id = RoomID(request.url.query["release_room_id"])
+        except KeyError:
+            release_room_id = None
+
+        if release_room_id is not None and release_room_id not in self.joined_rooms:
+            return Response(text=f"403: Forbidden\nThe bot is not in the room {release_room_id}. "
                                  f"Please invite {self.bot.client.mxid} to the room.\n",
                             status=403)
+
         try:
             delivery_id = UUID(request.headers["Linear-Delivery"])
         except (KeyError, ValueError):
@@ -161,7 +185,7 @@ async def webhook(self, request: Request) -> Response:
             self.log.debug("Recognized data in %s: %s", delivery_id, evt)
         except AttributeError:
             self.log.trace("Received event %s: %s", delivery_id, evt)
-        task = asyncio.create_task(self._try_handle_webhook(delivery_id, room_id, evt))
+        task = asyncio.create_task(self._try_handle_webhook(delivery_id, room_id, release_room_id, evt))
         self.task_list.append(task)
         return Response(status=202, text="202: Accepted\nWebhook processing started.\n")