From 21fb3243651d644a4585253dd055e5b4e79626bd Mon Sep 17 00:00:00 2001
From: jamesbeedy <jamesbeedy@gmail.com>
Date: Thu, 27 Jun 2024 16:24:47 +0000
Subject: [PATCH] remove fluentbit and small fixes

These changes remove the fluentbit relation and associated code
and fix some leftover variable references.
---
 charmcraft.yaml                      |   2 -
 lib/charms/fluentbit/v0/fluentbit.py | 203 ---------------------------
 src/charm.py                         |  13 --
 src/constants.py                     |   9 +-
 src/slurmdbd_ops.py                  | 101 ++++---------
 5 files changed, 38 insertions(+), 290 deletions(-)
 delete mode 100644 lib/charms/fluentbit/v0/fluentbit.py

diff --git a/charmcraft.yaml b/charmcraft.yaml
index 47e7e9f..a9cd3a3 100644
--- a/charmcraft.yaml
+++ b/charmcraft.yaml
@@ -28,8 +28,6 @@ links:
 requires:
   database:
     interface: mysql_client
-  fluentbit:
-    interface: fluentbit
 
 provides:
   slurmctld:
diff --git a/lib/charms/fluentbit/v0/fluentbit.py b/lib/charms/fluentbit/v0/fluentbit.py
deleted file mode 100644
index aa68450..0000000
--- a/lib/charms/fluentbit/v0/fluentbit.py
+++ /dev/null
@@ -1,203 +0,0 @@
-r"""Fluentbit charm libraries.
-
-This library contains two main classes: `FluentbitProvider` and
-`FluentbitClient`. `FluentbitProvider` class is instantiated in the Fluentbit
-Server charm, and receives configuration data through a relation to other
-charms. `FluentbitClient` class should be instantiated in any charm that wants
-to ship logs via Fluentbit.
-
-## Forwarding logs using Fluentbit
-
-To forward logs from your charm to a centralized place using Fluentbit,
-instantiate the `FluentbitClient()` class and handle the `relation_created`
-event in your main charm code. In this event, your charm must pass all the
-configuration parameters necessary to configure Fluentbit: the inputs, the
-parsers, and the filters.
-
-For example:
-
-```python
-class MyCharm(CharmBase):
-    def __init__(self, *args):
-        super().__init__(*args)
-
-        self._fluentbit = FluentbitClient(self, "fluentbit")
-
-        self.framework.observe(self.on.fluentbit.relation_created,
-                               self._fluentbit_relation_created)
-
-    def _fluentbit_relation_created(self, event):
-        cfg = [{"input": [("name",     "tail"),
-                          ("path",     "/var/log/foo/bar.log"),
-                          ("path_key", "filename"),
-                          ("tag",      "foo"),
-                          ("parser",   "bar")]},
-               {"parser": [("name",        "bar"),
-                           ("format",      "regex"),
-                           ("regex",       "^\[(?<time>[^\]]*)\] (?<log>.*)$"),
-                           ("time_key",    "time"),
-                           ("time_format", "%Y-%m-%dT%H,%M,%S.%L")]}]
-        self._fluentbit.configure(cfg)
-```
-
-The configuration object must be a list of dictionaries. Each dictionary must
-contain one key. The key must be the section of Fluentbit's processing
-pipeline. Valid ones are:
-- `input`
-- `filter`
-- `parser`
-- `multiline_parser`
-- `output`
-
-The value of each key must be a list of all configuration entries. Each entry
-is a tuple (or list) of values to be rendered in the configuration files.
-
-Your charm's `metadata.yaml` should have the Fluentbit relation entry in the
-`requires` section:
-
-```
-requires:
-      fluentbit:
-          interface: fluentbit
-```
-
-
-## FluentbitProvider class
-
-This class receives the configuration data and forwards to the Fluentbit Charm,
-to rewrite the configuration files and restart the service. This class should
-only be instantiated by Fluentbit Charm.
-
-## Caveats
-
-The charm does not validate the configuration files before restarting the
-service. It is the charm author's responsibility to ensure the configuration is
-correct.
-"""
-
-import logging
-import json
-from typing import List
-
-from ops.framework import EventBase, EventSource, Object, ObjectEvents, StoredState
-from ops.model import Relation
-
-# The unique Charmhub library identifier, never change it
-LIBID = "e7b5ae1460034b9fb67cd4ec6aa3e87f"
-
-# Increment this major API version when introducing breaking changes
-LIBAPI = 0
-
-# Increment this PATCH version before using `charmcraft publish-lib` or reset
-# to 0 if you are raising the major API version
-LIBPATCH = 2
-
-logger = logging.getLogger(__name__)
-
-
-class FluentbitConfigurationAvailable(EventBase):
-    """Emitted when configuration is available."""
-
-
-class FluentbitEvents(ObjectEvents):
-    """Fluentbit emitted events."""
-
-    configuration_available = EventSource(FluentbitConfigurationAvailable)
-
-
-class FluentbitProvider(Object):
-    """Implement the provider side of the relation."""
-
-    _state = StoredState()
-    on = FluentbitEvents()
-
-    def __init__(self, charm, relation_name: str):
-        """Initialize the service provider.
-
-        Arguments:
-            charm: a `CharmBase` instance that manages this instance of the
-                   Fluentbit service.
-            relation_name: string name of the relation that provides the
-                           Fluentbit logging service.
-        """
-        super().__init__(charm, relation_name)
-
-        self.charm = charm
-        self._relation_name = relation_name
-
-        self._state.set_default(cfg=str())
-
-        events = self.charm.on[relation_name]
-        self.framework.observe(events.relation_changed, self._on_relation_changed)
-        # TODO relation_broken should reconfigure with empty/default values,
-        #      with care to not remove other entries from other relations
-
-    def _on_relation_changed(self, event):
-        """Get configuration from the client and trigger a reconfiguration."""
-        cfg = event.relation.data[event.unit].get("configuration")
-        logger.debug(f"## relation-changed: received: {cfg}")
-        # TODO this only works for 1 relation, should extend for any number of
-        #      relations, so it can support multiple outputs easily?
-        if cfg:
-            self._state.cfg = cfg
-            self.on.configuration_available.emit()
-
-    @property
-    def configuration(self) -> List[dict]:
-        """Get the stored configuration.
-
-        Returns:
-            list of dictionaries with the configuration parameters.
-        """
-        cfg = json.loads(self._state.cfg or '[]')
-        logger.debug(f"## Fluentbit stored configuration: {cfg}")
-        return cfg
-
-
-class FluentbitClient(Object):
-    """A client to relate to a Fluentbit Charm.
-
-    This class implements the `requires` end of the relation, to configure
-    Fluentbit.
-
-    The instantiating class must handle the `relation_created` event to
-    configure Fluentbit:
-    """
-    def __init__(self, charm, relation_name: str):
-        """Initialize Fluentbit client.
-
-        Arguments:
-            charm: a `CharmBase` object that manages this `FluentbitClient`
-                   object. Typically this is `self` in the instantiating class.
-            relation_name: string name of the relation between `charm` and the
-                           Fluentbit charmed service.
-        """
-        super().__init__(charm, relation_name)
-
-        self._charm = charm
-        self._relation_name = relation_name
-
-    def configure(self, cfg: List[dict]):
-        r"""Configure Fluentbit.
-
-        Arguments:
-            cfg: a list of stuff to setup. Example:
-                [{"input": [("name",     "tail"),
-                            ("path",     "/var/log/slurm/slurmd.log"),
-                            ("path_key", "filename"),
-                            ("tag",      "slurmd"),
-                            ("parser",   "slurm")]},
-                 {"parser": [("name",        "slurm"),
-                             ("format",      "regex"),
-                             ("regex",       "^\[(?<time>[^\]]*)\] (?<message>.*)$"),
-                             ("time_key",    "time"),
-                             ("time_format", "%Y-%m-%dT%H,%M,%S.%L")]},
-        """
-        # should we validate the input? how?
-        logging.debug(f"## Seding configuration data to Fluentbit: {cfg}")
-        self._relation.data[self.model.unit]["configuration"] = json.dumps(cfg)
-
-    @property
-    def _relation(self) -> Relation:
-        """Return the relation."""
-        return self.framework.model.get_relation(self._relation_name)
diff --git a/src/charm.py b/src/charm.py
index c86544e..6c7aba2 100755
--- a/src/charm.py
+++ b/src/charm.py
@@ -13,7 +13,6 @@
     DatabaseCreatedEvent,
     DatabaseRequires,
 )
