From 0367e5f87ed508260b70ea80cefa2f939cec022c Mon Sep 17 00:00:00 2001
From: jamesbeedy <jamesbeedy@gmail.com>
Date: Wed, 24 Apr 2024 04:11:53 +0000
Subject: [PATCH 1/2] James Longdev

Changes include:
* remove jinja2 and replace with `Path().write_text()`
* remove `slurm-ops-manager` 3rd party dep and replace with local `slurmrestd_ops.py`
* consolidate the yaml files into a single `charmcraft.yaml`
* rename interface slurmrestd -> slurmctld
* cleanup from PR review
* remove unused code
* addeded logging
* simplified api
* reduced code footprint
* consolidated yaml files into charmcraft.yaml
* added type checking
---
 .github/workflows/ci.yaml                    |   20 +-
 README.md                                    |    6 +-
 charmcraft.yaml                              |   45 +-
 config.yaml                                  |   15 -
 lib/charms/fluentbit/v0/fluentbit.py         |  203 ---
 lib/charms/operator_libs_linux/v0/apt.py     | 1361 ++++++++++++++++++
 lib/charms/operator_libs_linux/v1/systemd.py |  288 ++++
 metadata.yaml                                |   24 -
 pyproject.toml                               |   10 +-
 requirements.txt                             |    2 +-
 src/charm.py                                 |  176 +--
 src/constants.py                             |   69 +
 src/interface_slurmctld.py                   |   96 ++
 src/interface_slurmrestd.py                  |  202 ---
 src/slurmrestd_ops.py                        |  249 ++++
 tests/integration/helpers.py                 |   34 -
 tests/integration/test_charm.py              |   12 +-
 tests/unit/test_charm.py                     |  139 +-
 tox.ini                                      |   26 +-
 19 files changed, 2188 insertions(+), 789 deletions(-)
 delete mode 100644 config.yaml
 delete mode 100644 lib/charms/fluentbit/v0/fluentbit.py
 create mode 100644 lib/charms/operator_libs_linux/v0/apt.py
 create mode 100644 lib/charms/operator_libs_linux/v1/systemd.py
 delete mode 100644 metadata.yaml
 create mode 100644 src/constants.py
 create mode 100644 src/interface_slurmctld.py
 delete mode 100644 src/interface_slurmrestd.py
 create mode 100644 src/slurmrestd_ops.py
 delete mode 100644 tests/integration/helpers.py

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index b1c606d..9e2c006 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -23,7 +23,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: woke
         uses: get-woke/woke-action@v0
         with:
@@ -35,18 +35,29 @@ jobs:
     runs-on: ubuntu-22.04
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: Install dependencies
         run: python3 -m pip install tox
       - name: Run linters
         run: tox -e lint
 
+  type:
+    name: Type checking
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Install dependencies
+        run: python3 -m pip install tox
+      - name: Run tests
+        run: tox -e type
+
   unit-test:
     name: Unit tests
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: Install dependencies
         run: python3 -m pip install tox
       - name: Run tests
@@ -63,10 +74,11 @@ jobs:
     needs:
       - inclusive-naming-check
       - lint
+      - type
       - unit-test
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: Setup operator environment
         uses: charmed-kubernetes/actions-operator@main
         with:
diff --git a/README.md b/README.md
index 2561d9b..e1fc47a 100644
--- a/README.md
+++ b/README.md
@@ -30,11 +30,11 @@ $ juju deploy slurmd --channel edge
 $ juju deploy slurmdbd --channel edge
 $ juju deploy mysql --channel 8.0/edge
 $ juju deploy mysql-router slurmdbd-mysql-router --channel dpe/edge
-$ juju integrate slurmctld:slurmrestd slurmrestd:slurmrestd
-$ juju integrate slurmctld:slurmd slurmd:slurmd
+$ juju integrate slurmctld:slurmd slurmd:slurmctld
+$ juju integrate slurmctld:slurmdbd slurmdbd:slurmctld
+$ juju integrate slurmctld:slurmrestd slurmrestd:slurmctld
 $ juju integrate slurmdbd-mysql-router:backend-database mysql:database
 $ juju integrate slurmdbd:database slurmdbd-mysql-router:database
