Merge pull request #4 from canonical/feature/support_legacy_mysql

support for legacy mysql/mariadb

Author: paulomach

README.md

@@ -1,26 +1,35 @@
-<!--
-Avoid using this README file for information that is maintained or published elsewhere, e.g.:
+# MySQL Test Application
 
-* metadata.yaml > published on Charmhub
-* documentation > published on (or linked to from) Charmhub
-* detailed contribution guide > documentation or CONTRIBUTING.md
+MySQL stack tester charm - this is a simple application used exclusively for integrations test of
+[mysql-k8s][mysql-k8s], [mysql][mysql], [mysql-router-k8s][mysql-router-k8s],
+[mysql-router][mysql-router], [mysql-bundle-k8s][mysql-bundle-k8s] and
+[mysql-bundle][mysql-bundle].
 
-Use links instead.
--->
+## Relations
 
-# mysql-test-app
+This charm implements relations interfaces:
+* database
+* mysql (legacy)
 
-Charmhub package name: operator-template
-More information: https://charmhub.io/mysql-test-app
+On using the `mysql` legacy relation interface with either [mysql] or [mysql-k8s] charms, its
+necessary to config the database name with:
 
-Describe your charm in one or two sentences.
+```shell
+> juju config mysql-k8s mysql-interface-database=continuous_writes_database
+```
 
-## Other resources
+## Actions
 