-from charms.fluentbit.v0.fluentbit import FluentbitClient
 from constants import CHARM_MAINTAINED_PARAMETERS, SLURM_ACCT_DB
 from interface_slurmctld import Slurmctld, SlurmctldAvailableEvent, SlurmctldUnavailableEvent
 from ops import (
@@ -22,7 +21,6 @@
     CharmBase,
     ConfigChangedEvent,
     InstallEvent,
-    RelationCreatedEvent,
     StoredState,
     UpdateStatusEvent,
     WaitingStatus,
@@ -48,22 +46,16 @@ def __init__(self, *args, **kwargs) -> None:
         )
 
         self._db = DatabaseRequires(self, relation_name="database", database_name=SLURM_ACCT_DB)
-        self._fluentbit = FluentbitClient(self, "fluentbit")
         self._slurmdbd_ops_manager = SlurmdbdOpsManager()
         self._slurmctld = Slurmctld(self, "slurmctld")
 
         event_handler_bindings = {
-            # Charm core events
             self.on.install: self._on_install,
             self.on.update_status: self._on_update_status,
             self.on.config_changed: self._write_config_and_restart_slurmdbd,
-            # Database relation
             self._db.on.database_created: self._on_database_created,
-            # Slurmctld
             self._slurmctld.on.slurmctld_available: self._on_slurmctld_available,
             self._slurmctld.on.slurmctld_unavailable: self._on_slurmctld_unavailable,
-            # fluentbit
-            self.on["fluentbit"].relation_created: self._on_fluentbit_relation_created,
         }
         for event, handler in event_handler_bindings.items():
             self.framework.observe(event, handler)