-$ juju integrate slurmctld:slurmdbd slurmdbd:slurmdbd
 ```
 
 ## Project & Community
diff --git a/charmcraft.yaml b/charmcraft.yaml
index 6a6f7d1..ab31126 100644
--- a/charmcraft.yaml
+++ b/charmcraft.yaml
@@ -1,6 +1,30 @@
-# Copyright 2020 Omnivector Solutions, LLC.
+# Copyright 2020-2024 Omnivector, LLC.
 # See LICENSE file for licensing details.
 
+name: slurmrestd
+summary: |
+  Interface to Slurm via REST API.
+description: |
+  This charm provides slurmrestd, munged, and the bindings to other utilities
+  that make lifecycle operations a breeze.
+
+  slurmrestd is a REST API interface for SLURM.
+
+links:
+  contact: https://matrix.to/#/#hpc:ubuntu.com
+  source:
+    - https://github.com/omnivector-solutions/slurmrestd-operator
+  issues:
+    - https://github.com/omnivector-solutions/slurmrestd-operator/issues
+
+provides:
+  slurmctld:
+    interface: slurmrestd
+    limit: 1
+
+assumes:
+  - juju
+
 type: charm
 bases:
   - build-on:
@@ -10,22 +34,3 @@ bases:
       - name: ubuntu
         channel: "22.04"
         architectures: [amd64]
-
-parts:
-  charm:
-    build-packages: [git]
-    charm-python-packages: [setuptools]
-
-  # Create a version file and pack it into the charm. This is dynamically generated
-  # as part of the build process for a charm to ensure that the git revision of the
-  # charm is always recorded in this version file.
-  version-file:
-    plugin: nil
-    build-packages:
-      - git
-    override-build: |
-      VERSION=$(git -C $CRAFT_PART_SRC/../../charm/src describe --dirty --always)
-      echo "Setting version to $VERSION"
-      echo $VERSION > $CRAFT_PART_INSTALL/version
-    stage:
-      - version
diff --git a/config.yaml b/config.yaml
deleted file mode 100644
index 633a2d3..0000000
--- a/config.yaml
+++ /dev/null
@@ -1,15 +0,0 @@
-options:
-  custom-slurm-repo:
-    type: string
-    default: ""
-    description: >
-      Use a custom repository for Slurm installation.
-
-      This can be set to the Organization's local mirror/cache of packages and
-      supersedes the Omnivector repositories. Alternatively, it can be used to
-      track a `testing` Slurm version, e.g. by setting to
-      `ppa:omnivector/osd-testing`.
-
-      Note: The configuration `custom-slurm-repo` must be set *before*
-      deploying the units. Changing this value after deploying the units will
-      not reinstall Slurm.
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/lib/charms/operator_libs_linux/v0/apt.py b/lib/charms/operator_libs_linux/v0/apt.py
new file mode 100644
index 0000000..1400df7
--- /dev/null
+++ b/lib/charms/operator_libs_linux/v0/apt.py
@@ -0,0 +1,1361 @@
+# Copyright 2021 Canonical Ltd.
+#
+# 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.
+
+"""Abstractions for the system's Debian/Ubuntu package information and repositories.
+
+This module contains abstractions and wrappers around Debian/Ubuntu-style repositories and
+packages, in order to easily provide an idiomatic and Pythonic mechanism for adding packages and/or
+repositories to systems for use in machine charms.
+
+A sane default configuration is attainable through nothing more than instantiation of the
+appropriate classes. `DebianPackage` objects provide information about the architecture, version,
+name, and status of a package.
+
+`DebianPackage` will try to look up a package either from `dpkg -L` or from `apt-cache` when
+provided with a string indicating the package name. If it cannot be located, `PackageNotFoundError`
+will be returned, as `apt` and `dpkg` otherwise return `100` for all errors, and a meaningful error
+message if the package is not known is desirable.
+
+To install packages with convenience methods:
+
+```python
+try:
+    # Run `apt-get update`
+    apt.update()
+    apt.add_package("zsh")
+    apt.add_package(["vim", "htop", "wget"])
+except PackageNotFoundError:
+    logger.error("a specified package not found in package cache or on system")
+except PackageError as e:
+    logger.error("could not install package. Reason: %s", e.message)
+````
+
+To find details of a specific package:
+
+```python
+try:
+    vim = apt.DebianPackage.from_system("vim")
+
+    # To find from the apt cache only
+    # apt.DebianPackage.from_apt_cache("vim")
+
+    # To find from installed packages only
+    # apt.DebianPackage.from_installed_package("vim")
+
+    vim.ensure(PackageState.Latest)
+    logger.info("updated vim to version: %s", vim.fullversion)
+except PackageNotFoundError:
+    logger.error("a specified package not found in package cache or on system")
+except PackageError as e:
+    logger.error("could not install package. Reason: %s", e.message)
+```
+
+
+`RepositoryMapping` will return a dict-like object containing enabled system repositories
+and their properties (available groups, baseuri. gpg key). This class can add, disable, or
+manipulate repositories. Items can be retrieved as `DebianRepository` objects.
+
+In order add a new repository with explicit details for fields, a new `DebianRepository` can
+be added to `RepositoryMapping`
+
+`RepositoryMapping` provides an abstraction around the existing repositories on the system,
+and can be accessed and iterated over like any `Mapping` object, to retrieve values by key,
+iterate, or perform other operations.
+
+Keys are constructed as `{repo_type}-{}-{release}` in order to uniquely identify a repository.
+
+Repositories can be added with explicit values through a Python constructor.
+
+Example:
+```python
+repositories = apt.RepositoryMapping()
+
+if "deb-example.com-focal" not in repositories:
+    repositories.add(DebianRepository(enabled=True, repotype="deb",
+                     uri="https://example.com", release="focal", groups=["universe"]))
+```
+
+Alternatively, any valid `sources.list` line may be used to construct a new
+`DebianRepository`.
+
+Example:
+```python
+repositories = apt.RepositoryMapping()
+
+if "deb-us.archive.ubuntu.com-xenial" not in repositories:
+    line = "deb http://us.archive.ubuntu.com/ubuntu xenial main restricted"
+    repo = DebianRepository.from_repo_line(line)
+    repositories.add(repo)
+```
+"""
+
+import fileinput
+import glob
+import logging
+import os
+import re
+import subprocess
+from collections.abc import Mapping
+from enum import Enum
+from subprocess import PIPE, CalledProcessError, check_output
+from typing import Iterable, List, Optional, Tuple, Union
+from urllib.parse import urlparse
+
+logger = logging.getLogger(__name__)
+
+# The unique Charmhub library identifier, never change it
+LIBID = "7c3dbc9c2ad44a47bd6fcb25caa270e5"
+
+# 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 = 13
+
+
+VALID_SOURCE_TYPES = ("deb", "deb-src")
+OPTIONS_MATCHER = re.compile(r"\[.*?\]")
+
+
+class Error(Exception):
+    """Base class of most errors raised by this library."""
+
+    def __repr__(self):
+        """Represent the Error."""
+        return "<{}.{} {}>".format(type(self).__module__, type(self).__name__, self.args)
+
+    @property
+    def name(self):
+        """Return a string representation of the model plus class."""
+        return "<{}.{}>".format(type(self).__module__, type(self).__name__)
+
+    @property
+    def message(self):
+        """Return the message passed as an argument."""
+        return self.args[0]
+
+
+class PackageError(Error):
+    """Raised when there's an error installing or removing a package."""
+
+
+class PackageNotFoundError(Error):
+    """Raised when a requested package is not known to the system."""
+
+
+class PackageState(Enum):
+    """A class to represent possible package states."""
+
+    Present = "present"
+    Absent = "absent"
+    Latest = "latest"
+    Available = "available"
+
+
+class DebianPackage:
+    """Represents a traditional Debian package and its utility functions.
+
+    `DebianPackage` wraps information and functionality around a known package, whether installed
+    or available. The version, epoch, name, and architecture can be easily queried and compared
+    against other `DebianPackage` objects to determine the latest version or to install a specific
+    version.
+
+    The representation of this object as a string mimics the output from `dpkg` for familiarity.
+
+    Installation and removal of packages is handled through the `state` property or `ensure`
+    method, with the following options:
+
+        apt.PackageState.Absent
+        apt.PackageState.Available
+        apt.PackageState.Present
+        apt.PackageState.Latest
+
+    When `DebianPackage` is initialized, the state of a given `DebianPackage` object will be set to
+    `Available`, `Present`, or `Latest`, with `Absent` implemented as a convenience for removal
+    (though it operates essentially the same as `Available`).
+    """
+
+    def __init__(
+        self, name: str, version: str, epoch: str, arch: str, state: PackageState
+    ) -> None:
+        self._name = name
+        self._arch = arch
+        self._state = state
+        self._version = Version(version, epoch)
+
+    def __eq__(self, other) -> bool:
+        """Equality for comparison.
+
+        Args:
+          other: a `DebianPackage` object for comparison
+
+        Returns:
+          A boolean reflecting equality
+        """
+        return isinstance(other, self.__class__) and (
+            self._name,
+            self._version.number,
+        ) == (other._name, other._version.number)
+
+    def __hash__(self):
+        """Return a hash of this package."""
+        return hash((self._name, self._version.number))
+
+    def __repr__(self):
+        """Represent the package."""
+        return "<{}.{}: {}>".format(self.__module__, self.__class__.__name__, self.__dict__)
+
+    def __str__(self):
+        """Return a human-readable representation of the package."""
+        return "<{}: {}-{}.{} -- {}>".format(
+            self.__class__.__name__,
+            self._name,
+            self._version,
+            self._arch,
+            str(self._state),
+        )
+
+    @staticmethod
+    def _apt(
+        command: str,
+        package_names: Union[str, List],
+        optargs: Optional[List[str]] = None,
+    ) -> None:
+        """Wrap package management commands for Debian/Ubuntu systems.
+
+        Args:
+          command: the command given to `apt-get`
+          package_names: a package name or list of package names to operate on
+          optargs: an (Optional) list of additioanl arguments
+
+        Raises:
+          PackageError if an error is encountered
+        """
+        optargs = optargs if optargs is not None else []
+        if isinstance(package_names, str):
+            package_names = [package_names]
+        _cmd = ["apt-get", "-y", *optargs, command, *package_names]
+        try:
+            env = os.environ.copy()
+            env["DEBIAN_FRONTEND"] = "noninteractive"
+            subprocess.run(_cmd, capture_output=True, check=True, text=True, env=env)
+        except CalledProcessError as e:
+            raise PackageError(
+                "Could not {} package(s) [{}]: {}".format(command, [*package_names], e.stderr)
+            ) from None
+
+    def _add(self) -> None:
+        """Add a package to the system."""
+        self._apt(
+            "install",
+            "{}={}".format(self.name, self.version),
+            optargs=["--option=Dpkg::Options::=--force-confold"],
+        )
+
+    def _remove(self) -> None:
+        """Remove a package from the system. Implementation-specific."""
+        return self._apt("remove", "{}={}".format(self.name, self.version))
+
+    @property
+    def name(self) -> str:
+        """Returns the name of the package."""
+        return self._name
+
+    def ensure(self, state: PackageState):
+        """Ensure that a package is in a given state.
+
+        Args:
+          state: a `PackageState` to reconcile the package to
+
+        Raises:
+          PackageError from the underlying call to apt
+        """
+        if self._state is not state:
+            if state not in (PackageState.Present, PackageState.Latest):
+                self._remove()
+            else:
+                self._add()
+        self._state = state
+
+    @property
+    def present(self) -> bool:
+        """Returns whether or not a package is present."""
+        return self._state in (PackageState.Present, PackageState.Latest)
+
+    @property
+    def latest(self) -> bool:
+        """Returns whether the package is the most recent version."""
+        return self._state is PackageState.Latest
+
+    @property
+    def state(self) -> PackageState:
+        """Returns the current package state."""
+        return self._state
+
+    @state.setter
+    def state(self, state: PackageState) -> None:
+        """Set the package state to a given value.
+
+        Args:
+          state: a `PackageState` to reconcile the package to
+
+        Raises:
+          PackageError from the underlying call to apt
+        """
+        if state in (PackageState.Latest, PackageState.Present):
+            self._add()
+        else:
+            self._remove()
+        self._state = state
+
+    @property
+    def version(self) -> "Version":
+        """Returns the version for a package."""
+        return self._version
+
+    @property
+    def epoch(self) -> str:
+        """Returns the epoch for a package. May be unset."""
+        return self._version.epoch
+
+    @property
+    def arch(self) -> str:
+        """Returns the architecture for a package."""
+        return self._arch
+
+    @property
+    def fullversion(self) -> str:
+        """Returns the name+epoch for a package."""
+        return "{}.{}".format(self._version, self._arch)
+
+    @staticmethod
+    def _get_epoch_from_version(version: str) -> Tuple[str, str]:
+        """Pull the epoch, if any, out of a version string."""
+        epoch_matcher = re.compile(r"^((?P<epoch>\d+):)?(?P<version>.*)")
+        matches = epoch_matcher.search(version).groupdict()
+        return matches.get("epoch", ""), matches.get("version")
+
+    @classmethod
+    def from_system(
+        cls, package: str, version: Optional[str] = "", arch: Optional[str] = ""
+    ) -> "DebianPackage":
+        """Locates a package, either on the system or known to apt, and serializes the information.
+
+        Args:
+            package: a string representing the package
+            version: an optional string if a specific version is requested
+            arch: an optional architecture, defaulting to `dpkg --print-architecture`. If an
+                architecture is not specified, this will be used for selection.
+
+        """
+        try:
+            return DebianPackage.from_installed_package(package, version, arch)
+        except PackageNotFoundError:
+            logger.debug(
+                "package '%s' is not currently installed or has the wrong architecture.", package
+            )
+
+        # Ok, try `apt-cache ...`
+        try:
+            return DebianPackage.from_apt_cache(package, version, arch)
+        except (PackageNotFoundError, PackageError):
+            # If we get here, it's not known to the systems.
+            # This seems unnecessary, but virtually all `apt` commands have a return code of `100`,
+            # and providing meaningful error messages without this is ugly.
+            raise PackageNotFoundError(
+                "Package '{}{}' could not be found on the system or in the apt cache!".format(
+                    package, ".{}".format(arch) if arch else ""
+                )
+            ) from None
+
+    @classmethod
+    def from_installed_package(
+        cls, package: str, version: Optional[str] = "", arch: Optional[str] = ""
+    ) -> "DebianPackage":
+        """Check whether the package is already installed and return an instance.
+
+        Args:
+            package: a string representing the package
+            version: an optional string if a specific version is requested
+            arch: an optional architecture, defaulting to `dpkg --print-architecture`.
+                If an architecture is not specified, this will be used for selection.
+        """
+        system_arch = check_output(
+            ["dpkg", "--print-architecture"], universal_newlines=True
+        ).strip()
+        arch = arch if arch else system_arch
+
+        # Regexps are a really terrible way to do this. Thanks dpkg
+        output = ""
+        try:
+            output = check_output(["dpkg", "-l", package], stderr=PIPE, universal_newlines=True)
+        except CalledProcessError:
+            raise PackageNotFoundError("Package is not installed: {}".format(package)) from None
+
+        # Pop off the output from `dpkg -l' because there's no flag to
+        # omit it`
+        lines = str(output).splitlines()[5:]
+
+        dpkg_matcher = re.compile(
+            r"""
+        ^(?P<package_status>\w+?)\s+
+        (?P<package_name>.*?)(?P<throwaway_arch>:\w+?)?\s+
+        (?P<version>.*?)\s+
+        (?P<arch>\w+?)\s+
+        (?P<description>.*)
+        """,
+            re.VERBOSE,
+        )
+
+        for line in lines:
+            try:
+                matches = dpkg_matcher.search(line).groupdict()
+                package_status = matches["package_status"]
+
+                if not package_status.endswith("i"):
+                    logger.debug(
+                        "package '%s' in dpkg output but not installed, status: '%s'",
+                        package,
+                        package_status,
+                    )
+                    break
+
+                epoch, split_version = DebianPackage._get_epoch_from_version(matches["version"])
+                pkg = DebianPackage(
+                    matches["package_name"],
+                    split_version,
+                    epoch,
+                    matches["arch"],
+                    PackageState.Present,
+                )
+                if (pkg.arch == "all" or pkg.arch == arch) and (
+                    version == "" or str(pkg.version) == version
+                ):
+                    return pkg
+            except AttributeError:
+                logger.warning("dpkg matcher could not parse line: %s", line)
+
+        # If we didn't find it, fail through
+        raise PackageNotFoundError("Package {}.{} is not installed!".format(package, arch))
+
+    @classmethod
+    def from_apt_cache(
+        cls, package: str, version: Optional[str] = "", arch: Optional[str] = ""
+    ) -> "DebianPackage":
+        """Check whether the package is already installed and return an instance.
+
+        Args:
+            package: a string representing the package
+            version: an optional string if a specific version is requested
+            arch: an optional architecture, defaulting to `dpkg --print-architecture`.
+                If an architecture is not specified, this will be used for selection.
+        """
+        system_arch = check_output(
+            ["dpkg", "--print-architecture"], universal_newlines=True
+        ).strip()
+        arch = arch if arch else system_arch
+
+        # Regexps are a really terrible way to do this. Thanks dpkg
+        keys = ("Package", "Architecture", "Version")
+
+        try:
+            output = check_output(
+                ["apt-cache", "show", package], stderr=PIPE, universal_newlines=True
+            )
+        except CalledProcessError as e:
+            raise PackageError(
+                "Could not list packages in apt-cache: {}".format(e.stderr)
+            ) from None
+
+        pkg_groups = output.strip().split("\n\n")
+        keys = ("Package", "Architecture", "Version")
+
+        for pkg_raw in pkg_groups:
+            lines = str(pkg_raw).splitlines()
+            vals = {}
+            for line in lines:
+                if line.startswith(keys):
+                    items = line.split(":", 1)
+                    vals[items[0]] = items[1].strip()
+                else:
+                    continue
+
+            epoch, split_version = DebianPackage._get_epoch_from_version(vals["Version"])
+            pkg = DebianPackage(
+                vals["Package"],
+                split_version,
+                epoch,
+                vals["Architecture"],
+                PackageState.Available,
+            )
+
+            if (pkg.arch == "all" or pkg.arch == arch) and (
+                version == "" or str(pkg.version) == version
+            ):
+                return pkg
+
+        # If we didn't find it, fail through
+        raise PackageNotFoundError("Package {}.{} is not in the apt cache!".format(package, arch))
+
+
+class Version:
+    """An abstraction around package versions.
+
+    This seems like it should be strictly unnecessary, except that `apt_pkg` is not usable inside a
+    venv, and wedging version comparisons into `DebianPackage` would overcomplicate it.
+
+    This class implements the algorithm found here:
+    https://www.debian.org/doc/debian-policy/ch-controlfields.html#version
+    """
+
+    def __init__(self, version: str, epoch: str):
+        self._version = version
+        self._epoch = epoch or ""
+
+    def __repr__(self):
+        """Represent the package."""
+        return "<{}.{}: {}>".format(self.__module__, self.__class__.__name__, self.__dict__)
+
+    def __str__(self):
+        """Return human-readable representation of the package."""
+        return "{}{}".format("{}:".format(self._epoch) if self._epoch else "", self._version)
+
+    @property
+    def epoch(self):
+        """Returns the epoch for a package. May be empty."""
+        return self._epoch
+
+    @property
+    def number(self) -> str:
+        """Returns the version number for a package."""
+        return self._version
+
+    def _get_parts(self, version: str) -> Tuple[str, str]:
+        """Separate the version into component upstream and Debian pieces."""
+        try:
+            version.rindex("-")
+        except ValueError:
+            # No hyphens means no Debian version
+            return version, "0"
+
+        upstream, debian = version.rsplit("-", 1)
+        return upstream, debian
+
+    def _listify(self, revision: str) -> List[str]:
+        """Split a revision string into a listself.
+
+        This list is comprised of  alternating between strings and numbers,
+        padded on either end to always be "str, int, str, int..." and
+        always be of even length.  This allows us to trivially implement the
+        comparison algorithm described.
+        """
+        result = []
+        while revision:
+            rev_1, remains = self._get_alphas(revision)
+            rev_2, remains = self._get_digits(remains)
+            result.extend([rev_1, rev_2])
+            revision = remains
+        return result
+
+    def _get_alphas(self, revision: str) -> Tuple[str, str]:
+        """Return a tuple of the first non-digit characters of a revision."""
+        # get the index of the first digit
+        for i, char in enumerate(revision):
+            if char.isdigit():
+                if i == 0:
+                    return "", revision
+                return revision[0:i], revision[i:]
+        # string is entirely alphas
+        return revision, ""
+
+    def _get_digits(self, revision: str) -> Tuple[int, str]:
+        """Return a tuple of the first integer characters of a revision."""
+        # If the string is empty, return (0,'')
+        if not revision:
+            return 0, ""
+        # get the index of the first non-digit
+        for i, char in enumerate(revision):
+            if not char.isdigit():
+                if i == 0:
+                    return 0, revision
+                return int(revision[0:i]), revision[i:]
+        # string is entirely digits
+        return int(revision), ""
+
+    def _dstringcmp(self, a, b):  # noqa: C901
+        """Debian package version string section lexical sort algorithm.
+
+        The lexical comparison is a comparison of ASCII values modified so
+        that all the letters sort earlier than all the non-letters and so that
+        a tilde sorts before anything, even the end of a part.
+        """
+        if a == b:
+            return 0
+        try:
+            for i, char in enumerate(a):
+                if char == b[i]:
+                    continue
+                # "a tilde sorts before anything, even the end of a part"
+                # (emptyness)
+                if char == "~":
+                    return -1
+                if b[i] == "~":
+                    return 1
+                # "all the letters sort earlier than all the non-letters"
+                if char.isalpha() and not b[i].isalpha():
+                    return -1
+                if not char.isalpha() and b[i].isalpha():
+                    return 1
+                # otherwise lexical sort
+                if ord(char) > ord(b[i]):
+                    return 1
+                if ord(char) < ord(b[i]):
+                    return -1
+        except IndexError:
+            # a is longer than b but otherwise equal, greater unless there are tildes
+            if char == "~":
+                return -1
+            return 1
+        # if we get here, a is shorter than b but otherwise equal, so check for tildes...
+        if b[len(a)] == "~":
+            return 1
+        return -1
+
+    def _compare_revision_strings(self, first: str, second: str):  # noqa: C901
+        """Compare two debian revision strings."""
+        if first == second:
+            return 0
+
+        # listify pads results so that we will always be comparing ints to ints
+        # and strings to strings (at least until we fall off the end of a list)
+        first_list = self._listify(first)
+        second_list = self._listify(second)
+        if first_list == second_list:
+            return 0
+        try:
+            for i, item in enumerate(first_list):
+                # explicitly raise IndexError if we've fallen off the edge of list2
+                if i >= len(second_list):
+                    raise IndexError
+                # if the items are equal, next
+                if item == second_list[i]:
+                    continue
+                # numeric comparison
+                if isinstance(item, int):
+                    if item > second_list[i]:
+                        return 1
+                    if item < second_list[i]:
+                        return -1
+                else:
+                    # string comparison
+                    return self._dstringcmp(item, second_list[i])
+        except IndexError:
+            # rev1 is longer than rev2 but otherwise equal, hence greater
+            # ...except for goddamn tildes
+            if first_list[len(second_list)][0][0] == "~":
+                return 1
+            return 1
+        # rev1 is shorter than rev2 but otherwise equal, hence lesser
+        # ...except for goddamn tildes
+        if second_list[len(first_list)][0][0] == "~":
+            return -1
+        return -1
+
+    def _compare_version(self, other) -> int:
+        if (self.number, self.epoch) == (other.number, other.epoch):
+            return 0
+
+        if self.epoch < other.epoch:
+            return -1
+        if self.epoch > other.epoch:
+            return 1
+
+        # If none of these are true, follow the algorithm
+        upstream_version, debian_version = self._get_parts(self.number)
+        other_upstream_version, other_debian_version = self._get_parts(other.number)
+
+        upstream_cmp = self._compare_revision_strings(upstream_version, other_upstream_version)
+        if upstream_cmp != 0:
+            return upstream_cmp
+
+        debian_cmp = self._compare_revision_strings(debian_version, other_debian_version)
+        if debian_cmp != 0:
+            return debian_cmp
+
+        return 0
+
+    def __lt__(self, other) -> bool:
+        """Less than magic method impl."""
+        return self._compare_version(other) < 0
+
+    def __eq__(self, other) -> bool:
+        """Equality magic method impl."""
+        return self._compare_version(other) == 0
+
+    def __gt__(self, other) -> bool:
+        """Greater than magic method impl."""
+        return self._compare_version(other) > 0
+
+    def __le__(self, other) -> bool:
+        """Less than or equal to magic method impl."""
+        return self.__eq__(other) or self.__lt__(other)
+
+    def __ge__(self, other) -> bool:
+        """Greater than or equal to magic method impl."""
+        return self.__gt__(other) or self.__eq__(other)
+
+    def __ne__(self, other) -> bool:
+        """Not equal to magic method impl."""
+        return not self.__eq__(other)
+
+
+def add_package(
+    package_names: Union[str, List[str]],
+    version: Optional[str] = "",
+    arch: Optional[str] = "",
+    update_cache: Optional[bool] = False,
+) -> Union[DebianPackage, List[DebianPackage]]:
+    """Add a package or list of packages to the system.
+
+    Args:
+        package_names: single package name, or list of package names
+        name: the name(s) of the package(s)
+        version: an (Optional) version as a string. Defaults to the latest known
+        arch: an optional architecture for the package
+        update_cache: whether or not to run `apt-get update` prior to operating
+
+    Raises:
+        TypeError if no package name is given, or explicit version is set for multiple packages
+        PackageNotFoundError if the package is not in the cache.
+        PackageError if packages fail to install
+    """
+    cache_refreshed = False
+    if update_cache:
+        update()
+        cache_refreshed = True
+
+    packages = {"success": [], "retry": [], "failed": []}
+
+    package_names = [package_names] if isinstance(package_names, str) else package_names
+    if not package_names:
+        raise TypeError("Expected at least one package name to add, received zero!")
+
+    if len(package_names) != 1 and version:
+        raise TypeError(
+            "Explicit version should not be set if more than one package is being added!"
+        )
+
+    for p in package_names:
+        pkg, success = _add(p, version, arch)
+        if success:
+            packages["success"].append(pkg)
+        else:
+            logger.warning("failed to locate and install/update '%s'", pkg)
+            packages["retry"].append(p)
+
+    if packages["retry"] and not cache_refreshed:
+        logger.info("updating the apt-cache and retrying installation of failed packages.")
+        update()
+
+        for p in packages["retry"]:
+            pkg, success = _add(p, version, arch)
+            if success:
+                packages["success"].append(pkg)
+            else:
+                packages["failed"].append(p)
+
+    if packages["failed"]:
+        raise PackageError("Failed to install packages: {}".format(", ".join(packages["failed"])))
+
+    return packages["success"] if len(packages["success"]) > 1 else packages["success"][0]
+
+
+def _add(
+    name: str,
+    version: Optional[str] = "",
+    arch: Optional[str] = "",
+) -> Tuple[Union[DebianPackage, str], bool]:
+    """Add a package to the system.
+
+    Args:
+        name: the name(s) of the package(s)
+        version: an (Optional) version as a string. Defaults to the latest known
+        arch: an optional architecture for the package
+
+    Returns: a tuple of `DebianPackage` if found, or a :str: if it is not, and
+        a boolean indicating success
+    """
+    try:
+        pkg = DebianPackage.from_system(name, version, arch)
+        pkg.ensure(state=PackageState.Present)
+        return pkg, True
+    except PackageNotFoundError:
+        return name, False
+
+
+def remove_package(
+    package_names: Union[str, List[str]]
+) -> Union[DebianPackage, List[DebianPackage]]:
+    """Remove package(s) from the system.
+
+    Args:
+        package_names: the name of a package
+
+    Raises:
+        PackageNotFoundError if the package is not found.
+    """
+    packages = []
+
+    package_names = [package_names] if isinstance(package_names, str) else package_names
+    if not package_names:
+        raise TypeError("Expected at least one package name to add, received zero!")
+
+    for p in package_names:
+        try:
+            pkg = DebianPackage.from_installed_package(p)
+            pkg.ensure(state=PackageState.Absent)
+            packages.append(pkg)
+        except PackageNotFoundError:
+            logger.info("package '%s' was requested for removal, but it was not installed.", p)
+
+    # the list of packages will be empty when no package is removed
+    logger.debug("packages: '%s'", packages)
+    return packages[0] if len(packages) == 1 else packages
+
+
+def update() -> None:
+    """Update the apt cache via `apt-get update`."""
+    subprocess.run(["apt-get", "update"], capture_output=True, check=True)
+
+
+def import_key(key: str) -> str:
+    """Import an ASCII Armor key.
+
+    A Radix64 format keyid is also supported for backwards
+    compatibility. In this case Ubuntu keyserver will be
+    queried for a key via HTTPS by its keyid. This method
+    is less preferable because https proxy servers may
+    require traffic decryption which is equivalent to a
+    man-in-the-middle attack (a proxy server impersonates
+    keyserver TLS certificates and has to be explicitly
+    trusted by the system).
+
+    Args:
+        key: A GPG key in ASCII armor format, including BEGIN
+            and END markers or a keyid.
+
+    Returns:
+        The GPG key filename written.
+
+    Raises:
+        GPGKeyError if the key could not be imported
+    """
+    key = key.strip()
+    if "-" in key or "\n" in key:
+        # Send everything not obviously a keyid to GPG to import, as
+        # we trust its validation better than our own. eg. handling
+        # comments before the key.
+        logger.debug("PGP key found (looks like ASCII Armor format)")
+        if (
+            "-----BEGIN PGP PUBLIC KEY BLOCK-----" in key
+            and "-----END PGP PUBLIC KEY BLOCK-----" in key
+        ):
+            logger.debug("Writing provided PGP key in the binary format")
+            key_bytes = key.encode("utf-8")
+            key_name = DebianRepository._get_keyid_by_gpg_key(key_bytes)
+            key_gpg = DebianRepository._dearmor_gpg_key(key_bytes)
+            gpg_key_filename = "/etc/apt/trusted.gpg.d/{}.gpg".format(key_name)
+            DebianRepository._write_apt_gpg_keyfile(
+                key_name=gpg_key_filename, key_material=key_gpg
+            )
+            return gpg_key_filename
+        else:
+            raise GPGKeyError("ASCII armor markers missing from GPG key")
+    else:
+        logger.warning(
+            "PGP key found (looks like Radix64 format). "
+            "SECURELY importing PGP key from keyserver; "
+            "full key not provided."
+        )
+        # as of bionic add-apt-repository uses curl with an HTTPS keyserver URL
+        # to retrieve GPG keys. `apt-key adv` command is deprecated as is
+        # apt-key in general as noted in its manpage. See lp:1433761 for more
+        # history. Instead, /etc/apt/trusted.gpg.d is used directly to drop
+        # gpg
+        key_asc = DebianRepository._get_key_by_keyid(key)
+        # write the key in GPG format so that apt-key list shows it
+        key_gpg = DebianRepository._dearmor_gpg_key(key_asc.encode("utf-8"))
+        gpg_key_filename = "/etc/apt/trusted.gpg.d/{}.gpg".format(key)
+        DebianRepository._write_apt_gpg_keyfile(key_name=gpg_key_filename, key_material=key_gpg)
+        return gpg_key_filename
+
+
+class InvalidSourceError(Error):
+    """Exceptions for invalid source entries."""
+
+
+class GPGKeyError(Error):
+    """Exceptions for GPG keys."""
+
+
+class DebianRepository:
+    """An abstraction to represent a repository."""
+
+    def __init__(
+        self,
+        enabled: bool,
+        repotype: str,
+        uri: str,
+        release: str,
+        groups: List[str],
+        filename: Optional[str] = "",
+        gpg_key_filename: Optional[str] = "",
+        options: Optional[dict] = None,
+    ):
+        self._enabled = enabled
+        self._repotype = repotype
+        self._uri = uri
+        self._release = release
+        self._groups = groups
+        self._filename = filename
+        self._gpg_key_filename = gpg_key_filename
+        self._options = options
+
+    @property
+    def enabled(self):
+        """Return whether or not the repository is enabled."""
+        return self._enabled
+
+    @property
+    def repotype(self):
+        """Return whether it is binary or source."""
+        return self._repotype
+
+    @property
+    def uri(self):
+        """Return the URI."""
+        return self._uri
+
+    @property
+    def release(self):
+        """Return which Debian/Ubuntu releases it is valid for."""
+        return self._release
+
+    @property
+    def groups(self):
+        """Return the enabled package groups."""
+        return self._groups
+
+    @property
+    def filename(self):
+        """Returns the filename for a repository."""
+        return self._filename
+
+    @filename.setter
+    def filename(self, fname: str) -> None:
+        """Set the filename used when a repo is written back to disk.
+
+        Args:
+            fname: a filename to write the repository information to.
+        """
+        if not fname.endswith(".list"):
+            raise InvalidSourceError("apt source filenames should end in .list!")
+
+        self._filename = fname
+
+    @property
+    def gpg_key(self):
+        """Returns the path to the GPG key for this repository."""
+        return self._gpg_key_filename
+
+    @property
+    def options(self):
+        """Returns any additional repo options which are set."""
+        return self._options
+
+    def make_options_string(self) -> str:
+        """Generate the complete options string for a a repository.
+
+        Combining `gpg_key`, if set, and the rest of the options to find
+        a complex repo string.
+        """
+        options = self._options if self._options else {}
+        if self._gpg_key_filename:
+            options["signed-by"] = self._gpg_key_filename
+
+        return (
+            "[{}] ".format(" ".join(["{}={}".format(k, v) for k, v in options.items()]))
+            if options
+            else ""
+        )
+
+    @staticmethod
+    def prefix_from_uri(uri: str) -> str:
+        """Get a repo list prefix from the uri, depending on whether a path is set."""
+        uridetails = urlparse(uri)
+        path = (
+            uridetails.path.lstrip("/").replace("/", "-") if uridetails.path else uridetails.netloc
+        )
+        return "/etc/apt/sources.list.d/{}".format(path)
+
+    @staticmethod
+    def from_repo_line(repo_line: str, write_file: Optional[bool] = True) -> "DebianRepository":
+        """Instantiate a new `DebianRepository` a `sources.list` entry line.
+
+        Args:
+            repo_line: a string representing a repository entry
+            write_file: boolean to enable writing the new repo to disk
+        """
+        repo = RepositoryMapping._parse(repo_line, "UserInput")
+        fname = "{}-{}.list".format(
+            DebianRepository.prefix_from_uri(repo.uri), repo.release.replace("/", "-")
+        )
+        repo.filename = fname
+
+        options = repo.options if repo.options else {}
+        if repo.gpg_key:
+            options["signed-by"] = repo.gpg_key
+
+        # For Python 3.5 it's required to use sorted in the options dict in order to not have
+        # different results in the order of the options between executions.
+        options_str = (
+            "[{}] ".format(" ".join(["{}={}".format(k, v) for k, v in sorted(options.items())]))
+            if options
+            else ""
+        )
+
+        if write_file:
+            with open(fname, "wb") as f:
+                f.write(
+                    (
+                        "{}".format("#" if not repo.enabled else "")
+                        + "{} {}{} ".format(repo.repotype, options_str, repo.uri)
+                        + "{} {}\n".format(repo.release, " ".join(repo.groups))
+                    ).encode("utf-8")
+                )
+
+        return repo
+
+    def disable(self) -> None:
+        """Remove this repository from consideration.
+
+        Disable it instead of removing from the repository file.
+        """
+        searcher = "{} {}{} {}".format(
+            self.repotype, self.make_options_string(), self.uri, self.release
+        )
+        for line in fileinput.input(self._filename, inplace=True):
+            if re.match(r"^{}\s".format(re.escape(searcher)), line):
+                print("# {}".format(line), end="")
+            else:
+                print(line, end="")
+
+    def import_key(self, key: str) -> None:
+        """Import an ASCII Armor key.
+
+        A Radix64 format keyid is also supported for backwards
+        compatibility. In this case Ubuntu keyserver will be
+        queried for a key via HTTPS by its keyid. This method
+        is less preferable because https proxy servers may
+        require traffic decryption which is equivalent to a
+        man-in-the-middle attack (a proxy server impersonates
+        keyserver TLS certificates and has to be explicitly
+        trusted by the system).
+
+        Args:
+          key: A GPG key in ASCII armor format,
+                      including BEGIN and END markers or a keyid.
+
+        Raises:
+          GPGKeyError if the key could not be imported
+        """
+        self._gpg_key_filename = import_key(key)
+
+    @staticmethod
+    def _get_keyid_by_gpg_key(key_material: bytes) -> str:
+        """Get a GPG key fingerprint by GPG key material.
+
+        Gets a GPG key fingerprint (40-digit, 160-bit) by the ASCII armor-encoded
+        or binary GPG key material. Can be used, for example, to generate file
+        names for keys passed via charm options.
+        """
+        # Use the same gpg command for both Xenial and Bionic
+        cmd = ["gpg", "--with-colons", "--with-fingerprint"]
+        ps = subprocess.run(
+            cmd,
+            stdout=PIPE,
+            stderr=PIPE,
+            input=key_material,
+        )
+        out, err = ps.stdout.decode(), ps.stderr.decode()
+        if "gpg: no valid OpenPGP data found." in err:
+            raise GPGKeyError("Invalid GPG key material provided")
+        # from gnupg2 docs: fpr :: Fingerprint (fingerprint is in field 10)
+        return re.search(r"^fpr:{9}([0-9A-F]{40}):$", out, re.MULTILINE).group(1)
+
+    @staticmethod
+    def _get_key_by_keyid(keyid: str) -> str:
+        """Get a key via HTTPS from the Ubuntu keyserver.
+
+        Different key ID formats are supported by SKS keyservers (the longer ones
+        are more secure, see "dead beef attack" and https://evil32.com/). Since
+        HTTPS is used, if SSLBump-like HTTPS proxies are in place, they will
+        impersonate keyserver.ubuntu.com and generate a certificate with
+        keyserver.ubuntu.com in the CN field or in SubjAltName fields of a
+        certificate. If such proxy behavior is expected it is necessary to add the
+        CA certificate chain containing the intermediate CA of the SSLBump proxy to
+        every machine that this code runs on via ca-certs cloud-init directive (via
+        cloudinit-userdata model-config) or via other means (such as through a
+        custom charm option). Also note that DNS resolution for the hostname in a
+        URL is done at a proxy server - not at the client side.
+        8-digit (32 bit) key ID
+        https://keyserver.ubuntu.com/pks/lookup?search=0x4652B4E6
+        16-digit (64 bit) key ID
+        https://keyserver.ubuntu.com/pks/lookup?search=0x6E85A86E4652B4E6
+        40-digit key ID:
+        https://keyserver.ubuntu.com/pks/lookup?search=0x35F77D63B5CEC106C577ED856E85A86E4652B4E6
+
+        Args:
+          keyid: An 8, 16 or 40 hex digit keyid to find a key for
+
+        Returns:
+          A string contining key material for the specified GPG key id
+
+
+        Raises:
+          subprocess.CalledProcessError
+        """
+        # options=mr - machine-readable output (disables html wrappers)
+        keyserver_url = (
+            "https://keyserver.ubuntu.com" "/pks/lookup?op=get&options=mr&exact=on&search=0x{}"
+        )
+        curl_cmd = ["curl", keyserver_url.format(keyid)]
+        # use proxy server settings in order to retrieve the key
+        return check_output(curl_cmd).decode()
+
+    @staticmethod
+    def _dearmor_gpg_key(key_asc: bytes) -> bytes:
+        """Convert a GPG key in the ASCII armor format to the binary format.
+
+        Args:
+          key_asc: A GPG key in ASCII armor format.
+
+        Returns:
+          A GPG key in binary format as a string
+
+        Raises:
+          GPGKeyError
+        """
+        ps = subprocess.run(["gpg", "--dearmor"], stdout=PIPE, stderr=PIPE, input=key_asc)
+        out, err = ps.stdout, ps.stderr.decode()
+        if "gpg: no valid OpenPGP data found." in err:
+            raise GPGKeyError(
+                "Invalid GPG key material. Check your network setup"
+                " (MTU, routing, DNS) and/or proxy server settings"
+                " as well as destination keyserver status."
+            )
+        else:
+            return out
+
+    @staticmethod
+    def _write_apt_gpg_keyfile(key_name: str, key_material: bytes) -> None:
+        """Write GPG key material into a file at a provided path.
+
+        Args:
+          key_name: A key name to use for a key file (could be a fingerprint)
+          key_material: A GPG key material (binary)
+        """
+        with open(key_name, "wb") as keyf:
+            keyf.write(key_material)
+
+
+class RepositoryMapping(Mapping):
+    """An representation of known repositories.
+
+    Instantiation of `RepositoryMapping` will iterate through the
+    filesystem, parse out repository files in `/etc/apt/...`, and create
+    `DebianRepository` objects in this list.
+
+    Typical usage:
+
+        repositories = apt.RepositoryMapping()
+        repositories.add(DebianRepository(
+            enabled=True, repotype="deb", uri="https://example.com", release="focal",
+            groups=["universe"]
+        ))
+    """
+
+    def __init__(self):
+        self._repository_map = {}
+        # Repositories that we're adding -- used to implement mode param
+        self.default_file = "/etc/apt/sources.list"
+
+        # read sources.list if it exists
+        if os.path.isfile(self.default_file):
+            self.load(self.default_file)
+
+        # read sources.list.d
+        for file in glob.iglob("/etc/apt/sources.list.d/*.list"):
+            self.load(file)
+
+    def __contains__(self, key: str) -> bool:
+        """Magic method for checking presence of repo in mapping."""
+        return key in self._repository_map
+
+    def __len__(self) -> int:
+        """Return number of repositories in map."""
+        return len(self._repository_map)
+
+    def __iter__(self) -> Iterable[DebianRepository]:
+        """Return iterator for RepositoryMapping."""
+        return iter(self._repository_map.values())
+
+    def __getitem__(self, repository_uri: str) -> DebianRepository:
+        """Return a given `DebianRepository`."""
+        return self._repository_map[repository_uri]
+
+    def __setitem__(self, repository_uri: str, repository: DebianRepository) -> None:
+        """Add a `DebianRepository` to the cache."""
+        self._repository_map[repository_uri] = repository
+
+    def load(self, filename: str):
+        """Load a repository source file into the cache.
+
+        Args:
+          filename: the path to the repository file
+        """
+        parsed = []
+        skipped = []
+        with open(filename, "r") as f:
+            for n, line in enumerate(f):
+                try:
+                    repo = self._parse(line, filename)
+                except InvalidSourceError:
+                    skipped.append(n)
+                else:
+                    repo_identifier = "{}-{}-{}".format(repo.repotype, repo.uri, repo.release)
+                    self._repository_map[repo_identifier] = repo
+                    parsed.append(n)
+                    logger.debug("parsed repo: '%s'", repo_identifier)
+
+        if skipped:
+            skip_list = ", ".join(str(s) for s in skipped)
+            logger.debug("skipped the following lines in file '%s': %s", filename, skip_list)
+
+        if parsed:
+            logger.info("parsed %d apt package repositories", len(parsed))
+        else:
+            raise InvalidSourceError("all repository lines in '{}' were invalid!".format(filename))
+
+    @staticmethod
+    def _parse(line: str, filename: str) -> DebianRepository:
+        """Parse a line in a sources.list file.
+
+        Args:
+          line: a single line from `load` to parse
+          filename: the filename being read
+
+        Raises:
+          InvalidSourceError if the source type is unknown
+        """
+        enabled = True
+        repotype = uri = release = gpg_key = ""
+        options = {}
+        groups = []
+
+        line = line.strip()
+        if line.startswith("#"):
+            enabled = False
+            line = line[1:]
+
+        # Check for "#" in the line and treat a part after it as a comment then strip it off.
+        i = line.find("#")
+        if i > 0:
+            line = line[:i]
+
+        # Split a source into substrings to initialize a new repo.
+        source = line.strip()
+        if source:
+            # Match any repo options, and get a dict representation.
+            for v in re.findall(OPTIONS_MATCHER, source):
+                opts = dict(o.split("=") for o in v.strip("[]").split())
+                # Extract the 'signed-by' option for the gpg_key
+                gpg_key = opts.pop("signed-by", "")
+                options = opts
+
+            # Remove any options from the source string and split the string into chunks
+            source = re.sub(OPTIONS_MATCHER, "", source)
+            chunks = source.split()
+
+            # Check we've got a valid list of chunks
+            if len(chunks) < 3 or chunks[0] not in VALID_SOURCE_TYPES:
+                raise InvalidSourceError("An invalid sources line was found in %s!", filename)
+
+            repotype = chunks[0]
+            uri = chunks[1]
+            release = chunks[2]
+            groups = chunks[3:]
+
+            return DebianRepository(
+                enabled, repotype, uri, release, groups, filename, gpg_key, options
+            )
+        else:
+            raise InvalidSourceError("An invalid sources line was found in %s!", filename)
+
+    def add(self, repo: DebianRepository, default_filename: Optional[bool] = False) -> None:
+        """Add a new repository to the system.
+
+        Args:
+          repo: a `DebianRepository` object
+          default_filename: an (Optional) filename if the default is not desirable
+        """
+        new_filename = "{}-{}.list".format(
+            DebianRepository.prefix_from_uri(repo.uri), repo.release.replace("/", "-")
+        )
+
+        fname = repo.filename or new_filename
+
+        options = repo.options if repo.options else {}
+        if repo.gpg_key:
+            options["signed-by"] = repo.gpg_key
+
+        with open(fname, "wb") as f:
+            f.write(
+                (
+                    "{}".format("#" if not repo.enabled else "")
+                    + "{} {}{} ".format(repo.repotype, repo.make_options_string(), repo.uri)
+                    + "{} {}\n".format(repo.release, " ".join(repo.groups))
+                ).encode("utf-8")
+            )
+
+        self._repository_map["{}-{}-{}".format(repo.repotype, repo.uri, repo.release)] = repo
+
+    def disable(self, repo: DebianRepository) -> None:
+        """Remove a repository. Disable by default.
+
+        Args:
+          repo: a `DebianRepository` to disable
+        """
+        searcher = "{} {}{} {}".format(
+            repo.repotype, repo.make_options_string(), repo.uri, repo.release
+        )
+
+        for line in fileinput.input(repo.filename, inplace=True):
+            if re.match(r"^{}\s".format(re.escape(searcher)), line):
+                print("# {}".format(line), end="")
+            else:
+                print(line, end="")
+
+        self._repository_map["{}-{}-{}".format(repo.repotype, repo.uri, repo.release)] = repo
diff --git a/lib/charms/operator_libs_linux/v1/systemd.py b/lib/charms/operator_libs_linux/v1/systemd.py
new file mode 100644
index 0000000..cdcbad6
--- /dev/null
+++ b/lib/charms/operator_libs_linux/v1/systemd.py
@@ -0,0 +1,288 @@
+# Copyright 2021 Canonical Ltd.
+#
+# 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.
+
+
+"""Abstractions for stopping, starting and managing system services via systemd.
+
+This library assumes that your charm is running on a platform that uses systemd. E.g.,
+Centos 7 or later, Ubuntu Xenial (16.04) or later.
+
+For the most part, we transparently provide an interface to a commonly used selection of
+systemd commands, with a few shortcuts baked in. For example, service_pause and
+service_resume with run the mask/unmask and enable/disable invocations.
+
+Example usage:
+
+```python
+from charms.operator_libs_linux.v0.systemd import service_running, service_reload
+
+# Start a service
+if not service_running("mysql"):
+    success = service_start("mysql")
+
+# Attempt to reload a service, restarting if necessary
+success = service_reload("nginx", restart_on_failure=True)
+```
+"""
+
+__all__ = [  # Don't export `_systemctl`. (It's not the intended way of using this lib.)
+    "SystemdError",
+    "daemon_reload",
+    "service_disable",
+    "service_enable",
+    "service_failed",
+    "service_pause",
+    "service_reload",
+    "service_restart",
+    "service_resume",
+    "service_running",
+    "service_start",
+    "service_stop",
+]
+
+import logging
+import subprocess
+
+logger = logging.getLogger(__name__)
+
+# The unique Charmhub library identifier, never change it
+LIBID = "045b0d179f6b4514a8bb9b48aee9ebaf"
+
+# Increment this major API version when introducing breaking changes
+LIBAPI = 1
+
+# Increment this PATCH version before using `charmcraft publish-lib` or reset
+# to 0 if you are raising the major API version
+LIBPATCH = 4
+
+
+class SystemdError(Exception):
+    """Custom exception for SystemD related errors."""
+
+
+def _systemctl(*args: str, check: bool = False) -> int:
+    """Control a system service using systemctl.
+
+    Args:
+        *args: Arguments to pass to systemctl.
+        check: Check the output of the systemctl command. Default: False.
+
+    Returns:
+        Returncode of systemctl command execution.
+
+    Raises:
+        SystemdError: Raised if calling systemctl returns a non-zero returncode and check is True.
+    """
+    cmd = ["systemctl", *args]
+    logger.debug(f"Executing command: {cmd}")
+    try:
+        proc = subprocess.run(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+            encoding="utf-8",
+            check=check,
+        )
+        logger.debug(
+            f"Command {cmd} exit code: {proc.returncode}. systemctl output:\n{proc.stdout}"
+        )
+        return proc.returncode
+    except subprocess.CalledProcessError as e:
+        raise SystemdError(
+            f"Command {cmd} failed with returncode {e.returncode}. systemctl output:\n{e.stdout}"
+        )
+
+
+def service_running(service_name: str) -> bool:
+    """Report whether a system service is running.
+
+    Args:
+        service_name: The name of the service to check.
+
+    Return:
+        True if service is running/active; False if not.
+    """
+    # If returncode is 0, this means that is service is active.
+    return _systemctl("--quiet", "is-active", service_name) == 0
+
+
+def service_failed(service_name: str) -> bool:
+    """Report whether a system service has failed.
+
+    Args:
+        service_name: The name of the service to check.
+
+    Returns:
+        True if service is marked as failed; False if not.
+    """
+    # If returncode is 0, this means that the service has failed.
+    return _systemctl("--quiet", "is-failed", service_name) == 0
+
+
+def service_start(*args: str) -> bool:
+    """Start a system service.
+
+    Args:
+        *args: Arguments to pass to `systemctl start` (normally the service name).
+
+    Returns:
+        On success, this function returns True for historical reasons.
+
+    Raises:
+        SystemdError: Raised if `systemctl start ...` returns a non-zero returncode.
+    """
+    return _systemctl("start", *args, check=True) == 0
+
+
+def service_stop(*args: str) -> bool:
+    """Stop a system service.
+
+    Args:
+        *args: Arguments to pass to `systemctl stop` (normally the service name).
+
+    Returns:
+        On success, this function returns True for historical reasons.
+
+    Raises:
+        SystemdError: Raised if `systemctl stop ...` returns a non-zero returncode.
+    """
+    return _systemctl("stop", *args, check=True) == 0
+
+
+def service_restart(*args: str) -> bool:
+    """Restart a system service.
+
+    Args:
+        *args: Arguments to pass to `systemctl restart` (normally the service name).
+
+    Returns:
+        On success, this function returns True for historical reasons.
+
+    Raises:
+        SystemdError: Raised if `systemctl restart ...` returns a non-zero returncode.
+    """
+    return _systemctl("restart", *args, check=True) == 0
+
+
+def service_enable(*args: str) -> bool:
+    """Enable a system service.
+
+    Args:
+        *args: Arguments to pass to `systemctl enable` (normally the service name).
+
+    Returns:
+        On success, this function returns True for historical reasons.
+
+    Raises:
+        SystemdError: Raised if `systemctl enable ...` returns a non-zero returncode.
+    """
+    return _systemctl("enable", *args, check=True) == 0
+
+
+def service_disable(*args: str) -> bool:
+    """Disable a system service.
+
+    Args:
+        *args: Arguments to pass to `systemctl disable` (normally the service name).
+
+    Returns:
+        On success, this function returns True for historical reasons.
+
+    Raises:
+        SystemdError: Raised if `systemctl disable ...` returns a non-zero returncode.
+    """
+    return _systemctl("disable", *args, check=True) == 0
+
+
+def service_reload(service_name: str, restart_on_failure: bool = False) -> bool:
+    """Reload a system service, optionally falling back to restart if reload fails.
+
+    Args:
+        service_name: The name of the service to reload.
+        restart_on_failure:
+            Boolean indicating whether to fall back to a restart if the reload fails.
+
+    Returns:
+        On success, this function returns True for historical reasons.
+
+    Raises:
+        SystemdError: Raised if `systemctl reload|restart ...` returns a non-zero returncode.
+    """
+    try:
+        return _systemctl("reload", service_name, check=True) == 0
+    except SystemdError:
+        if restart_on_failure:
+            return service_restart(service_name)
+        else:
+            raise
+
+
+def service_pause(service_name: str) -> bool:
+    """Pause a system service.
+
+    Stops the service and prevents the service from starting again at boot.
+
+    Args:
+        service_name: The name of the service to pause.
+
+    Returns:
+        On success, this function returns True for historical reasons.
+
+    Raises:
+        SystemdError: Raised if service is still running after being paused by systemctl.
+    """
+    _systemctl("disable", "--now", service_name)
+    _systemctl("mask", service_name)
+
+    if service_running(service_name):
+        raise SystemdError(f"Attempted to pause {service_name!r}, but it is still running.")
+
+    return True
+
+
+def service_resume(service_name: str) -> bool:
+    """Resume a system service.
+
+    Re-enable starting the service again at boot. Start the service.
+
+    Args:
+        service_name: The name of the service to resume.
+
+    Returns:
+        On success, this function returns True for historical reasons.
+
+    Raises:
+        SystemdError: Raised if service is not running after being resumed by systemctl.
+    """
+    _systemctl("unmask", service_name)
+    _systemctl("enable", "--now", service_name)
+
+    if not service_running(service_name):
+        raise SystemdError(f"Attempted to resume {service_name!r}, but it is not running.")
+
+    return True
+
+
+def daemon_reload() -> bool:
+    """Reload systemd manager configuration.
+
+    Returns:
+        On success, this function returns True for historical reasons.
+
+    Raises:
+        SystemdError: Raised if `systemctl daemon-reload` returns a non-zero returncode.
+    """
+    return _systemctl("daemon-reload", check=True) == 0
diff --git a/metadata.yaml b/metadata.yaml
deleted file mode 100644
index 379e75b..0000000
--- a/metadata.yaml
+++ /dev/null
@@ -1,24 +0,0 @@
-name: slurmrestd
-summary: |
-  Interface to Slurm via REST API.
-description: |
-  This charm provides slurmrestd, munged, and the bindings to other utilities
-  that make lifecycle operations a breeze.
-
-  slurmrestd is a REST API interface for SLURM.
-source: https://github.com/omnivector-solutions/slurmrestd-operator
-issues: https://github.com/omnivector-solutions/slurmrestd-operator/issues
-maintainers:
-    - OmniVector Solutions <admin@omnivector.solutions>
-    - Jason C. Nucciarone <jason.nucciarone@canonical.com>
-    - David Gomez <david.gomez@canonical.com>
-
-requires:
-  fluentbit:
-    interface: fluentbit
-provides:
-  slurmrestd:
-    interface: slurmrestd
-
-assumes:
-  - juju
diff --git a/pyproject.toml b/pyproject.toml
index ec80137..859ad12 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -35,8 +35,8 @@ target-version = ["py38"]
 # Linting tools configuration
 [tool.ruff]
 line-length = 99