-<!-- If your charm is documented somewhere else other than Charmhub, provide a link separately. -->
+Actions are listed on [actions page](https://charmhub.io/mysql-test-app/actions)
 
-- [Read more](https://example.com)
 
-- [Contributing](CONTRIBUTING.md) <!-- or link to other contribution documentation -->
+[mysql-k8s]: https://charmhub.io/mysql-k8s
+[mysql]: https://charmhub.io/mysql
+[mysql-router-k8s]: https://charmhub.io/mysql-router-k8s
+[mysql-router]: https://charmhub.io/mysql-router?channel=dpe/edge
+[mysql-bundle-k8s]: https://charmhub.io/mysql-bundle-k8s
+[mysql-bundle]: https://charmhub.io/mysql-bundle
 
-- See the [Juju SDK documentation](https://juju.is/docs/sdk) for more information about developing and improving charms.
+## References
+
+* [MySQL Test App at Charmhub](https://charmhub.io/mysql-test-app)

actions.yaml

@@ -27,3 +27,5 @@ get-session-ssl-cipher:
 get-server-certificate:
   description: Retrieve server certificate in pem format
 
+get-legacy-mysql-credentials:
+  description: Get the credentials for the legacy mysql user

metadata.yaml

@@ -3,7 +3,7 @@
 
 name: mysql-test-app
 description: |
-  An application charm used in high availability MySQL k8s integration tests.
+  An application charm used in high availability MySQL k8s/vm integration tests.
 summary: |
   Data platform libs application meant to be used
   only for testing high availability of the MySQL charm.
@@ -12,6 +12,8 @@ requires:
   database:
     interface: mysql_client
     limit: 1
+  mysql:
+    interface: mysql
 
 peers:
   application-peers:

src/charm.py

@@ -22,17 +22,20 @@
 from tenacity import RetryError, Retrying, stop_after_delay, wait_fixed
 
 from connector import MySQLConnector  # isort: skip
+from literals import (
+    CONTINUOUS_WRITE_TABLE_NAME,
+    DATABASE_NAME,
+    DATABASE_RELATION,
+    LEGACY_MYSQL_RELATION,
+    PEER,
+    PROC_PID_KEY,
+    RANDOM_VALUE_KEY,
+    RANDOM_VALUE_TABLE_NAME,
+)
+from relations.legacy_mysql import LegacyMySQL
 
 logger = logging.getLogger(__name__)
 
-CONTINUOUS_WRITE_TABLE_NAME = "data"
-DATABASE_NAME = "continuous_writes_database"
-DATABASE_RELATION = "database"
-PEER = "application-peers"
-PROC_PID_KEY = "proc-pid"
-RANDOM_VALUE_KEY = "inserted_value"
-RANDOM_VALUE_TABLE_NAME = "random_data"
-
 
 class MySQLTestApplication(CharmBase):
     """Application charm that continuously writes to MySQL."""
@@ -42,7 +45,9 @@ def __init__(self, *args):
 
         # Charm events
         self.framework.observe(self.on.start, self._on_start)
+        self.framework.observe(self.on[PEER].relation_changed, self._on_peer_relation_changed)
 
+        # Action handlers
         self.framework.observe(
             getattr(self.on, "clear_continuous_writes_action"),
             self._on_clear_continuous_writes_action,
@@ -79,6 +84,11 @@ def __init__(self, *args):
         self.framework.observe(
             self.on[DATABASE_RELATION].relation_broken, self._on_relation_broken
         )
+        self.framework.observe(
+            self.on[LEGACY_MYSQL_RELATION].relation_broken, self._on_relation_broken
+        )
+        # Legacy MySQL/MariaDB Handler
+        self.legacy_mysql = LegacyMySQL(self)
 
     # ==============
     # Properties
@@ -108,13 +118,22 @@ def unit_peer_data(self) -> Dict:
     @property
     def _database_config(self):
         """Returns the database config to use to connect to the MySQL cluster."""
-        data = list(self.database.fetch_relation_data().values())[0]
-
-        username, password, endpoints = (
-            data.get("username"),
-            data.get("password"),
-            data.get("endpoints"),
-        )
+        # identify the database relation
+        if self.model.get_relation(DATABASE_RELATION):
+            data = list(self.database.fetch_relation_data().values())[0]
+
+            username, password, endpoints = (
+                data.get("username"),
+                data.get("password"),
+                data.get("endpoints"),
+            )
+        elif self.model.get_relation(LEGACY_MYSQL_RELATION):
+            username = self.app_peer_data.get(f"{LEGACY_MYSQL_RELATION}-user")
+            password = self.app_peer_data.get(f"{LEGACY_MYSQL_RELATION}-password")
+            endpoints = self.app_peer_data.get(f"{LEGACY_MYSQL_RELATION}-host")
+            endpoints = f"{endpoints}:3306"
+        else:
+            return {}
         if None in [username, password, endpoints]:
             return {}
 
@@ -168,9 +187,6 @@ def _start_continuous_writes(self, starting_number: int) -> None:
 
     def _stop_continuous_writes(self) -> Optional[int]:
         """Stop continuous writes to the MySQL cluster and return the last written value."""
-        if not self._database_config:
-            return None
-
         if not self.unit_peer_data.get(PROC_PID_KEY):
             return None
 
@@ -193,7 +209,7 @@ def _stop_continuous_writes(self) -> Optional[int]:
         return last_written_value
 
     def _max_written_value(self) -> int:
-        """Return the count of rows in the continuous writes table."""
+        """Return the max value in the continuous writes table."""
         if not self._database_config:
             return -1
 
@@ -203,7 +219,7 @@ def _max_written_value(self) -> int:
             )
             return cursor.fetchone()[0]
 
-    def _create_test_table(self, cursor) -> None:
+    def _create_random_value_table(self, cursor) -> None:
         """Create a test table in the database."""
         cursor.execute(
             (
@@ -214,7 +230,7 @@ def _create_test_table(self, cursor) -> None:
             )
         )
 
-    def _insert_test_data(self, cursor, random_value: str) -> None:
+    def _insert_random_value(self, cursor, random_value: str) -> None:
         """Insert the provided random value into the test table in the database."""
         cursor.execute(f"INSERT INTO `{RANDOM_VALUE_TABLE_NAME}`(data) VALUES('{random_value}')")
 
@@ -232,9 +248,9 @@ def _write_random_value(self) -> str:
             for attempt in Retrying(stop=stop_after_delay(60), wait=wait_fixed(5)):
                 with attempt:
                     with MySQLConnector(self._database_config) as cursor:
-                        self._create_test_table(cursor)
+                        self._create_random_value_table(cursor)
                         random_value = self._generate_random_values(10)
-                        self._insert_test_data(cursor, random_value)
+                        self._insert_random_value(cursor, random_value)
         except RetryError:
             logger.exception("Unable to write to the database")
             return random_value
@@ -248,8 +264,11 @@ def _write_random_value(self) -> str:
     # ==============
     def _on_start(self, _) -> None:
         """Handle the start event."""
-        self.unit.set_workload_version("0.0.1")
-        self.unit.status = WaitingStatus()
+        self.unit.set_workload_version("0.0.2")
+        if self._database_config:
+            self.unit.status = ActiveStatus()
+        else:
+            self.unit.status = WaitingStatus()
 
     def _on_clear_continuous_writes_action(self, _) -> None:
         """Handle the clear continuous writes action event."""
@@ -281,20 +300,32 @@ def _on_database_created(self, _) -> None:
         """Handle the database created event."""
         if not self._database_config:
             return
-
-        self._start_continuous_writes(1)
-        value = self._write_random_value()
         if self.unit.is_leader():
-            self.app_peer_data[RANDOM_VALUE_KEY] = value
-        self.unit.status = ActiveStatus()
+            self.app_peer_data["database-start"] = "true"
 
     def _on_endpoints_changed(self, _) -> None:
         """Handle the database endpoints changed event."""
         count = self._max_written_value()
         self._start_continuous_writes(count + 1)
 
+    def _on_peer_relation_changed(self, _) -> None:
+        """Handle common post database estabilshed tasks."""
+        if self.app_peer_data.get("database-start") == "true":
+            self._start_continuous_writes(1)
+
+            if self.unit.is_leader():
+                value = self._write_random_value()
+                self.app_peer_data[RANDOM_VALUE_KEY] = value
+                # flag should be picked up just once
+                self.app_peer_data["database-start"] = "done"
+
+            self.unit.status = ActiveStatus()
+
     def _on_relation_broken(self, _) -> None:
         """Handle the database relation broken event."""
+        self._stop_continuous_writes()
+        if self.unit.is_leader():
+            self.app_peer_data.pop("database-start", None)
         self.unit.status = WaitingStatus()
 
     def _get_inserted_data(self, event: ActionEvent) -> None:

src/continuous_writes.py

@@ -22,7 +22,12 @@ def continuous_writes(database_config: Dict, table_name: str, starting_number: i
     try:
         with MySQLConnector(database_config) as cursor:
             cursor.execute(
-                f"CREATE TABLE IF NOT EXISTS `{table_name}`(number INTEGER, PRIMARY KEY(number));"
+                (
+                    f"CREATE TABLE IF NOT EXISTS `{table_name}`("
+                    "id INTEGER NOT NULL AUTO_INCREMENT,"
+                    "number INTEGER, "
+                    "PRIMARY KEY(id));"
+                )
             )
     except Exception:
         pass

src/literals.py

@@ -0,0 +1,13 @@
+# Copyright 2023 Canonical Ltd.
+# See LICENSE file for licensing details.
+
+"""Test application literals."""
+
+CONTINUOUS_WRITE_TABLE_NAME = "data"
+DATABASE_NAME = "continuous_writes_database"
+DATABASE_RELATION = "database"
+LEGACY_MYSQL_RELATION = "mysql"  # MariaDB legacy relation
+PEER = "application-peers"
+PROC_PID_KEY = "proc-pid"
+RANDOM_VALUE_KEY = "inserted_value"
+RANDOM_VALUE_TABLE_NAME = "random_data"

src/relations/legacy_mysql.py

@@ -0,0 +1,87 @@
+# Copyright 2023 Canonical Ltd.
+# See LICENSE file for licensing details.
+
+"""Module for handling legacy MySQL/MariaDB relations."""
+
+import logging
+
+from literals import DATABASE_NAME, LEGACY_MYSQL_RELATION
+from ops.framework import Object
+from ops.model import BlockedStatus
+
+logger = logging.getLogger(__name__)
+
+
+class LegacyMySQL(Object):
+    """Class for handling legacy MySQL/MariaDB relations."""
+
+    def __init__(self, charm):
+        super().__init__(charm, LEGACY_MYSQL_RELATION)
+        self.charm = charm
+
+        self.framework.observe(
+            charm.on[LEGACY_MYSQL_RELATION].relation_joined, self._on_relation_joined
+        )
+        self.framework.observe(
+            charm.on[LEGACY_MYSQL_RELATION].relation_broken, self._on_relation_broken
+        )
+        self.framework.observe(
+            charm.on.get_legacy_mysql_credentials_action, self._get_legacy_mysql_credentials
+        )
+
+    def _on_relation_joined(self, event):
+        if not self.charm.unit.is_leader():
+            # only leader handles the relation data
+            return
+
+        # On legacy MariaDB, the relation data is stored on
+        # leader unit databag only.
+        try:
+            relation_data = event.relation.data[event.unit]
+        except KeyError:
+            logger.debug("Relation departed")
+            return
+
+        if "user" not in relation_data:
+            if f"{LEGACY_MYSQL_RELATION}-user" in self.charm.app_peer_data:
+                # If user set, relation joined already handled
+                return
+            logger.debug("Mysql legacy relation data not ready yet. Deferring event.")
+            event.defer()
+            return
+
+        database_name = relation_data["database"]
+        if database_name != DATABASE_NAME:
+            logger.error(f"Database name must be set to `{DATABASE_NAME}`. Modify the test.")
+            self.charm.unit.status = BlockedStatus("Wrong database name")
+            return
+
+        # Dump data into peer relation
+        self.charm.app_peer_data[f"{LEGACY_MYSQL_RELATION}-user"] = relation_data["user"]
+        self.charm.app_peer_data[f"{LEGACY_MYSQL_RELATION}-password"] = relation_data["password"]
+        self.charm.app_peer_data[f"{LEGACY_MYSQL_RELATION}-host"] = relation_data["host"]
+        self.charm.app_peer_data[f"{LEGACY_MYSQL_RELATION}-database"] = database_name
+
+        # Set database-start to true to trigger common post relation tasks
+        self.charm.app_peer_data["database-start"] = "true"
+
+    def _on_relation_broken(self, _):
+        if not self.charm.unit.is_leader():
+            # only leader handles the relation data
+            return
+        # Clear data from peer relation
+        self.charm.app_peer_data.pop(f"{LEGACY_MYSQL_RELATION}-user", None)
+        self.charm.app_peer_data.pop(f"{LEGACY_MYSQL_RELATION}-password", None)
+        self.charm.app_peer_data.pop(f"{LEGACY_MYSQL_RELATION}-host", None)
+        self.charm.app_peer_data.pop(f"{LEGACY_MYSQL_RELATION}-database", None)
+
+    def _get_legacy_mysql_credentials(self, event) -> None:
+        """Retrieve legacy mariadb credentials."""
+        event.set_results(
+            {
+                "username": self.charm.app_peer_data[f"{LEGACY_MYSQL_RELATION}-user"],
+                "password": self.charm.app_peer_data[f"{LEGACY_MYSQL_RELATION}-password"],
+                "host": self.charm.app_peer_data[f"{LEGACY_MYSQL_RELATION}-host"],
+                "database": self.charm.app_peer_data[f"{LEGACY_MYSQL_RELATION}-database"],
+            }
+        )