@@ -92,11 +84,6 @@ def _on_install(self, event: InstallEvent) -> None:
             self.unit.status = ActiveStatus("slurmdbd successfully installed")
         self._check_status()
 
-    def _on_fluentbit_relation_created(self, event: RelationCreatedEvent) -> None:
-        """Set up Fluentbit log forwarding."""
-        logger.debug("## Configuring fluentbit")
-        self._fluentbit.configure(self._slurmdbd_ops_manager.fluentbit_config_slurm)
-
     def _on_update_status(self, event: UpdateStatusEvent) -> None:
         """Handle update status."""
         self._check_status()
diff --git a/src/constants.py b/src/constants.py
index 23a1afe..d159597 100644
--- a/src/constants.py
+++ b/src/constants.py
@@ -3,11 +3,16 @@
 """Constants."""
 from pathlib import Path
 
+SLURM_USER = "slurm"
+SLURM_GROUP = "slurm"
+
+STATE_DIR = Path("/var/spool/slurmdbd")
+
 CHARM_MAINTAINED_PARAMETERS = {
     "DbdPort": "6819",
     "AuthType": "auth/munge",
     "AuthInfo": '"socket=/var/run/munge/munge.socket.2"',
-    "SlurmUser": "slurm",
+    "SlurmUser": SLURM_USER,
     "PluginDir": "/usr/lib/x86_64-linux-gnu/slurm-wlm",
     "PidFile": "/var/run/slurmdbd.pid",
     "LogFile": "/var/log/slurm/slurmdbd.log",
@@ -18,7 +23,7 @@
 
 SLURMDBD_DEFAULTS_FILE = Path("/etc/default/slurmdbd")
 
-UBUNTU_HPC_PPA_KEY: str = """
+UBUNTU_HPC_PPA_KEY = """
 -----BEGIN PGP PUBLIC KEY BLOCK-----
 Comment: Hostname:
 Version: Hockeypuck 2.1.1-10-gec3b0e7
diff --git a/src/slurmdbd_ops.py b/src/slurmdbd_ops.py
index b7d07bf..cd46409 100644
--- a/src/slurmdbd_ops.py
+++ b/src/slurmdbd_ops.py
@@ -15,7 +15,13 @@
 import charms.operator_libs_linux.v0.apt as apt
 import charms.operator_libs_linux.v1.systemd as systemd
 import distro
-from constants import SLURMDBD_DEFAULTS_FILE, UBUNTU_HPC_PPA_KEY
+from constants import (
+    SLURM_GROUP,
+    SLURM_USER,
+    SLURMDBD_DEFAULTS_FILE,
+    STATE_DIR,
+    UBUNTU_HPC_PPA_KEY,
+)
 
 logger = logging.getLogger()
 
@@ -107,21 +113,32 @@ class SlurmdbdOpsManager:
     def __init__(self):
         """Set the initial attribute values."""
         self._slurm_component = "slurmdbd"
-
-        self._slurm_state_dir = Path("/var/spool/slurmdbd")
-        self._slurmdbd_conf_dir = Path("/etc/slurm")
-        self._slurmdbd_log_dir = Path("/var/log/slurm")
-        self._slurm_user = "slurm"
-        self._slurm_group = "slurm"
-
         self._munge_package = CharmedHPCPackageLifecycleManager("munge")
         self._slurmdbd_package = CharmedHPCPackageLifecycleManager("slurmdbd")
 
+    def install(self) -> bool:
+        """Install slurmdbd and munge to the system and setup paths."""
+        if self._slurmdbd_package.install() is not True:
+            return False
+        systemd.service_stop("slurmdbd")
+
+        if self._munge_package.install() is not True:
+            return False
+        systemd.service_stop("munge")
+
+        # Create the state directory as it is not created as part of the package installation.
+        STATE_DIR.mkdir()
+        slurm_user_uid = getpwnam(SLURM_USER).pw_uid
+        slurm_group_gid = getgrnam(SLURM_GROUP).gr_gid
+        os.chown(f"{STATE_DIR}", slurm_user_uid, slurm_group_gid)
+
+        return True
+
     def write_slurmdbd_conf(self, slurmdbd_parameters: dict) -> None:
         """Render slurmdbd.conf."""
-        slurmdbd_conf = self._slurmdbd_conf_dir / "slurmdbd.conf"
-        slurm_user_uid = getpwnam(self._slurm_user).pw_uid
-        slurm_group_gid = getgrnam(self._slurm_group).gr_gid
+        slurmdbd_conf = Path("/etc/slurm/slurmdbd.conf")
+        slurm_user_uid = getpwnam(SLURM_USER).pw_uid
+        slurm_group_gid = getgrnam(SLURM_GROUP).gr_gid
 
         header = textwrap.dedent(
             f"""
@@ -145,36 +162,15 @@ def write_munge_key(self, munge_key_data: str) -> None:
 
     def write_jwt_rsa(self, jwt_rsa: str) -> None:
         """Write the jwt_rsa key and set permissions."""
-        jwt_rsa_path = self._slurm_state_dir / "jwt_hs256.key"
-        slurm_user_uid = getpwnam(self._slurm_user).pw_uid
-        slurm_group_gid = getgrnam(self._slurm_group).gr_gid
+        jwt_rsa_path = STATE_DIR / "jwt_hs256.key"
+        slurm_user_uid = getpwnam(SLURM_USER).pw_uid
+        slurm_group_gid = getgrnam(SLURM_GROUP).gr_gid
 
-        # Write the jwt_rsa key to the file and chmod 0600 + chown to slurm_user.
         jwt_rsa_path.write_text(jwt_rsa)
         jwt_rsa_path.chmod(0o600)
 
         os.chown(f"{jwt_rsa_path}", slurm_user_uid, slurm_group_gid)
 
-    def install(self) -> bool:
-        """Install slurmdbd and munge to the system and setup paths."""
-        slurm_user_uid = getpwnam(self._slurm_user).pw_uid
-        slurm_group_gid = getgrnam(self._slurm_group).gr_gid
-
-        if self._slurmdbd_package.install() is not True:
-            return False
-        systemd.service_stop("slurmdbd")
-
-        if self._munge_package.install() is not True:
-            return False
-        systemd.service_stop("munge")
-
-        # Create needed paths with correct permissions.
-        for syspath in [self._slurmdbd_conf_dir, self._slurmdbd_log_dir, self._slurm_state_dir]:
-            if not syspath.exists():
-                syspath.mkdir()
-            os.chown(f"{syspath}", slurm_user_uid, slurm_group_gid)
-        return True
-
     def stop_slurmdbd(self) -> None:
         """Stop slurmdbd."""
         systemd.service_stop("slurmdbd")
@@ -245,41 +241,6 @@ def restart_slurmdbd(self) -> bool:
             return False
         return True
 
-    @property
-    def fluentbit_config_slurm(self) -> list:
-        """Return Fluentbit configuration parameters to forward Slurm logs."""
-        log_file = self._slurmdbd_log_dir / "slurmdbd.log"
-
-        cfg = [
-            {
-                "input": [
-                    ("name", "tail"),
-                    ("path", log_file.as_posix()),
-                    ("path_key", "filename"),
-                    ("tag", self._slurm_component),
-                    ("parser", "slurm"),
-                ]
-            },
-            {
-                "parser": [
-                    ("name", "slurm"),
-                    ("format", "regex"),
-                    ("regex", r"^\[(?<time>[^\]]*)\] (?<log>.*)$"),
-                    ("time_key", "time"),
-                    ("time_format", "%Y-%m-%dT%H:%M:%S.%L"),
-                ]
-            },
-            {
-                "filter": [
-                    ("name", "record_modifier"),
-                    ("match", self._slurm_component),
-                    ("record", "hostname ${HOSTNAME}"),
-                    ("record", f"service {self._slurm_component}"),
-                ]
-            },
-        ]
-        return cfg
-
     # Originally contributed by @wolsen
     # https://github.com/charmed-hpc/slurmdbd-operator/commit/2b47acda7f51aea8699886c49783eaf0de691747
     @classmethod