-select = ["E", "W", "F", "C", "N", "D", "I001"]
-extend-ignore = [
+lint.select = ["E", "W", "F", "C", "N", "D", "I001"]
+lint.extend-ignore = [
     "D203",
     "D204",
     "D213",
@@ -49,9 +49,9 @@ extend-ignore = [
     "D409",
     "D413",
 ]
-ignore = ["E501", "D107"]
+lint.ignore = ["E501", "D107"]
 extend-exclude = ["__pycache__", "*.egg_info"]
-per-file-ignores = {"tests/*" = ["D100","D101","D102","D103","D104"]}
+lint.per-file-ignores = {"tests/*" = ["D100","D101","D102","D103","D104"]}
 
-[tool.ruff.mccabe]
+[tool.ruff.lint.mccabe]
 max-complexity = 10
diff --git a/requirements.txt b/requirements.txt
index dfa795a..d001003 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,2 +1,2 @@
 ops==2.*
-git+https://github.com/omnivector-solutions/slurm-ops-manager.git@0.8.16
\ No newline at end of file
+distro==1.9.0
diff --git a/src/charm.py b/src/charm.py
index c9eac4d..f112575 100755
--- a/src/charm.py
+++ b/src/charm.py
@@ -1,19 +1,23 @@
 #!/usr/bin/env python3
-# Copyright 2020 Omnivector Solutions, LLC.
+# Copyright 2020-2024 Omnivector, LLC.
 # See LICENSE file for licensing details.
 
 """SlurmrestdCharm."""
 
 import logging
-from pathlib import Path
 
-from charms.fluentbit.v0.fluentbit import FluentbitClient
-from interface_slurmrestd import SlurmrestdRequires
-from ops.charm import CharmBase
-from ops.framework import StoredState
-from ops.main import main
-from ops.model import ActiveStatus, BlockedStatus, WaitingStatus
-from slurm_ops_manager import SlurmManager
+from interface_slurmctld import Slurmctld, SlurmctldAvailableEvent, SlurmctldUnavailableEvent
+from ops import (
+    ActiveStatus,
+    BlockedStatus,
+    CharmBase,
+    InstallEvent,
+    StoredState,
+    UpdateStatusEvent,
+    WaitingStatus,
+    main,
+)
+from slurmrestd_ops import SlurmrestdManager
 
 logger = logging.getLogger()
 
@@ -27,164 +31,70 @@ def __init__(self, *args):
         """Initialize charm and configure states and events to observe."""
         super().__init__(*args)
 
-        self._stored.set_default(
-            slurm_installed=False, slurmrestd_restarted=False, cluster_name=str()
-        )
+        self._stored.set_default(slurm_installed=False)
 
-        self._slurm_manager = SlurmManager(self, "slurmrestd")
-        self._slurmrestd = SlurmrestdRequires(self, "slurmrestd")
-        self._fluentbit = FluentbitClient(self, "fluentbit")
+        self._slurmctld = Slurmctld(self, "slurmctld")
+        self._slurmrestd_manager = SlurmrestdManager()
 
         event_handler_bindings = {
             self.on.install: self._on_install,
-            self.on.upgrade_charm: self._on_upgrade,
             self.on.update_status: self._on_update_status,
-            self._slurmrestd.on.config_available: self._on_check_status_and_write_config,
-            self._slurmrestd.on.config_unavailable: self._on_config_unavailable,
-            self._slurmrestd.on.munge_key_available: self._on_configure_munge_key,
-            self._slurmrestd.on.jwt_rsa_available: self._on_configure_jwt_rsa,
-            self._slurmrestd.on.restart_slurmrestd: self._on_restart_slurmrestd,
-            # fluentbit
-            self.on["fluentbit"].relation_created: self._on_fluentbit_relation_created,
+            self._slurmctld.on.slurmctld_available: self._on_slurmctld_available,
+            self._slurmctld.on.slurmctld_unavailable: self._on_slurmctld_unavailable,
         }
         for event, handler in event_handler_bindings.items():
             self.framework.observe(event, handler)
 
-    def _on_install(self, event):
+    def _on_install(self, event: InstallEvent) -> None:
         """Perform installation operations for slurmrestd."""
-        self.unit.set_workload_version(Path("version").read_text().strip())
-
         self.unit.status = WaitingStatus("Installing slurmrestd")
 
-        custom_repo = self.config.get("custom-slurm-repo")
-        successful_installation = self._slurm_manager.install(custom_repo)
-
-        if successful_installation:
-            self.unit.status = ActiveStatus("slurmrestd installed")
+        if self._slurmrestd_manager.install():
+            self.unit.set_workload_version(self._slurmrestd_manager.version())
             self._stored.slurm_installed = True
-
-            self._slurm_manager.start_munged()
         else:
-            self.unit.status = BlockedStatus("Error installing slurmrestd")
             event.defer()
 
         self._check_status()
 
-    def _on_fluentbit_relation_created(self, event):
-        """Set up Fluentbit log forwarding."""
-        self._configure_fluentbit()
-
-    def _configure_fluentbit(self):
-        logger.debug("## Configuring fluentbit")
-        cfg = []
-        cfg.extend(self._slurm_manager.fluentbit_config_nhc)
-        cfg.extend(self._slurm_manager.fluentbit_config_slurm)
-        self._fluentbit.configure(cfg)
-
-    def _on_upgrade(self, event):
-        """Perform upgrade operations."""
-        self.unit.set_workload_version(Path("version").read_text().strip())
-        self._check_status()
-
-    def _on_update_status(self, event):
+    def _on_update_status(self, event: UpdateStatusEvent) -> None:
         """Handle update status."""
         self._check_status()
 
-    def _on_config_unavailable(self, event):
-        """Handle the config unavailable due to relation broken."""
-        # when the config becomes unavailable, we have to set this flag to False,
-        # so the next time the config becomes available, the daemon restarts
-        self._stored.slurmrestd_restarted = False
-        self._check_status()
-
-    def _on_restart_slurmrestd(self, event):
-        """Restart the slurmrestd component."""
-        logger.debug("## _on_restart_slurmrestd")
-
-        if not self._check_status():
-            event.defer()
-            return
-
-        self._slurm_manager.restart_slurm_component()
-        self._stored.slurmrestd_restarted = True
-
-    def _on_configure_munge_key(self, event):
-        """Configure the munge key.
-
-        1) Get the munge key from the stored state of the slurmrestd relation
-        2) Write the munge key to the munge key path and chmod
-        3) Restart munged
-        """
-        if not self._stored.slurm_installed:
+    def _on_slurmctld_available(self, event: SlurmctldAvailableEvent) -> None:
+        """Render config and restart the service when we have what we want from slurmctld."""
+        if self._stored.slurm_installed is not True:
             event.defer()
             return
 
-        logger.debug("## configuring new munge key")
-        munge_key = self._slurmrestd.get_stored_munge_key()
-        self._slurm_manager.configure_munge_key(munge_key)
-        self._slurm_manager.restart_munged()
-
-    def _on_configure_jwt_rsa(self, event):
-        if not self._stored.slurm_installed:
-            event.defer()
-            return
+        if (event.munge_key is not None) and (event.slurm_conf is not None):
+            self._slurmrestd_manager.stop_slurmrestd()
+            self._slurmrestd_manager.stop_munge()
+            self._slurmrestd_manager.write_munge_key(event.munge_key)
+            self._slurmrestd_manager.write_slurm_conf(event.slurm_conf)
+            self._slurmrestd_manager.start_munge()
+            self._slurmrestd_manager.start_slurmrestd()
+        self._check_status()
 
-        logger.debug("## configuring new jwt rsa")
-        jwt_rsa = self._slurmrestd.get_stored_jwt_rsa()
-        self._slurm_manager.configure_jwt_rsa(jwt_rsa)
+    def _on_slurmctld_unavailable(self, event: SlurmctldUnavailableEvent) -> None:
+        """Stop the slurmrestd daemon if slurmctld is unavailable."""
+        self._slurmrestd_manager.stop_slurmrestd()
+        self._slurmrestd_manager.stop_munge()
+        self._check_status()
 
     def _check_status(self) -> bool:
-        if not self._stored.slurm_installed:
+        """Check the status of our integrated applications."""
+        if self._stored.slurm_installed is not True:
             self.unit.status = BlockedStatus("Error installing slurmrestd")
             return False
 
-        # Check and see if we have what we need for operation.
-        if not self._slurmrestd.is_joined:
+        if not self._slurmctld.is_joined:
             self.unit.status = BlockedStatus("Need relations: slurmctld")
             return False
 
-        slurmctld_available = (
-            self._slurmrestd.get_stored_munge_key()
-            and self._slurmrestd.get_stored_jwt_rsa()
-            and self._slurmrestd.get_stored_slurm_config()
-        )
-        if not slurmctld_available:
-            self.unit.status = WaitingStatus("Waiting on: slurmctld")
-            return True
-
-        self.unit.status = ActiveStatus("slurmrestd available")
-
+        self.unit.status = ActiveStatus()
         return True
 
-    def _on_check_status_and_write_config(self, event):
-        if not self._check_status():
-            event.defer()
-            return
-
-        slurm_config = self._slurmrestd.get_stored_slurm_config()
-        if slurm_config:
-            self._slurm_manager.render_slurm_configs(slurm_config)
-            self.cluster_name = slurm_config.get("cluster_name")
-        else:
-            logger.error(f"## weird slurmconfig: {slurm_config}")
-
-        # Only restart slurmrestd the first time the node is brought up.
-        if not self._stored.slurmrestd_restarted:
-            self._on_restart_slurmrestd(event)
-
-        if self._fluentbit._relation is not None:
-            self._configure_fluentbit()
-
-    @property
-    def cluster_name(self) -> str:
-        """Return the cluster-name."""
-        return self._stored.cluster_name
-
-    @cluster_name.setter
-    def cluster_name(self, name: str):
-        """Set the cluster-name."""
-        self._stored.cluster_name = name
-
 
 if __name__ == "__main__":
-    main(SlurmrestdCharm)
+    main.main(SlurmrestdCharm)
diff --git a/src/constants.py b/src/constants.py
new file mode 100644
index 0000000..eefa075
--- /dev/null
+++ b/src/constants.py
@@ -0,0 +1,69 @@
+# Copyright 2024 Omnivector, LLC.
+# See LICENSE file for licensing details.
+"""constants for slurmrestd-operator."""
+from pathlib import Path
+
+SLURMRESTD_GROUP_GID = 64031
+SLURMRESTD_USER_UID = 64031
+SLURMRESTD_USER_NAME = "slurmrestd"
+SLURMRESTD_GROUP_NAME = "slurmrestd"
+
+MUNGE_KEY_PATH = Path("/etc/munge/munge.key")
+
+SLURMRESTD_SERVICE = """
+[Unit]
+Description=Slurm REST daemon
+After=network.target munge.service slurmctld.service
+ConditionPathExists=/etc/slurm/slurm.conf
+Documentation=man:slurmrestd(8)
+
+[Service]
+Type=simple
+EnvironmentFile=-/etc/default/slurmrestd
+Environment="SLURM_JWT=daemon"
+ExecStart=/usr/sbin/slurmrestd $SLURMRESTD_OPTIONS -vv 0.0.0.0:6820
+ExecReload=/bin/kill -HUP $MAINPID
+User=slurmrestd
+Group=slurmrestd
+
+# Restart service if failed
+Restart=on-failure
+RestartSec=30s
+
+[Install]
+WantedBy=multi-user.target
+"""
+
+
+UBUNTU_HPC_PPA_KEY = """
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+Comment: Hostname:
+Version: Hockeypuck 2.1.1-10-gec3b0e7
+
+xsFNBGTuZb8BEACtJ1CnZe6/hv84DceHv+a54y3Pqq0gqED0xhTKnbj/E2ByJpmT
+NlDNkpeITwPAAN1e3824Me76Qn31RkogTMoPJ2o2XfG253RXd67MPxYhfKTJcnM3
+CEkmeI4u2Lynh3O6RQ08nAFS2AGTeFVFH2GPNWrfOsGZW03Jas85TZ0k7LXVHiBs
+W6qonbsFJhshvwC3SryG4XYT+z/+35x5fus4rPtMrrEOD65hij7EtQNaE8owuAju
+Kcd0m2b+crMXNcllWFWmYMV0VjksQvYD7jwGrWeKs+EeHgU8ZuqaIP4pYHvoQjag
+umqnH9Qsaq5NAXiuAIAGDIIV4RdAfQIR4opGaVgIFJdvoSwYe3oh2JlrLPBlyxyY
+dayDifd3X8jxq6/oAuyH1h5K/QLs46jLSR8fUbG98SCHlRmvozTuWGk+e07ALtGe
+sGv78ToHKwoM2buXaTTHMwYwu7Rx8LZ4bZPHdersN1VW/m9yn1n5hMzwbFKy2s6/
+D4Q2ZBsqlN+5aW2q0IUmO+m0GhcdaDv8U7RVto1cWWPr50HhiCi7Yvei1qZiD9jq
+57oYZVqTUNCTPxi6NeTOdEc+YqNynWNArx4PHh38LT0bqKtlZCGHNfoAJLPVYhbB
+b2AHj9edYtHU9AAFSIy+HstET6P0UDxy02IeyE2yxoUBqdlXyv6FL44E+wARAQAB
+zRxMYXVuY2hwYWQgUFBBIGZvciBVYnVudHUgSFBDwsGOBBMBCgA4FiEErocSHcPk
+oLD4H/Aj9tDF1ca+s3sFAmTuZb8CGwMFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AA
+CgkQ9tDF1ca+s3sz3w//RNawsgydrutcbKf0yphDhzWS53wgfrs2KF1KgB0u/H+u
+6Kn2C6jrVM0vuY4NKpbEPCduOj21pTCepL6PoCLv++tICOLVok5wY7Zn3WQFq0js
+Iy1wO5t3kA1cTD/05v/qQVBGZ2j4DsJo33iMcQS5AjHvSr0nu7XSvDDEE3cQE55D
+87vL7lgGjuTOikPh5FpCoS1gpemBfwm2Lbm4P8vGOA4/witRjGgfC1fv1idUnZLM
+TbGrDlhVie8pX2kgB6yTYbJ3P3kpC1ZPpXSRWO/cQ8xoYpLBTXOOtqwZZUnxyzHh
+gM+hv42vPTOnCo+apD97/VArsp59pDqEVoAtMTk72fdBqR+BB77g2hBkKESgQIEq
+EiE1/TOISioMkE0AuUdaJ2ebyQXugSHHuBaqbEC47v8t5DVN5Qr9OriuzCuSDNFn
+6SBHpahN9ZNi9w0A/Yh1+lFfpkVw2t04Q2LNuupqOpW+h3/62AeUqjUIAIrmfeML
+IDRE2VdquYdIXKuhNvfpJYGdyvx/wAbiAeBWg0uPSepwTfTG59VPQmj0FtalkMnN
+ya2212K5q68O5eXOfCnGeMvqIXxqzpdukxSZnLkgk40uFJnJVESd/CxHquqHPUDE
+fy6i2AnB3kUI27D4HY2YSlXLSRbjiSxTfVwNCzDsIh7Czefsm6ITK2+cVWs0hNQ=
+=cs1s
+-----END PGP PUBLIC KEY BLOCK-----
+"""
diff --git a/src/interface_slurmctld.py b/src/interface_slurmctld.py
new file mode 100644
index 0000000..2cb238e
--- /dev/null
+++ b/src/interface_slurmctld.py
@@ -0,0 +1,96 @@
+"""Slurmctld interface for slurmrestd <-> slurmctld integration."""
+
+import logging
+
+from ops import (
+    EventBase,
+    EventSource,
+    Object,
+    ObjectEvents,
+    RelationBrokenEvent,
+    RelationChangedEvent,
+)
+
+logger = logging.getLogger()
+
+
+class SlurmctldAvailableEvent(EventBase):
+    """SlurmctldAvailableEvent."""
+
+    def __init__(self, handle, munge_key, slurm_conf):
+        super().__init__(handle)
+
+        self.munge_key = munge_key
+        self.slurm_conf = slurm_conf
+
+    def snapshot(self):
+        """Snapshot the event data."""
+        return {
+            "munge_key": self.munge_key,
+            "slurm_conf": self.slurm_conf,
+        }
+
+    def restore(self, snapshot):
+        """Restore the snapshot of the event data."""
+        self.munge_key = snapshot.get("munge_key")
+        self.slurm_conf = snapshot.get("slurm_conf")
+
+
+class SlurmctldUnavailableEvent(EventBase):
+    """SlurmctldUnavailableEvent."""
+
+
+class Events(ObjectEvents):
+    """'slurmctld' interface Events."""
+
+    slurmctld_available = EventSource(SlurmctldAvailableEvent)
+    slurmctld_unavailable = EventSource(SlurmctldUnavailableEvent)
+
+
+class Slurmctld(Object):
+    """Slurmctld interface."""
+
+    on = Events()  # pyright: ignore [reportIncompatibleMethodOverride, reportAssignmentType]
+
+    def __init__(self, charm, relation_name):
+        """Set the provides initial data."""
+        super().__init__(charm, relation_name)
+
+        self._charm = charm
+        self._relation_name = relation_name
+
+        self.framework.observe(
+            self._charm.on[relation_name].relation_changed, self._on_relation_changed
+        )
+        self.framework.observe(
+            self._charm.on[relation_name].relation_broken, self._on_relation_broken
+        )
+
+    @property
+    def is_joined(self) -> bool:
+        """Return True if self._relation is not None."""
+        return True if self.framework.model.relations.get(self._relation_name) else False
+
+    def _on_relation_changed(self, event: RelationChangedEvent) -> None:
+        """Get the munge key and slurm_conf from slurmctld on relation joined."""
+        if app := event.app:
+            if event_app_data := event.relation.data.get(app):
+
+                munge_key = event_app_data.get("munge_key")
+                slurm_conf = event_app_data.get("slurm_conf")
+
+                logger.debug(f"munge_key={munge_key}")
+                logger.debug(f"slurm_conf={slurm_conf}")
+
+                if munge_key and slurm_conf:
+                    self.on.slurmctld_available.emit(munge_key, slurm_conf)
+                else:
+                    logger.debug("'munge_key' or 'slurm_conf' not in relation data.")
+            else:
+                logger.debug("application data not available in event databag.")
+        else:
+            logger.debug("application not available in relation data.")
+
+    def _on_relation_broken(self, event: RelationBrokenEvent) -> None:
+        """Emit slurmctld_unavailable when the relation is broken."""
+        self.on.slurmctld_unavailable.emit()
diff --git a/src/interface_slurmrestd.py b/src/interface_slurmrestd.py
deleted file mode 100644
index 9d29282..0000000
--- a/src/interface_slurmrestd.py
+++ /dev/null
@@ -1,202 +0,0 @@
-#!/usr/bin/env python3
-"""SlurmrestdRequiries."""
-import json
-import logging
-
-from ops.framework import (
-    EventBase,
-    EventSource,
-    Object,
-    ObjectEvents,
-    StoredState,
-)
-
-logger = logging.getLogger()
-
-
-class SlurmrestdAvailableEvent(EventBase):
-    """SlurmctldAvailableEvent."""
-
-
-class SlurmrestdUnavailableEvent(EventBase):
-    """SlurmctldUnavailableEvent."""
-
-
-class MungeKeyAvailableEvent(EventBase):
-    """MungeKeyAvailableEvent."""
-
-
-class JwtRsaAvailableEvent(EventBase):
-    """JwtRsaAvailableEvent."""
-
-
-class RestartSlurmrestdEvent(EventBase):
-    """RestartSlurmrestdEvent."""
-
-
-class SlurmrestdEvents(ObjectEvents):
-    """SlurmLoginEvents."""
-
-    config_available = EventSource(SlurmrestdAvailableEvent)
-    config_unavailable = EventSource(SlurmrestdUnavailableEvent)
-    munge_key_available = EventSource(MungeKeyAvailableEvent)
-    jwt_rsa_available = EventSource(JwtRsaAvailableEvent)
-    restart_slurmrestd = EventSource(RestartSlurmrestdEvent)
-
-
-class SlurmrestdRequires(Object):
-    """SlurmrestdRequires."""
-
-    _stored = StoredState()
-    on = SlurmrestdEvents()
-
-    def __init__(self, charm, relation_name):
-        """Set the provides initial data."""
-        super().__init__(charm, relation_name)
-
-        self._charm = charm
-        self._relation_name = relation_name
-
-        self._stored.set_default(
-            munge_key=str(),
-            jwt_rsa=str(),
-            slurm_config={},
-            restart_slurmrestd_uuid=str(),
-        )
-
-        self.framework.observe(
-            self._charm.on[relation_name].relation_joined, self._on_relation_joined
-        )
-        self.framework.observe(
-            self._charm.on[relation_name].relation_changed, self._on_relation_changed
-        )
-        self.framework.observe(
-            self._charm.on[relation_name].relation_broken, self._on_relation_broken
-        )
-
-    def _on_relation_joined(self, event):
-        """Get the munge/jwt keys from slurmctld on relation joined."""
-        # Since we are in relation-joined (with the app on the other side)
-        # we can almost guarantee that the app object will exist in
-        # the event, but check for it just in case.
-        event_app_data = event.relation.data.get(event.app)
-        if not event_app_data:
-            event.defer()
-            return
-
-        logger.debug("## slurmrestd joined relation")
-
-        # slurmctld sets the munge_key on the relation-created event
-        # which happens before relation-joined. We can almost guarantee that
-        # the munge key will exist at this point, but check for it just in case.
-        munge_key = event_app_data.get("munge_key")
-        if not munge_key:
-            event.defer()
-            return
-
-        jwt_rsa = event_app_data.get("jwt_rsa")
-        if not jwt_rsa:
-            event.defer()
-            return
-
-        # Store the keys in the charm's state
-        self._store_munge_key(munge_key)
-        self._store_jwt_rsa(jwt_rsa)
-        self.on.munge_key_available.emit()
-        self.on.jwt_rsa_available.emit()
-
-    def _on_relation_changed(self, event):
-        """Check for the munge_key in the relation data."""
-        event_app_data = event.relation.data.get(event.app)
-        if not event_app_data:
-            event.defer()
-            return
-
-        logger.debug("## slurmrestd - relation changed")
-
-        munge_key = event_app_data.get("munge_key")
-        jwt_rsa = event_app_data.get("jwt_rsa")
-        restart_slurmrestd_uuid = event_app_data.get("restart_slurmrestd_uuid")
-        slurm_config = self._get_slurm_config_from_relation()
-
-        if not (munge_key and jwt_rsa and slurm_config):
-            logger.debug("## Deferring event: missing munge, jwt, and/or config")
-            event.defer()
-            return
-
-        # Store the munge_key in the interface StoredState if it has changed
-        if munge_key != self.get_stored_munge_key():
-            self._store_munge_key(munge_key)
-            self.on.munge_key_available.emit()
-
-        # Store the jwt_rsa in the interface StoredState if it has changed
-        if jwt_rsa != self.get_stored_jwt_rsa():
-            self._store_jwt_rsa(jwt_rsa)
-            self.on.jwt_rsa_available.emit()
-
-        # Store the slurm_config in the interface StoredState if it has changed
-        if slurm_config != self.get_stored_slurm_config():
-            self._store_slurm_config(slurm_config)
-            self.on.config_available.emit()
-
-        if restart_slurmrestd_uuid:
-            if restart_slurmrestd_uuid != self._get_restart_slurmrestd_uuid():
-                self._store_restart_slurmrestd_uuid(restart_slurmrestd_uuid)
-                self.on.restart_slurmrestd.emit()
-
-    def _on_relation_broken(self, event):
-        self._store_munge_key("")
-        self._store_jwt_rsa("")
-        self.on.config_unavailable.emit()
-
-    def _get_slurm_config_from_relation(self) -> dict:
-        """Return slurm_config."""
-        relation = self._relation
-        if relation:
-            app = relation.app
-            if app:
-                app_data = self._relation.data.get(app)
-                if app_data:
-                    slurm_config = app_data.get("slurm_config")
-                    if slurm_config:
-                        return json.loads(slurm_config)
-        return {}
-
-    @property
-    def _relation(self):
-        return self.framework.model.get_relation(self._relation_name)
-
-    @property
-    def is_joined(self):
-        """Return True if relation is joined."""
-        if self._charm.framework.model.relations.get(self._relation_name):
-            return True
-        else:
-            return False
-
-    def _store_restart_slurmrestd_uuid(self, restart_slurmrestd_uuid):
-        self._stored.restart_slurmrestd_uuid = restart_slurmrestd_uuid
-
-    def _get_restart_slurmrestd_uuid(self):
-        return self._stored.restart_slurmrestd_uuid
-
-    def _store_munge_key(self, munge_key):
-        self._stored.munge_key = munge_key
-
-    def get_stored_munge_key(self):
-        """Retrieve the munge_key from stored state."""
-        return self._stored.munge_key
-
-    def _store_jwt_rsa(self, jwt_rsa):
-        self._stored.jwt_rsa = jwt_rsa
-
-    def get_stored_jwt_rsa(self):
-        """Retrieve the jwt_rsa from stored state."""
-        return self._stored.jwt_rsa
-
-    def _store_slurm_config(self, slurm_config: dict):
-        self._stored.slurm_config = slurm_config
-
-    def get_stored_slurm_config(self) -> dict:
-        """Retrieve the slurm_config from stored state."""
-        return dict(self._stored.slurm_config)
diff --git a/src/slurmrestd_ops.py b/src/slurmrestd_ops.py
new file mode 100644
index 0000000..6e35131
--- /dev/null
+++ b/src/slurmrestd_ops.py
@@ -0,0 +1,249 @@
+# Copyright 2024 Omnivector, LLC.
+# See LICENSE file for licensing details.
+"""This module provides the SlurmrestdManager."""
+
+import logging
+import os
+import subprocess
+from base64 import b64decode
+from pathlib import Path
+
+import charms.operator_libs_linux.v0.apt as apt
+import charms.operator_libs_linux.v1.systemd as systemd
+import distro
+from constants import (
+    MUNGE_KEY_PATH,
+    SLURMRESTD_GROUP_GID,
+    SLURMRESTD_GROUP_NAME,
+    SLURMRESTD_SERVICE,
+    SLURMRESTD_USER_NAME,
+    SLURMRESTD_USER_UID,
+    UBUNTU_HPC_PPA_KEY,
+)
+
+logger = logging.getLogger()
+
+
+class SlurmrestdManagerError(BaseException):
+    """Exception for use with SlurmrestdManager."""
+
+    def __init__(self, message):
+        super().__init__(message)
+        self.message = message
+
+
+class CharmedHPCPackageLifecycleManager:
+    """Facilitate ubuntu-hpc slurm component package lifecycles."""
+
+    def __init__(self, package_name: str):
+        self._package_name = package_name
+        self._keyring_path = Path(f"/usr/share/keyrings/ubuntu-hpc-{self._package_name}.asc")
+
+    def _repo(self) -> apt.DebianRepository:
+        """Return the ubuntu-hpc repo."""
+        ppa_url: str = "https://ppa.launchpadcontent.net/ubuntu-hpc/slurm-wlm-23.02/ubuntu"
+        sources_list: str = (
+            f"deb [signed-by={self._keyring_path}] {ppa_url} {distro.codename()} main"
+        )
+        return apt.DebianRepository.from_repo_line(sources_list)
+
+    def install(self) -> bool:
+        """Install package using lib apt."""
+        package_installed = False
+
+        if self._keyring_path.exists():
+            self._keyring_path.unlink()
+        self._keyring_path.write_text(UBUNTU_HPC_PPA_KEY)
+
+        repositories = apt.RepositoryMapping()
+        repositories.add(self._repo())
+
+        try:
+            apt.update()
+            apt.add_package([self._package_name])
+            package_installed = True
+        except apt.PackageNotFoundError:
+            logger.error(f"'{self._package_name}' not found in package cache or on system.")
+        except apt.PackageError as e:
+            logger.error(f"Could not install '{self._package_name}'. Reason: {e.message}")
+
+        return package_installed
+
+    def uninstall(self) -> None:
+        """Uninstall the package using libapt."""
+        if apt.remove_package(self._package_name):
+            logger.info(f"'{self._package_name}' removed from system.")
+        else:
+            logger.error(f"'{self._package_name}' not found on system.")
+
+        repositories = apt.RepositoryMapping()
+        repositories.disable(self._repo())
+
+        if self._keyring_path.exists():
+            self._keyring_path.unlink()
+
+    def upgrade_to_latest(self) -> None:
+        """Upgrade package to latest."""
+        try:
+            slurm_package = apt.DebianPackage.from_system(self._package_name)
+            slurm_package.ensure(apt.PackageState.Latest)
+            logger.info(f"Updated '{self._package_name}' to: {slurm_package.version.number}.")
+        except apt.PackageNotFoundError:
+            logger.error(f"'{self._package_name}' not found in package cache or on system.")
+        except apt.PackageError as e:
+            logger.error(f"Could not install '{self._package_name}'. Reason: {e.message}")
+
+    def version(self) -> str:
+        """Return the package version."""
+        slurm_package_vers = ""
+        try:
+            slurm_package_vers = apt.DebianPackage.from_installed_package(
+                self._package_name
+            ).version.number
+        except apt.PackageNotFoundError:
+            logger.error(f"'{self._package_name}' not found on system.")
+        return slurm_package_vers
+
+
+class SlurmrestdManager:
+    """SlurmrestdManager."""
+
+    def __init__(self):
+        self._munge_package = CharmedHPCPackageLifecycleManager("munge")
+        self._slurmrestd_package = CharmedHPCPackageLifecycleManager("slurmrestd")
+
+    def install(self) -> bool:
+        """Install slurmrestd and munge to the system."""
+        logger.debug("Installing and configuring slurmrestd and munge packages.")
+
+        if self._slurmrestd_package.install() is not True:
+            return False
+        systemd.service_stop("slurmrestd")
+
+        if self._munge_package.install() is not True:
+            return False
+        systemd.service_stop("munge")
+
+        self._create_slurmrestd_user_group()
+
+        slurm_conf_dir = Path("/etc/slurm")
+        slurm_conf_dir.mkdir()
+
+        os.chown(f"{slurm_conf_dir}", SLURMRESTD_USER_UID, SLURMRESTD_GROUP_GID)
+
+        logger.debug("Replacing slurmrestd.service")
+        target = Path("/usr/lib/systemd/system/slurmrestd.service")
+        target.write_text(SLURMRESTD_SERVICE)
+        systemd.daemon_reload()
+
+        return True
+
+    def version(self) -> str:
+        """Return slurm version."""
+        return self._slurmrestd_package.version()
+
+    def write_slurm_conf(self, slurm_conf: str) -> None:
+        """Render /etc/slurm/slurm.conf."""
+        target = Path("/etc/slurm/slurm.conf")
+        logger.debug(f"Writing slurm.conf: {target}")
+
+        target.write_text(slurm_conf)
+
+        os.chown(f"{target}", SLURMRESTD_USER_UID, SLURMRESTD_GROUP_GID)
+
+    def write_munge_key(self, munge_key: str) -> None:
+        """Base64 decode and write the munge key."""
+        MUNGE_KEY_PATH.write_bytes(b64decode(munge_key.encode()))
+
+    def check_munged(self) -> bool:
+        """Check if munge is working correctly."""
+        if not systemd.service_running("munge"):
+            return False
+
+        # check if munge is working, i.e., can use the credentials correctly
+        output = ""
+        try:
+            logger.debug("## Testing if munge is working correctly")
+            munge = subprocess.Popen(
+                ["munge", "-n"], stdout=subprocess.PIPE, stderr=subprocess.PIPE
+            )
+            if munge is not None:
+                unmunge = subprocess.Popen(
+                    ["unmunge"], stdin=munge.stdout, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+                )
+                output = unmunge.communicate()[0].decode()
+            if "Success" in output:
+                logger.debug(f"## Munge working as expected: {output}")
+                return True
+            logger.error(f"## Munge not working: {output}")
+        except subprocess.CalledProcessError as e:
+            logger.error(f"## Error testing munge: {e}")
+
+        return False
+
+    def _create_slurmrestd_user_group(self) -> None:
+        """Create the slurmrestd user."""
+        logger.info("#### Creating slurmrestd user and group")
+
+        try:
+            subprocess.check_output(
+                ["groupadd", "--gid", f"{SLURMRESTD_GROUP_GID}", f"{SLURMRESTD_GROUP_NAME}"]
+            )
+        except subprocess.CalledProcessError as e:
+            if e.returncode == 9:
+                logger.warning(f"Group '{SLURMRESTD_GROUP_NAME}' already exists.")
+            else:
+                logger.error(f"Error creating group: '{SLURMRESTD_GROUP_NAME}' - {e}")
+                raise e
+
+        try:
+            subprocess.check_output(
+                [
+                    "adduser",
+                    "--system",
+                    "--gid",
+                    f"{SLURMRESTD_GROUP_GID}",
+                    "--uid",
+                    f"{SLURMRESTD_USER_UID}",
+                    "--no-create-home",
+                    "--home",
+                    "/nonexistent",
+                    f"{SLURMRESTD_USER_NAME}",
+                ]
+            )
+        except subprocess.CalledProcessError as e:
+            if e.returncode == 9:
+                logger.warning(f"User '{SLURMRESTD_USER_NAME}' already exists.")
+            else:
+                logger.error(f"Error creating user: '{SLURMRESTD_USER_NAME} - {e}")
+                raise e
+
+        logger.info("'{SLURMRESTD_USER_NAME}' user and '{SLURMRESTD_GROUP_NAME}' group created.")
+
+    def stop_slurmrestd(self) -> None:
+        """Stop slurmrestd service."""
+        systemd.service_stop("slurmrestd")
+
+    def start_slurmrestd(self) -> None:
+        """Start slurmrestd service."""
+        systemd.service_start("slurmrestd")
+
+    def stop_munge(self) -> None:
+        """Stop munge."""
+        systemd.service_stop("munge")
+
+    def start_munge(self) -> bool:
+        """Start the munge process.
+
+        Return True on success, and False otherwise.
+        """
+        logger.debug("Starting munge.")
+        try:
+            systemd.service_start("munge")
+        # Ignore pyright error for is not a valid exception class, reportGeneralTypeIssues
+        except SlurmrestdManagerError(
+            "Cannot start munge."
+        ) as e:  # pyright: ignore [reportGeneralTypeIssues]
+            logger.error(e)
+            return False
+        return self.check_munged()
diff --git a/tests/integration/helpers.py b/tests/integration/helpers.py
deleted file mode 100644
index 9ca94b0..0000000
--- a/tests/integration/helpers.py
+++ /dev/null
@@ -1,34 +0,0 @@
-# Copyright 2023 Canonical Ltd.
-#
-# 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.
-
-"""Helpers for the slurmrestd integration tests."""
-
-import logging
-from pathlib import Path
-from typing import Dict
-from urllib import request
-
-logger = logging.getLogger(__name__)
-
-NHC = "lbnl-nhc-1.4.3.tar.gz"
-NHC_URL = f"https://github.com/mej/nhc/releases/download/1.4.3/{NHC}"
-
-
-async def get_slurmd_res() -> Dict[str, Path]:
-    """Get slurmd resources needed for charm deployment."""
-    if not (nhc := Path(NHC)).exists():
-        logger.info(f"Getting resource {NHC} from {NHC_URL}")
-        request.urlretrieve(NHC_URL, nhc)
-
-    return {"nhc": nhc}
diff --git a/tests/integration/test_charm.py b/tests/integration/test_charm.py
index 422830a..e67a38e 100644
--- a/tests/integration/test_charm.py
+++ b/tests/integration/test_charm.py
@@ -20,7 +20,6 @@
 
 import pytest
 import tenacity
-from helpers import get_slurmd_res
 from pytest_operator.plugin import OpsTest
 
 logger = logging.getLogger(__name__)
@@ -51,7 +50,7 @@ async def test_build_and_deploy(
     )
     # Pack charms and download NHC resource for slurmd operator.
     slurmrestd, slurmctld, slurmd_res, slurmd, slurmdbd = await asyncio.gather(
-        slurmrestd_charm, slurmctld_charm, get_slurmd_res(), slurmd_charm, slurmdbd_charm
+        slurmrestd_charm, slurmctld_charm, slurmd_charm, slurmdbd_charm
     )
     # Deploy the test Charmed SLURM cloud.
     await asyncio.gather(
@@ -73,7 +72,6 @@ async def test_build_and_deploy(
             application_name=SLURMD,
             channel="edge" if isinstance(slurmd, str) else None,
             num_units=1,
-            resources=slurmd_res,
             base=charm_base,
         ),
         ops_test.model.deploy(
@@ -98,14 +96,12 @@ async def test_build_and_deploy(
             base="ubuntu@22.04",
         ),
     )
-    # Attach resources to charms.
-    await ops_test.juju("attach-resource", SLURMD, f"nhc={slurmd_res['nhc']}")
     # Set relations for charmed applications.
-    await ops_test.model.integrate(f"{SLURMCTLD}:{SLURMDBD}", f"{SLURMDBD}:{SLURMDBD}")
+    await ops_test.model.integrate(f"{SLURMCTLD}:{SLURMDBD}", f"{SLURMDBD}:{SLURMCTLD}")
     await ops_test.model.integrate(f"{SLURMDBD}-{ROUTER}:backend-database", f"{DATABASE}:database")
     await ops_test.model.integrate(f"{SLURMDBD}:database", f"{SLURMDBD}-{ROUTER}:database")
-    await ops_test.model.integrate(f"{SLURMRESTD}:slurmrestd", f"{SLURMCTLD}:slurmrestd")
-    await ops_test.model.integrate(f"{SLURMD}:{SLURMD}", f"{SLURMCTLD}:{SLURMD}")
+    await ops_test.model.integrate(f"{SLURMRESTD}:{SLURMCTLD}", f"{SLURMCTLD}:{SLURMRESTD}")
+    await ops_test.model.integrate(f"{SLURMD}:{SLURMCTLD}", f"{SLURMCTLD}:{SLURMD}")
     # Reduce the update status frequency to accelerate the triggering of deferred events.
     async with ops_test.fast_forward():
         await ops_test.model.wait_for_idle(apps=[SLURMRESTD], status="active", timeout=1000)
diff --git a/tests/unit/test_charm.py b/tests/unit/test_charm.py
index 9b007de..db72b29 100644
--- a/tests/unit/test_charm.py
+++ b/tests/unit/test_charm.py
@@ -19,7 +19,7 @@
 from unittest.mock import PropertyMock, patch
 
 from charm import SlurmrestdCharm
-from ops.model import ActiveStatus, BlockedStatus, MaintenanceStatus
+from ops.model import ActiveStatus, BlockedStatus
 from ops.testing import Harness
 
 
@@ -29,112 +29,18 @@ def setUp(self) -> None:
         self.addCleanup(self.harness.cleanup)
         self.harness.begin()
 
-    @patch("ops.framework.EventBase.defer")
-    def test_config_available_fail(self, defer):
-        self.harness.charm._slurmrestd.on.config_available.emit()
-        defer.assert_called()
-
-    @patch("slurm_ops_manager.SlurmManager.render_slurm_configs")
-    @patch(
-        "interface_slurmrestd.SlurmrestdRequires.get_stored_slurm_config",
-        return_value={"cluster_name": "test"},
-    )
     @patch(
-        "interface_slurmrestd.SlurmrestdRequires.is_joined",
+        "interface_slurmctld.Slurmctld.is_joined",
         new_callable=PropertyMock(return_value=True),
     )
-    @patch("interface_slurmrestd.SlurmrestdRequires.get_stored_munge_key", lambda _: True)
-    @patch("interface_slurmrestd.SlurmrestdRequires.get_stored_jwt_rsa", lambda _: True)
-    @patch("interface_slurmrestd.SlurmrestdRequires.get_stored_slurm_config", lambda _: True)
-    @patch("ops.framework.EventBase.defer")
-    def test_config_available_success(self, defer, *_):
-        self.harness.charm._stored.slurm_installed = True
-        self.harness.charm._stored.slurmrestd_restarted = True
-
-        self.harness.charm._slurmrestd.on.config_available.emit()
-        defer.assert_not_called()
-
-    def test_config_unavailable(self):
-        self.harness.charm._slurmrestd.on.config_unavailable.emit()
-        self.assertFalse(self.harness.charm._stored.slurmrestd_restarted)
-
-    @patch("pathlib.Path.read_text", return_value="v1.0.0")
-    @patch("ops.framework.EventBase.defer")
-    def test_install_fail(self, defer, *_):
-        self.harness.charm.on.install.emit()
-        self.assertFalse(self.harness.charm._stored.slurm_installed)
-        defer.assert_called()
-
-    @patch(
-        "interface_slurmrestd.SlurmrestdRequires.is_joined",
-        new_callable=PropertyMock(return_value=True),
-    )
-    @patch("interface_slurmrestd.SlurmrestdRequires.get_stored_munge_key", lambda _: True)
-    @patch("interface_slurmrestd.SlurmrestdRequires.get_stored_jwt_rsa", lambda _: True)
-    @patch("interface_slurmrestd.SlurmrestdRequires.get_stored_slurm_config", lambda _: True)
-    @patch("slurm_ops_manager.SlurmManager.install")
-    @patch("pathlib.Path.read_text", return_value="v1.0.0")
-    @patch("slurm_ops_manager.SlurmManager.start_munged", lambda _: True)
-    @patch("ops.framework.EventBase.defer")
-    def test_install_success(self, defer, *_):
+    @patch("slurmrestd_ops.SlurmrestdManager.version", return_value="1.1.1")
+    @patch("slurmrestd_ops.SlurmrestdManager.install")
+    @patch("slurmrestd_ops.CharmedHPCPackageLifecycleManager.install")
+    def test_install_success(self, *_):
+        self.harness.charm._stored.slurmctld_available = True
         self.harness.charm.on.install.emit()
         self.assertTrue(self.harness.charm._stored.slurm_installed)
-        self.assertEqual(self.harness.charm.unit.status, ActiveStatus("slurmrestd available"))
-        defer.assert_not_called()
-
-    @patch("ops.framework.EventBase.defer")
-    def test_jwt_rsa_available_fail(self, defer):
-        self.harness.charm._slurmrestd.on.jwt_rsa_available.emit()
-        defer.assert_called()
-
-    @patch("interface_slurmrestd.SlurmrestdRequires.get_stored_jwt_rsa")
-    @patch("slurm_ops_manager.SlurmManager.configure_jwt_rsa")
-    @patch("ops.framework.EventBase.defer")
-    def test_jwt_rsa_available_success(self, defer, *_):
-        self.harness.charm._stored.slurm_installed = True
-
-        self.harness.charm._slurmrestd.on.jwt_rsa_available.emit()
-        defer.assert_not_called()
-
-    @patch("ops.framework.EventBase.defer")
-    def test_munge_key_available_fail(self, defer):
-        self.harness.charm._slurmrestd.on.munge_key_available.emit()
-        defer.assert_called()
-
-    @patch("interface_slurmrestd.SlurmrestdRequires.get_stored_munge_key")
-    @patch("slurm_ops_manager.SlurmManager.configure_munge_key")
-    @patch("slurm_ops_manager.SlurmManager.restart_munged")
-    @patch("ops.framework.EventBase.defer")
-    def test_munge_key_available_success(self, defer, *_):
-        self.harness.charm._stored.slurm_installed = True
-
-        self.harness.charm._slurmrestd.on.munge_key_available.emit()
-        defer.assert_not_called()
-
-    @patch("ops.framework.EventBase.defer")
-    def test_restart_slurmrestd_fail(self, defer):
-        self.harness.charm._slurmrestd.on.restart_slurmrestd.emit()
-        defer.assert_called()
-
-    @patch("slurm_ops_manager.SlurmManager.restart_slurm_component", lambda _: True)
-    @patch(
-        "interface_slurmrestd.SlurmrestdRequires.is_joined",
-        new_callable=PropertyMock(return_value=True),
-    )
-    @patch("interface_slurmrestd.SlurmrestdRequires.get_stored_munge_key", lambda _: True)
-    @patch("interface_slurmrestd.SlurmrestdRequires.get_stored_jwt_rsa", lambda _: True)
-    @patch("interface_slurmrestd.SlurmrestdRequires.get_stored_slurm_config", lambda _: True)
-    @patch("ops.framework.EventBase.defer")
-    def test_restart_slurmrestd_success(self, defer, *_):
-        self.harness.charm._stored.slurm_installed = True
-
-        self.harness.charm._slurmrestd.on.restart_slurmrestd.emit()
-        self.assertTrue(self.harness.charm._stored.slurmrestd_restarted)
-        defer.assert_not_called()
-
-    def test_start(self):
-        self.harness.charm.on.start.emit()
-        self.assertEqual(self.harness.charm.unit.status, MaintenanceStatus(""))
+        self.assertEqual(self.harness.charm.unit.status, ActiveStatus())
 
     def test_update_status_fail(self):
         self.harness.charm.on.update_status.emit()
@@ -143,35 +49,12 @@ def test_update_status_fail(self):
         )
 
     @patch(
-        "interface_slurmrestd.SlurmrestdRequires.is_joined",
+        "interface_slurmctld.Slurmctld.is_joined",
         new_callable=PropertyMock(return_value=True),
     )
-    @patch("interface_slurmrestd.SlurmrestdRequires.get_stored_munge_key", lambda _: True)
-    @patch("interface_slurmrestd.SlurmrestdRequires.get_stored_jwt_rsa", lambda _: True)
-    @patch("interface_slurmrestd.SlurmrestdRequires.get_stored_slurm_config", lambda _: True)
+    @patch("slurmrestd_ops.SlurmrestdManager.check_munged", return_value=True)
     def test_update_status_success(self, *_):
         self.harness.charm._stored.slurm_installed = True
 
         self.harness.charm.on.update_status.emit()
-        self.assertEqual(self.harness.charm.unit.status, ActiveStatus("slurmrestd available"))
-
-    @patch("pathlib.Path.read_text", return_value="v1.0.0")
-    def test_upgrade_fail(self, *_):
-        self.harness.charm.on.upgrade_charm.emit()
-        self.assertEqual(
-            self.harness.charm.unit.status, BlockedStatus("Error installing slurmrestd")
-        )
-
-    @patch("pathlib.Path.read_text", return_value="v1.0.0")
-    @patch(
-        "interface_slurmrestd.SlurmrestdRequires.is_joined",
-        new_callable=PropertyMock(return_value=True),
-    )
-    @patch("interface_slurmrestd.SlurmrestdRequires.get_stored_munge_key", lambda _: True)
-    @patch("interface_slurmrestd.SlurmrestdRequires.get_stored_jwt_rsa", lambda _: True)
-    @patch("interface_slurmrestd.SlurmrestdRequires.get_stored_slurm_config", lambda _: True)
-    def test_upgrade_success(self, *_):
-        self.harness.charm._stored.slurm_installed = True
-
-        self.harness.charm.on.upgrade_charm.emit()
-        self.assertEqual(self.harness.charm.unit.status, ActiveStatus("slurmrestd available"))
+        self.assertEqual(self.harness.charm.unit.status, ActiveStatus())
diff --git a/tox.ini b/tox.ini
index 1b89fbc..682e543 100644
--- a/tox.ini
+++ b/tox.ini
@@ -4,7 +4,7 @@
 [tox]
 skipsdist=True
 skip_missing_interpreters = True
-envlist = lint, unit
+envlist = lint, type, unit
 
 [vars]
 src_path = {toxinidir}/src/
@@ -31,7 +31,7 @@ deps =
     ruff
 commands =
     black {[vars]all_path}
-    ruff --fix {[vars]all_path}
+    ruff check {[vars]all_path} --fix
 
 [testenv:lint]
 description = Check code against coding style standards
@@ -41,14 +41,22 @@ deps =
     ruff
 commands =
     codespell {toxinidir}
-    ruff {[vars]all_path}
+    ruff check {[vars]all_path}
     black --check --diff {[vars]all_path}
 
+[testenv:type]
+description = Type checking with pyright.
+deps =
+    pyright
+    -r{toxinidir}/requirements.txt
+commands =
+    pyright {[vars]src_path}
+
 [testenv:unit]
 description = Run unit tests
 deps =
-    pytest==7.2.0
-    coverage[toml]==6.5.0
+    pytest
+    coverage[toml]
     -r{toxinidir}/requirements.txt
 commands =
     coverage run \
@@ -60,10 +68,10 @@ commands =
 description = Run integration tests
 deps =
     juju
-    pytest==7.2.0
-    pytest-operator==0.31.1
-    pytest-order==1.1.0
-    tenacity==8.2.2
+    pytest
+    pytest-operator
+    pytest-order
+    tenacity
     -r{toxinidir}/requirements.txt
 commands =
     pytest -v \

From 1c4432e72c76a7e655c9e3a96e82e810ea18b641 Mon Sep 17 00:00:00 2001
From: jamesbeedy <jamesbeedy@gmail.com>
Date: Fri, 28 Jun 2024 16:25:30 +0000
Subject: [PATCH 2/2] correct the relation in the docstring

---
 src/interface_slurmctld.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/interface_slurmctld.py b/src/interface_slurmctld.py
index 2cb238e..47e7780 100644
--- a/src/interface_slurmctld.py
+++ b/src/interface_slurmctld.py
@@ -72,7 +72,7 @@ def is_joined(self) -> bool:
         return True if self.framework.model.relations.get(self._relation_name) else False
 
     def _on_relation_changed(self, event: RelationChangedEvent) -> None:
-        """Get the munge key and slurm_conf from slurmctld on relation joined."""
+        """Get the munge key and slurm_conf from slurmctld on relation changed."""
         if app := event.app:
             if event_app_data := event.relation.data.get(app):