Add action to register user (#15)

Author: Amanda H. L. de Andrade Katz

.wokeignore

@@ -1 +1,2 @@
 lib/charms/nginx_ingress_integrator/v0/nginx_route.py
+pyproject.toml

actions.yaml

@@ -6,3 +6,19 @@ reset-instance:
     Set a new server_name before running this action.
     Once a server_name is configured, you must start a new instance if you wish a different one.
     This actions will erase all data and create a instance with the new server_name.
+register-user:
+  description: |
+    Registers a user for the Synapse server.
+    You need to supply a user name and whether that user should be an admin or not.
+  properties:
+    username:
+      description: |
+        When not using SSO, a user name is needed
+        for the creation of a matrix account.
+      type: string
+    admin:
+      description: Whether to create an admin user.
+      type: boolean
+      default: false
+  required:
+    - username

pyproject.toml

@@ -22,6 +22,9 @@ markers = [
     "requires_secrets: mark tests that require external secrets"
 ]
 
+[tool.pylint.'MESSAGES CONTROL']
+extension-pkg-whitelist = "pydantic"
+
 # Formatting tools configuration
 [tool.black]
 line-length = 99

requirements.txt

@@ -1,5 +1,6 @@
 jsonschema == 4.17.3
-ops >= 2.2.0
+ops >= 2.4.1
 pydantic == 1.10.10
 ops-lib-pgsql >= 1.4
 psycopg2-binary == 2.9.6
+requests>=2,<3

src/actions/__init__.py

@@ -0,0 +1,9 @@
+# Copyright 2023 Canonical Ltd.
+# See LICENSE file for licensing details.
+
+"""Actions package is used to run actions provided by the charm."""
+
+from .register_user import RegisterUserError, register_user  # noqa: F401
+
+# Exporting methods to be used for another modules
+from .reset_instance import ResetInstanceError, reset_instance  # noqa: F401

src/actions/register_user.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+
+# Copyright 2023 Canonical Ltd.
+# See LICENSE file for licensing details.
+
+"""Module to interact with Register User action."""
+
+import logging
+
+import ops
+
+# pydantic is causing this no-name-in-module problem
+from pydantic import ValidationError  # pylint: disable=no-name-in-module,import-error
+
+import synapse
+from user import User
+
+logger = logging.getLogger(__name__)
+
+
+class RegisterUserError(Exception):
+    """Exception raised when something fails while running register-user.
+
+    Attrs:
+        msg (str): Explanation of the error.
+    """
+
+    def __init__(self, msg: str):
+        """Initialize a new instance of the RegisterUserError exception.
+
+        Args:
+            msg (str): Explanation of the error.
+        """
+        self.msg = msg
+
+
+def register_user(container: ops.Container, username: str, admin: bool) -> User:
+    """Run register user action.
+
+    Args:
+        container: Container of the charm.
+        username: username to be registered.
+        admin: if user is admin.
+
+    Raises:
+        RegisterUserError: if something goes wrong while registering the user.
+
+    Returns:
+        User with password registered.
+    """
+    try:
+        registration_shared_secret = synapse.get_registration_shared_secret(container=container)
+        if registration_shared_secret is None:
+            raise RegisterUserError(
+                "registration_shared_secret was not found, please check the logs"
+            )
+        user = User(username=username, admin=admin)
+        synapse.register_user(registration_shared_secret=registration_shared_secret, user=user)
+        return user
+    except (ValidationError, synapse.APIError) as exc:
+        raise RegisterUserError(str(exc)) from exc

src/actions/reset_instance.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+
+# Copyright 2023 Canonical Ltd.
+# See LICENSE file for licensing details.
+
+"""Module to interact with Reset Instance action."""
+
+import logging
+import typing
+
+import ops
+import psycopg2
+
+import synapse
+from charm_state import CharmState
+from database_client import DatabaseClient, DatasourcePostgreSQL
+
+logger = logging.getLogger(__name__)
+
+
+class ResetInstanceError(Exception):
+    """Exception raised when something fails while running reset-instance.
+
+    Attrs:
+        msg (str): Explanation of the error.
+    """
+
+    def __init__(self, msg: str):
+        """Initialize a new instance of the ResetInstanceError exception.
+
+        Args:
+            msg (str): Explanation of the error.
+        """
+        self.msg = msg
+
+
+def reset_instance(
+    container: ops.Container,
+    charm_state: CharmState,
+    datasource: typing.Optional[DatasourcePostgreSQL],
+) -> None:
+    """Run reset instance action.
+
+    Args:
+        container: Container of the charm.
+        charm_state: charm state from the charm.
+        datasource: datasource to interact with the database.
+
+    Raises:
+        ResetInstanceError: if something goes wrong while resetting the instance.
+    """
+    try:
+        if datasource is not None:
+            logger.info("Erase Synapse database")
+            # Connecting to template1 to make it possible to erase the database.
+            # Otherwise PostgreSQL will prevent it if there are open connections.
+            db_client = DatabaseClient(datasource=datasource, alternative_database="template1")
+            db_client.erase()
+        synapse.execute_migrate_config(container=container, charm_state=charm_state)
+    except (psycopg2.Error, synapse.WorkloadError) as exc:
+        raise ResetInstanceError(str(exc)) from exc

src/charm.py

@@ -9,18 +9,16 @@
 import typing
 
 import ops
-import psycopg2
 from charms.nginx_ingress_integrator.v0.nginx_route import require_nginx_route
 from charms.traefik_k8s.v1.ingress import IngressPerAppRequirer
 from ops.charm import ActionEvent
 from ops.main import main
 
+import actions
 from charm_state import CharmConfigInvalidError, CharmState
 from constants import SYNAPSE_CONTAINER_NAME, SYNAPSE_PORT
-from database_client import DatabaseClient
 from database_observer import DatabaseObserver
-from pebble import PebbleService
-from synapse import CommandMigrateConfigError, ServerNameModifiedError, Synapse
+from pebble import PebbleService, PebbleServiceError
 
 logger = logging.getLogger(__name__)
 
@@ -41,8 +39,7 @@ def __init__(self, *args: typing.Any) -> None:
         except CharmConfigInvalidError as exc:
             self.model.unit.status = ops.BlockedStatus(exc.msg)
             return
-        self._synapse = Synapse(charm_state=self._charm_state)
-        self.pebble_service = PebbleService(synapse=self._synapse)
+        self.pebble_service = PebbleService(charm_state=self._charm_state)
         # service-hostname is a required field so we're hardcoding to the same
         # value as service-name. service-hostname should be set via Nginx
         # Ingress Integrator charm config.
@@ -64,6 +61,7 @@ def __init__(self, *args: typing.Any) -> None:
         self.framework.observe(self.on.config_changed, self._on_config_changed)
         self.framework.observe(self.on.reset_instance_action, self._on_reset_instance_action)
         self.framework.observe(self.on.synapse_pebble_ready, self._on_pebble_ready)
+        self.framework.observe(self.on.register_user_action, self._on_register_user_action)
 
     def change_config(self, _: ops.HookEvent) -> None:
         """Change configuration."""
@@ -74,12 +72,7 @@ def change_config(self, _: ops.HookEvent) -> None:
         self.model.unit.status = ops.MaintenanceStatus("Configuring Synapse")
         try:
             self.pebble_service.change_config(container)
-        except (
-            CharmConfigInvalidError,
-            CommandMigrateConfigError,
-            ops.pebble.PathError,
-            ServerNameModifiedError,
-        ) as exc:
+        except PebbleServiceError as exc:
             self.model.unit.status = ops.BlockedStatus(str(exc))
             return
         self.model.unit.status = ops.ActiveStatus()
@@ -120,24 +113,39 @@ def _on_reset_instance_action(self, event: ActionEvent) -> None:
             self.model.unit.status = ops.MaintenanceStatus("Resetting Synapse instance")
             self.pebble_service.reset_instance(container)
             datasource = self.database.get_relation_as_datasource()
-            if datasource is not None:
-                logger.info("Erase Synapse database")
-                # Connecting to template1 to make it possible to erase the database.
-                # Otherwise PostgreSQL will prevent it if there are open connections.
-                db_client = DatabaseClient(datasource=datasource, alternative_database="template1")
-                db_client.erase()
-            self._synapse.execute_migrate_config(container)
-            logger.info("Start Synapse database")
+            actions.reset_instance(
+                container=container, charm_state=self._charm_state, datasource=datasource
+            )
+            logger.info("Start Synapse")
             self.pebble_service.replan(container)
             results["reset-instance"] = True
-        except (psycopg2.Error, ops.pebble.PathError, CommandMigrateConfigError) as exc:
+        except (PebbleServiceError, actions.ResetInstanceError) as exc:
             self.model.unit.status = ops.BlockedStatus(str(exc))
             event.fail(str(exc))
             return
-        # results is a dict and set_results expects _SerializedData
-        event.set_results(results)  # type: ignore[arg-type]
+        event.set_results(results)
         self.model.unit.status = ops.ActiveStatus()
 
+    def _on_register_user_action(self, event: ActionEvent) -> None:
+        """Reset instance and report action result.
+
+        Args:
+            event: Event triggering the reset instance action.
+        """
+        container = self.unit.get_container(SYNAPSE_CONTAINER_NAME)
+        if not container.can_connect():
+            self.unit.status = ops.MaintenanceStatus("Waiting for pebble")
+            return
+        try:
+            user = actions.register_user(
+                container=container, username=event.params["username"], admin=event.params["admin"]
+            )
+        except actions.RegisterUserError as exc:
+            event.fail(str(exc))
+            return
+        results = {"register-user": True, "user-password": user.password}
+        event.set_results(results)
+
 
 if __name__ == "__main__":  # pragma: nocover
     main(SynapseCharm)

src/pebble.py

@@ -10,27 +10,44 @@
 
 import ops
 
+import synapse
+from charm_state import CharmState
 from constants import (
     CHECK_READY_NAME,
     SYNAPSE_COMMAND_PATH,
     SYNAPSE_CONTAINER_NAME,
     SYNAPSE_SERVICE_NAME,
 )
-from synapse import Synapse
 
 logger = logging.getLogger(__name__)
 
 
+class PebbleServiceError(Exception):
+    """Exception raised when something fails while interacting with Pebble.
+
+    Attrs:
+        msg (str): Explanation of the error.
+    """
+
+    def __init__(self, msg: str):
+        """Initialize a new instance of the PebbleServiceError exception.
+
+        Args:
+            msg (str): Explanation of the error.
+        """
+        self.msg = msg
+
+
 class PebbleService:
     """The charm pebble service manager."""
 
-    def __init__(self, synapse: Synapse):
+    def __init__(self, charm_state: CharmState):
         """Initialize the pebble service.
 
         Args:
-            synapse: Instance to interact with Synapse.
+            charm_state: Instance of CharmState.
         """
-        self._synapse = synapse
+        self._charm_state = charm_state
 
     def replan(self, container: ops.model.Container) -> None:
         """Replan the pebble service.
@@ -46,27 +63,39 @@ def change_config(self, container: ops.model.Container) -> None:
 
         Args:
             container: Charm container.
+
+        Raises:
+            PebbleServiceError: if something goes wrong while interacting with Pebble.
         """
-        self._synapse.execute_migrate_config(container)
-        self.replan(container)
+        try:
+            synapse.execute_migrate_config(container=container, charm_state=self._charm_state)
+            self.replan(container)
+        except (synapse.WorkloadError, ops.pebble.PathError) as exc:
+            raise PebbleServiceError(str(exc)) from exc
 
     def reset_instance(self, container: ops.model.Container) -> None:
         """Reset instance.
 
         Args:
             container: Charm container.
+
+        Raises:
+            PebbleServiceError: if something goes wrong while interacting with Pebble.
         """
         # This is needed in the case of relation with Postgresql.
         # If there is open connections it won't be possible to drop the database.
-        logger.info("Replan service to not restart")
-        container.add_layer(
-            SYNAPSE_CONTAINER_NAME, self._pebble_layer_without_restart, combine=True
-        )
-        container.replan()
-        logger.info("Stop Synapse instance")
-        container.stop(SYNAPSE_SERVICE_NAME)
-        logger.info("Erase Synapse data")
-        self._synapse.reset_instance(container)
+        try:
+            logger.info("Replan service to not restart")
+            container.add_layer(
+                SYNAPSE_CONTAINER_NAME, self._pebble_layer_without_restart, combine=True
+            )
+            container.replan()
+            logger.info("Stop Synapse instance")
+            container.stop(SYNAPSE_SERVICE_NAME)
+            logger.info("Erase Synapse data")
+            synapse.reset_instance(container)
+        except ops.pebble.PathError as exc:
+            raise PebbleServiceError(str(exc)) from exc
 
     @property
     def _pebble_layer(self) -> ops.pebble.LayerDict:
@@ -80,11 +109,11 @@ def _pebble_layer(self) -> ops.pebble.LayerDict:
                     "summary": "Synapse application service",
                     "startup": "enabled",
                     "command": SYNAPSE_COMMAND_PATH,
-                    "environment": self._synapse.synapse_environment(),
+                    "environment": synapse.get_environment(self._charm_state),
                 }
             },
             "checks": {
-                CHECK_READY_NAME: self._synapse.check_ready(),
+                CHECK_READY_NAME: synapse.check_ready(),
             },
         }
         return typing.cast(ops.pebble.LayerDict, layer)