Added options to compiler service to configure notification behavior (Issue #4803, PR #4829)

# Description

- add an option to configure if notification is required
- add message option to use when notification is used
- add sane defaults for both to ensure backwards compatibility

closes #4803

# Self Check:

Strike through any lines that are not applicable (`~~line~~`) then check the box

- [x] Attached issue to pull request
- [x] Changelog entry
- [x] Type annotations are present
- [x] Code is clear and sufficiently documented
- [x] No (preventable) type errors (check using make mypy or make mypy-diff)
- [x] Sufficient test cases (reproduces the bug/tests the requested feature)
- [x] Correct, in line with design
- [x] End user documentation is included or an issue is created for end-user documentation (add ref to issue here: )

# Reviewer Checklist:

- [ ] Sufficient test cases (reproduces the bug/tests the requested feature)
- [ ] Code is clear and sufficiently documented
- [ ] Correct, in line with design

Author: FloLey

changelogs/unreleased/4803-compiler-service-notification.yml

@@ -0,0 +1,7 @@
+description: Added options to compiler service to configure notification behavior
+change-type: minor
+destination-branches: [master, iso5]
+issue-nr: 4803
+sections: {
+  minor-improvement: "{{description}}"
+}

src/inmanta/data/__init__.py

@@ -3484,6 +3484,9 @@ class Compile(BaseDocument):
         to this one that actually got compiled.
     :param partial: True if the compile only contains the entities/resources for the resource sets that should be updated
     :param removed_resource_sets: indicates the resource sets that should be removed from the model
+    :param notify_failed_compile: if true use the notification service to notify that a compile has failed.
+        By default, notifications are enabled only for exporting compiles.
+    :param failed_compile_message: Optional message to use when a notification for a failed compile is created
     """
 
     __primary_key__ = ("id",)
@@ -3513,6 +3516,9 @@ class Compile(BaseDocument):
     partial: bool = False
     removed_resource_sets: list[str] = []
 
+    notify_failed_compile: Optional[bool] = None
+    failed_compile_message: Optional[str] = None
+
     @classmethod
     async def get_substitute_by_id(cls, compile_id: uuid.UUID) -> Optional["Compile"]:
         """

src/inmanta/data/model.py

@@ -151,6 +151,9 @@ class CompileRunBase(BaseModel):
     partial: bool = False
     removed_resource_sets: list[str] = []
 
+    notify_failed_compile: Optional[bool] = None
+    failed_compile_message: Optional[str] = None
+
 
 class CompileRun(CompileRunBase):
     compile_data: Optional[CompileData]

src/inmanta/db/versions/v202209090.py

@@ -0,0 +1,29 @@
+"""
+    Copyright 2022 Inmanta
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+    Contact: code@inmanta.com
+"""
+
+from asyncpg import Connection
+
+
+async def update(connection: Connection) -> None:
+    schema = """
+    ALTER TABLE public.compile
+        ADD COLUMN notify_failed_compile boolean DEFAULT NULL,
+        ADD COLUMN failed_compile_message varchar DEFAULT NULL;
+    """
+    async with connection.transaction():
+        await connection.execute(schema)

src/inmanta/server/services/compilerservice.py

@@ -570,11 +570,19 @@ async def request_recompile(
         env_vars: Optional[Mapping[str, str]] = None,
         partial: bool = False,
         removed_resource_sets: Optional[List[str]] = None,
+        notify_failed_compile: Optional[bool] = None,
+        failed_compile_message: Optional[str] = None,
     ) -> Tuple[Optional[uuid.UUID], Warnings]:
         """
         Recompile an environment in a different thread and taking wait time into account.
 
+        :param notify_failed_compile: if set to True, errors during compilation will be notified using the
+        "failed_compile_message".
+        if set to false, nothing will be notified. If not set then the default notifications are
+        sent (failed pull stage and errors during the do_export)
+        :param failed_compile_message: the message used in notifications if notify_failed_compile is set to True.
         :return: the compile id of the requested compile and any warnings produced during the request
+
         """
         if removed_resource_sets is None:
             removed_resource_sets = []
@@ -600,6 +608,8 @@ async def request_recompile(
             environment_variables=env_vars,
             partial=partial,
             removed_resource_sets=removed_resource_sets,
+            notify_failed_compile=notify_failed_compile,
+            failed_compile_message=failed_compile_message,
         )
         await compile.insert()
         await self._queue(compile)

src/inmanta/server/services/notificationservice.py

@@ -70,7 +70,18 @@ async def compile_done(self, compile: data.Compile) -> None:
             failed_pull_stage = next(
                 (report for report in reports if report["name"] == "Pulling updates" and report["returncode"] != 0), None
             )
-            if failed_pull_stage:
+            if compile.notify_failed_compile is False:
+                return
+            elif compile.notify_failed_compile and compile.failed_compile_message:
+                # Use specific message provided in request
+                await self.notify(
+                    compile.environment,
+                    title="Compilation failed",
+                    message=compile.failed_compile_message,
+                    severity=const.NotificationSeverity.error,
+                    uri=f"/api/v2/compilereport/{compile.id}",
+                )
+            elif failed_pull_stage:
                 await self.notify(
                     compile.environment,
                     title="Pulling updates during compile failed",
@@ -86,6 +97,15 @@ async def compile_done(self, compile: data.Compile) -> None:
                     severity=const.NotificationSeverity.error,
                     uri=f"/api/v2/compilereport/{compile.id}",
                 )
+            elif compile.notify_failed_compile:
+                # Send notification with generic message as fallback
+                await self.notify(
+                    compile.environment,
+                    title="Compilation failed",
+                    message="A compile has failed",
+                    severity=const.NotificationSeverity.error,
+                    uri=f"/api/v2/compilereport/{compile.id}",
+                )
 
     async def notify(
         self,