From ccefec72da2e0820ab81353ed20976946cbd7ad0 Mon Sep 17 00:00:00 2001
From: jamesbeedy <jamesbeedy@gmail.com>
Date: Tue, 25 Jun 2024 19:47:41 +0000
Subject: [PATCH] pr feedback integration

---
 src/charm.py                |  91 +++---
 src/constants.py            |  99 +++++++
 src/interface_slurmd.py     |  18 +-
 src/interface_slurmdbd.py   |  10 +-
 src/interface_slurmrestd.py |  12 +-
 src/slurm_conf_editor.py    |   2 +-
 src/slurmctld_ops.py        | 541 +++++++++---------------------------
 tox.ini                     |   8 +-
 8 files changed, 311 insertions(+), 470 deletions(-)
 create mode 100644 src/constants.py

diff --git a/src/charm.py b/src/charm.py
index b93ea27..56f96b0 100755
--- a/src/charm.py
+++ b/src/charm.py
@@ -9,7 +9,8 @@
 import subprocess
 from typing import Any, Dict, List, Optional, Union
 
-from charms.fluentbit.v0.fluentbit import FluentbitClient  # type: ignore
+from charms.fluentbit.v0.fluentbit import FluentbitClient
+from constants import CHARM_MAINTAINED_SLURM_CONF_PARAMETERS, FLUENTBIT_CONFIG, SLURM_CONF_PATH
 from interface_slurmd import (
     PartitionAvailableEvent,
     PartitionUnavailableEvent,
@@ -40,7 +41,7 @@
     main,
 )
 from slurm_conf_editor import slurm_conf_as_string
-from slurmctld_ops import SlurmctldManager
+from slurmctld_ops import SlurmctldManager, is_container
 
 logger = logging.getLogger()
 
@@ -65,13 +66,9 @@ def __init__(self, *args):
             user_supplied_slurm_conf_params=str(),
         )
 
-        # Fluentbit relation
-        self._fluentbit = FluentbitClient(self, "fluentbit")
-
-        # SlurmctldManager
-        self._slurmctld_manager = SlurmctldManager(self, "slurmctld")
+        self._slurmctld_manager = SlurmctldManager()
 
-        # Slurm components
+        self._fluentbit = FluentbitClient(self, "fluentbit")
         self._slurmd = Slurmd(self, "slurmd")
         self._slurmdbd = Slurmdbd(self, "slurmdbd")
         self._slurmrestd = Slurmrestd(self, "slurmrestd")
@@ -91,7 +88,6 @@ def __init__(self, *args):
             self._slurmd.on.slurmd_departed: self._on_write_slurm_conf,
             # slurmrestd available
             self._slurmrestd.on.slurmrestd_available: self._on_slurmrestd_available,
-            # NOTE: a second slurmctld should get the jwt/munge keys and configure them
             # fluentbit
             self.on["fluentbit"].relation_created: self._on_fluentbit_relation_created,
             # actions
@@ -111,29 +107,43 @@ def _on_install(self, event: InstallEvent) -> None:
             # Store the munge_key and jwt_rsa key in the stored state.
             # NOTE: Use secrets instead of stored state when secrets are supported the framework.
             if self.model.unit.is_leader():
-                self._stored.jwt_rsa = self._slurmctld_manager.generate_jwt_rsa()
-                self._stored.munge_key = self._slurmctld_manager.get_munge_key()
-                self._slurmctld_manager.write_jwt_rsa(self.get_jwt_rsa())
-                self._slurmctld_manager.restart_munged()
+                jwt_rsa = self._slurmctld_manager.generate_jwt_rsa()
+                self._stored.jwt_rsa = jwt_rsa
+
+                munge_key = self._slurmctld_manager.generate_munge_key()
+                self._stored.munge_key = munge_key
+
+                self._slurmctld_manager.stop_munged()
+                self._slurmctld_manager.write_munge_key(munge_key)
+                self._slurmctld_manager.start_munged()
+
+                self._slurmctld_manager.stop_slurmctld()
+                self._slurmctld_manager.write_jwt_rsa(jwt_rsa)
+                self._slurmctld_manager.start_slurmctld()
+
                 self.unit.set_workload_version(self._slurmctld_manager.version())
                 self.slurm_installed = True
             else:
+                self.unit.status = BlockedStatus("Only singleton slurmctld is supported.")
                 logger.debug("Secondary slurmctld not supported.")
                 event.defer()
         else:
             self.unit.status = BlockedStatus("Error installing slurmctld")
+            logger.error("Cannot install slurmctld, please debug.")
             event.defer()
 
         self._on_write_slurm_conf(event)
 
     def _on_config_changed(self, event: ConfigChangedEvent) -> None:
         """Perform config-changed operations."""
-        charm_config_nhc_params = self.config.get("health-check-params")
-        if (user_supplied_nhc_params := charm_config_nhc_params) != self._stored.nhc_params:
+        charm_config_nhc_params = str(self.config.get("health-check-params", ""))
+        if (charm_config_nhc_params != self._stored.nhc_params) and (
+            charm_config_nhc_params != ""
+        ):
             logger.debug("## NHC user supplied params changed, sending to slurmd.")
-            self._stored.nhc_params = user_supplied_nhc_params
+            self._stored.nhc_params = charm_config_nhc_params
             # Send the custom NHC parameters to all slurmd.
-            self._slurmd.set_nhc_params(user_supplied_nhc_params)
+            self._slurmd.set_nhc_params(charm_config_nhc_params)
 
         write_slurm_conf = False
         if charm_config_default_partition := self.config.get("default-partition"):
@@ -160,15 +170,13 @@ def _on_update_status(self, event: UpdateStatusEvent) -> None:
 
     def _on_show_current_config_action(self, event: ActionEvent) -> None:
         """Show current slurm.conf."""
-        slurm_conf = self._slurmctld_manager.slurm_conf_path.read_text()
+        slurm_conf = SLURM_CONF_PATH.read_text()
         event.set_results({"slurm.conf": slurm_conf})
 
     def _on_fluentbit_relation_created(self, event: RelationCreatedEvent) -> None:
         """Set up Fluentbit log forwarding."""
         logger.debug("## Configuring fluentbit")
-        cfg = []
-        cfg.extend(self._slurmctld_manager.fluentbit_config_slurm)
-        self._fluentbit.configure(cfg)
+        self._fluentbit.configure(FLUENTBIT_CONFIG)
 
     def _on_slurmrestd_available(self, event: SlurmrestdAvailableEvent) -> None:
         """Check that we have slurm_config when slurmrestd available otherwise defer the event."""
@@ -241,16 +249,15 @@ def _on_write_slurm_conf(
             return
 
         if slurm_config := self._assemble_slurm_conf():
+            self._slurmctld_manager.stop_slurmctld()
             self._slurmctld_manager.write_slurm_conf(slurm_config)
 
             # Write out any user_supplied_cgroup_parameters to /etc/slurm/cgroup.conf.
-            if user_supplied_cgroup_parameters := self.config.get("cgroup-parameters"):
-                self._slurmctld_manager.write_cgroup_conf(user_supplied_cgroup_parameters)
+            if user_supplied_cgroup_parameters := self.config.get("cgroup-parameters", ""):
+                self._slurmctld_manager.write_cgroup_conf(str(user_supplied_cgroup_parameters))
+
+            self._slurmctld_manager.start_slurmctld()
 
-            # Restart is needed if nodes are added/removed from the cluster, but since we don't
-            # currently have a method of identifying if nodes are being added or removed, simply
-            # restart every time after writing slurm.conf.
-            self._slurmctld_manager.restart_slurmctld()
             self._slurmctld_manager.slurm_cmd("scontrol", "reconfigure")
 
             # Transitioning Nodes
@@ -281,29 +288,28 @@ def _on_write_slurm_conf(
             logger.debug("## Should write slurm.conf, but we don't have it. " "Deferring.")
             event.defer()
 
-    def _assemble_slurm_conf(self) -> Dict[Any, Any]:
+    def _assemble_slurm_conf(self) -> Dict[str, Any]:
         """Return the slurm.conf parameters."""
-        slurmctld_manager = self._slurmctld_manager
-
-        charm_maintained_parameters = slurmctld_manager.charm_maintained_slurm_conf_parameters()
         user_supplied_parameters = self._get_user_supplied_parameters()
 
         slurmd_parameters = self._slurmd.get_new_nodes_and_nodes_and_partitions()
 
         def _assemble_slurmctld_parameters() -> str:
             # Preprocess merging slurmctld_parameters if they exist in the context
-            slurmctld_param_config = charm_maintained_parameters["SlurmctldParameters"].split(",")
-            if user_supplied_slurmctld_parameters := user_supplied_parameters.get(
+            slurmctld_param_config = CHARM_MAINTAINED_SLURM_CONF_PARAMETERS[
                 "SlurmctldParameters"
-            ):
-                slurmctld_param_config = list(
-                    set(
-                        slurmctld_param_config.extend(
-                            user_supplied_slurmctld_parameters.split(",")
-                        )
-                    )
+            ].split(",")
+            user_config = []
+
+            if (
+                user_supplied_slurmctld_parameters := user_supplied_parameters.get(
+                    "SlurmctldParameters", ""
                 )
-            return ",".join(slurmctld_param_config)
+                != ""
+            ):
+                user_config.extend(user_supplied_slurmctld_parameters.split(","))
+
+            return ",".join(slurmctld_param_config + user_config)
 
         accounting_params = {}
         if (slurmdbd_host := self._stored.slurmdbd_host) != "":
@@ -319,8 +325,9 @@ def _assemble_slurmctld_parameters() -> str:
             "SlurmctldAddr": self._slurmd_ingress_address,
             "SlurmctldHost": self.hostname,
             "SlurmctldParameters": _assemble_slurmctld_parameters(),
+            "ProctrackType": "proctrack/linuxproc" if is_container() else "proctrack/cgroup",
             **accounting_params,
-            **charm_maintained_parameters,
+            **CHARM_MAINTAINED_SLURM_CONF_PARAMETERS,
             **slurmd_parameters,
             **user_supplied_parameters,
         }
diff --git a/src/constants.py b/src/constants.py
new file mode 100644
index 0000000..c074c34
--- /dev/null
+++ b/src/constants.py
@@ -0,0 +1,99 @@
+# Copyright 2024 Omnivector, LLC.
+# See LICENSE file for licensing details.
+"""This module provides constants for the slurmctld-operator charm."""
+from pathlib import Path
+
+SLURM_CONF_PATH = Path("/etc/slurm/slurm.conf")
+SLURM_USER = "slurm"
+SLURM_GROUP = "slurm"
+
+CHARM_MAINTAINED_SLURM_CONF_PARAMETERS = {
+    "AuthAltParameters": "jwt_key=/var/spool/slurmctldjwt_hs256.key",
+    "AuthAltTypes": "auth/jwt",
+    "AuthInfo": "/var/run/munge/munge.socket.2",
+    "AuthType": "auth/munge",
+    "GresTypes": "gpu",
+    "HealthCheckInterval": "600",
+    "HealthCheckNodeState": "ANY,CYCLE",
+    "HealthCheckProgram": "/usr/sbin/omni-nhc-wrapper",
+    "MailProg": "/usr/bin/mail.mailutils",
+    "PluginDir": "/usr/lib/x86_64-linux-gnu/slurm-wlm",
+    "PlugStackConfig": "/etc/slurm/plugstack.conf.d/plugstack.conf",
+    "SelectType": "select/cons_tres",
+    "SlurmctldPort": "6817",
+    "SlurmdPort": "6818",
+    "StateSaveLocation": "/var/spool/slurmctld",
+    "SlurmdSpoolDir": "/var/spool/slurmd",
+    "SlurmctldParameters": "enable_configless",
+    "SlurmctldLogFile": "/var/log/slurm/slurmctld.log",
+    "SlurmdLogFile": "/var/log/slurm/slurmctld.log",
+    "SlurmdPidFile": "/var/run/slurmd.pid",
+    "SlurmctldPidFile": "/var/run/slurmctld.pid",
+    "SlurmUser": SLURM_USER,
+    "SlurmdUser": "root",
+    "RebootProgram": '"/usr/sbin/reboot --reboot"',
+}
+
+
+FLUENTBIT_CONFIG = [
+    {
+        "input": [
+            ("name", "tail"),
+            ("path", "/var/log/slurm/slurmctld.log"),
+            ("path_key", "filename"),
+            ("tag", "slurmctld"),
+            ("parser", "slurm"),
+        ]
+    },
+    {
+        "parser": [
+            ("name", "slurm"),
+            ("format", "regex"),
+            ("regex", r"^\[(?<time>[^\]]*)\] (?<log>.*)$"),
+            ("time_key", "time"),
+            ("time_format", "%Y-%m-%dT%H:%M:%S.%L"),
+        ]
+    },
+    {
+        "filter": [
+            ("name", "record_modifier"),
+            ("match", "slurmctld"),
+            ("record", "hostname ${HOSTNAME}"),
+            ("record", "service slurmctld"),
+        ]
+    },
+]
+
+
+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_slurmd.py b/src/interface_slurmd.py
index d48ce4a..b0a4a26 100644
--- a/src/interface_slurmd.py
+++ b/src/interface_slurmd.py
@@ -1,5 +1,5 @@
-#!/usr/bin/env python3
-"""Interface slurmd."""
+"""Slurmctld interface to slurmd."""
+
 import json
 import logging
 from typing import Any, Dict
@@ -36,8 +36,8 @@ class SlurmdDepartedEvent(EventBase):
     """Emitted when one slurmd departs."""
 
 
-class PartitionInventoryEvents(ObjectEvents):
-    """SlurmClusterProviderRelationEvents."""
+class Events(ObjectEvents):
+    """Slurmd interface events."""
 
     partition_available = EventSource(PartitionAvailableEvent)
     partition_unavailable = EventSource(PartitionUnavailableEvent)
@@ -48,7 +48,7 @@ class PartitionInventoryEvents(ObjectEvents):
 class Slurmd(Object):
     """Slurmd inventory interface."""
 
-    on = PartitionInventoryEvents()
+    on = Events()  # pyright: ignore [reportIncompatibleMethodOverride, reportAssignmentType]
 
     def __init__(self, charm, relation_name):
         """Set self._relation_name and self.charm."""
@@ -122,7 +122,7 @@ def _on_relation_changed(self, event: RelationChangedEvent) -> None:
                     raise (e)
 
                 if node.get("new_node"):
-                    if node_config := node.get("node_config"):
+                    if node_config := node.get("node_parameters"):
                         if node_name := node_config.get("NodeName"):
                             self._charm.new_nodes = list(set(self._charm.new_nodes + [node_name]))
                             self.on.slurmd_available.emit()
@@ -143,7 +143,7 @@ def _on_relation_broken(self, event: RelationBrokenEvent) -> None:
             event.relation.data[self.model.app]["cluster_info"] = ""
             self.on.partition_unavailable.emit()
 
-    def set_nhc_params(self, params: str = "#") -> None:
+    def set_nhc_params(self, params: str) -> None:
         """Send NHC parameters to all slurmd."""
         # juju does not allow setting empty data/strings on the relation data,
         # so we set it to something that behaves like empty
@@ -214,7 +214,7 @@ def get_new_nodes_and_nodes_and_partitions(self) -> Dict[str, Any]:
                         if node := self._get_node_from_relation(relation, unit):
 
                             # Check that the data we expect to exist, exists.
-                            if node_config := node.get("node_config"):
+                            if node_config := node.get("node_parameters"):
 
                                 # Get the NodeName and append to the partition nodes
                                 node_name = node_config["NodeName"]
@@ -236,7 +236,7 @@ def get_new_nodes_and_nodes_and_partitions(self) -> Dict[str, Any]:
                     if self._charm.model.config.get("default-partition") == partition_name:
                         partition_parameters["Default"] = "YES"
 
-                partitions[partition_name] = partition_parameters
+                    partitions[partition_name] = partition_parameters
 
         # If we have down nodes because they are new nodes, then set them here.
         new_node_down_nodes = (
diff --git a/src/interface_slurmdbd.py b/src/interface_slurmdbd.py
index 5f2135d..6012463 100644
--- a/src/interface_slurmdbd.py
+++ b/src/interface_slurmdbd.py
@@ -1,5 +1,5 @@
-#!/usr/bin/env python3
-"""Slurmdbd."""
+"""Slurmctld interface to slurmdbd."""
+
 import json
 import logging
 
@@ -37,8 +37,8 @@ class SlurmdbdUnavailableEvent(EventBase):
     """Emits slurmdbd_unavailable."""
 
 
-class SlurmdbdAvailableEvents(ObjectEvents):
-    """SlurmdbdAvailableEvents."""
+class Events(ObjectEvents):
+    """Slurmdbd interface events."""
 
     slurmdbd_available = EventSource(SlurmdbdAvailableEvent)
     slurmdbd_unavailable = EventSource(SlurmdbdUnavailableEvent)
@@ -47,7 +47,7 @@ class SlurmdbdAvailableEvents(ObjectEvents):
 class Slurmdbd(Object):
     """Facilitate slurmdbd lifecycle events."""
 
-    on = SlurmdbdAvailableEvents()
+    on = Events()  # pyright: ignore [reportIncompatibleMethodOverride, reportAssignmentType]
 
     def __init__(self, charm, relation_name):
         """Set the initial attribute values for this interface."""
diff --git a/src/interface_slurmrestd.py b/src/interface_slurmrestd.py
index d52500e..b671fbe 100644
--- a/src/interface_slurmrestd.py
+++ b/src/interface_slurmrestd.py
@@ -1,5 +1,5 @@
-#!/usr/bin/env python3
-"""SlurmrestdProvides."""
+"""Slurmctld interface to slurmrestd."""
+
 import logging
 
 from ops import (
@@ -22,8 +22,8 @@ class SlurmrestdUnavailableEvent(EventBase):
     """Emitted when the slurmrestd relation is broken."""
 
 
-class SlurmrestdEvents(ObjectEvents):
-    """SlurmrestdEvents."""
+class Events(ObjectEvents):
+    """Slurmrestd interface events."""
 
     slurmrestd_available = EventSource(SlurmrestdAvailableEvent)
     slurmrestd_unavailable = EventSource(SlurmrestdUnavailableEvent)
@@ -32,7 +32,7 @@ class SlurmrestdEvents(ObjectEvents):
 class Slurmrestd(Object):
     """Slurmrestd interface."""
 
-    on = SlurmrestdEvents()
+    on = Events()  # pyright: ignore [reportIncompatibleMethodOverride, reportAssignmentType]
 
     def __init__(self, charm, relation_name):
         """Set the initial data."""
@@ -69,7 +69,7 @@ def _on_relation_created(self, event: RelationCreatedEvent) -> None:
     def _on_relation_broken(self, event: RelationBrokenEvent) -> None:
         self.on.slurmrestd_unavailable.emit()
 
-    def set_slurm_config_on_app_relation_data(self, slurm_config: dict) -> None:
+    def set_slurm_config_on_app_relation_data(self, slurm_config: str) -> None:
         """Set the slurm_conifg to the app data on the relation.
 
         Setting data on the relation forces the units of related applications
diff --git a/src/slurm_conf_editor.py b/src/slurm_conf_editor.py
index cd29b7c..a346fc4 100644
--- a/src/slurm_conf_editor.py
+++ b/src/slurm_conf_editor.py
@@ -1,5 +1,5 @@
-#!/usr/bin/env python3
 """Slurm Configuration Helpers."""
+
 import copy
 import textwrap
 from dataclasses import dataclass, field
diff --git a/src/slurmctld_ops.py b/src/slurmctld_ops.py
index 2a4f22f..07819f9 100644
--- a/src/slurmctld_ops.py
+++ b/src/slurmctld_ops.py
@@ -1,33 +1,28 @@
 # Copyright 2024 Omnivector, LLC.
 # See LICENSE file for licensing details.
-"""This module provides the SlurmManager."""
+"""This module provides the SlurmctldManager."""
 
 import logging
 import os
-import shlex
-import shutil
 import socket
 import subprocess
+import tempfile
 from base64 import b64decode, b64encode
+from grp import getgrnam
 from pathlib import Path
+from pwd import getpwnam
 
-import charms.operator_libs_linux.v0.apt as apt  # type: ignore [import-untyped]
-import charms.operator_libs_linux.v1.systemd as systemd  # type: ignore [import-untyped]
+import charms.operator_libs_linux.v0.apt as apt
+import charms.operator_libs_linux.v1.systemd as systemd
 import distro
+from constants import SLURM_GROUP, SLURM_USER, UBUNTU_HPC_PPA_KEY
 from Crypto.PublicKey import RSA
-from ops.framework import (
-    Object,
-    StoredState,
-)
 from slurm_conf_editor import slurm_conf_as_string
 
 logger = logging.getLogger()
 
 
-TEMPLATE_DIR = Path(os.path.dirname(os.path.abspath(__file__))) / "templates"
-
-
-def _is_container() -> bool:
+def is_container() -> bool:
     """Determine if we are running in a container."""
     container = False
     try:
@@ -38,7 +33,14 @@ def _is_container() -> bool:
     return container
 
 
-class SlurmctldException(BaseException):
+def _get_slurm_user_uid_and_slurm_group_gid():
+    """Return the slurm user uid and slurm group gid."""
+    slurm_user_uid = getpwnam(SLURM_USER).pw_uid
+    slurm_group_gid = getgrnam(SLURM_GROUP).gr_gid
+    return slurm_user_uid, slurm_group_gid
+
+
+class SlurmctldManagerError(BaseException):
     """Exception for use with SlurmctldManager."""
 
     def __init__(self, message):
@@ -46,285 +48,207 @@ def __init__(self, message):
         self.message = message
 
 
-SLURM_PPA_KEY: str = """
------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-----
-"""
-
-
-class Slurmctld:
-    """Facilitate slurmctld package lifecycle ops."""
-
-    _package_name: str = "slurmctld"
-    _keyring_path: Path = Path("/usr/share/keyrings/slurm-wlm.asc")
+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 slurmctld repo."""
+        """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) -> None:
-        """Install the slurmctld package using lib apt."""
-        # Install the key.
+    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(SLURM_PPA_KEY)
+        self._keyring_path.write_text(UBUNTU_HPC_PPA_KEY)
 
-        # Add the repo.
         repositories = apt.RepositoryMapping()
         repositories.add(self._repo())
 
-        # Install the slurmctld, slurm-client packages.
         try:
-            # Run `apt-get update`
             apt.update()
-            apt.add_package(["mailutils", "logrotate"])
-            apt.add_package([self._package_name, "slurm-client"])
+            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")
+            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: %s", e.message)
+            logger.error(f"Could not install '{self._package_name}'. Reason: {e.message}")
+
+        return package_installed
 
     def uninstall(self) -> None:
-        """Uninstall the slurmctld package using libapt."""
-        # Uninstall the slurmctld package.
+        """Uninstall the package using libapt."""
         if apt.remove_package(self._package_name):
-            logger.info(f"{self._package_name} removed from system.")
+            logger.info(f"'{self._package_name}' removed from system.")
         else:
-            logger.error(f"{self._package_name} not found on system")
+            logger.error(f"'{self._package_name}' not found on system.")
 
-        # Disable the slurmctld repo.
         repositories = apt.RepositoryMapping()
         repositories.disable(self._repo())
 
-        # Remove the key.
         if self._keyring_path.exists():
             self._keyring_path.unlink()
 
     def upgrade_to_latest(self) -> None:
-        """Upgrade slurmctld to latest."""
+        """Upgrade package to latest."""
         try:
-            slurmctld = apt.DebianPackage.from_system(self._package_name)
-            slurmctld.ensure(apt.PackageState.Latest)
-            logger.info("updated vim to version: %s", slurmctld.version.number)
+            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("a specified package not found in package cache or on system")
+            logger.error(f"'{self._package_name}' not found in package cache or on system.")
         except apt.PackageError as e:
-            logger.error("could not install package. Reason: %s", e.message)
+            logger.error(f"Could not install '{self._package_name}'. Reason: {e.message}")
 
     def version(self) -> str:
-        """Return the slurmctld version."""
+        """Return the package version."""
+        slurm_package_vers = ""
         try:
-            slurmctld = apt.DebianPackage.from_installed_package(self._package_name)
+            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 slurmctld.version.number
+            logger.error(f"'{self._package_name}' not found on system.")
+        return slurm_package_vers
 
 
-class SlurmctldManager(Object):
+class SlurmctldManager:
     """SlurmctldManager."""
 
-    _stored = StoredState()
-
-    def __init__(self, charm, component):
-        """Set the initial attribute values."""
-        super().__init__(charm, component)
-
-        self._charm = charm
-
-        self._slurm_conf_template_name = "slurm.conf.tmpl"
-        self._slurm_conf_path = self._slurm_conf_dir / "slurm.conf"
-
-        self._slurmd_log_file = self._slurm_log_dir / "slurmd.log"
-        self._slurmctld_log_file = self._slurm_log_dir / "slurmctld.log"
-
-        self._slurmd_pid_file = self._slurm_pid_dir / "slurmd.pid"
-        self._slurmctld_pid_file = self._slurm_pid_dir / "slurmctld.pid"
-
-        self._slurm_conf_template_location = TEMPLATE_DIR / self._slurm_conf_template_name
+    def __init__(self):
+        self._munge_package = CharmedHPCPackageLifecycleManager("munge")
+        self._slurmctld_package = CharmedHPCPackageLifecycleManager("slurmctld")
 
     def install(self) -> bool:
-        """Install slurmctld to the system.
-
-        Returns:
-            bool: True on success, False otherwise.
-        """
-        Slurmctld().install()
-
-        # create needed paths with correct permissions
-        self._setup_paths()
-
+        """Install slurmctld and munge to the system."""
+        if self._slurmctld_package.install() is not True:
+            return False
         systemd.service_stop("slurmctld")
-        systemd.service_stop("munge")
 
-        self._create_systemd_override_for_nofile()
-        systemd.daemon_reload()
+        if self._munge_package.install() is not True:
+            return False
+        systemd.service_stop("munge")
 
         return True
 
-    def _create_systemd_override_for_nofile(self) -> None:
-        """Create the override.conf file for slurm systemd service."""
-        systemd_override_dir = Path("/etc/systemd/system/slurmctld.service.d")
-        if not systemd_override_dir.exists():
-            systemd_override_dir.mkdir(exist_ok=True)
-
-        systemd_override_conf = systemd_override_dir / "override.conf"
-        systemd_override_conf_tmpl = TEMPLATE_DIR / "override.conf"
-
-        shutil.copyfile(systemd_override_conf_tmpl, systemd_override_conf)
-
-    def charm_maintained_slurm_conf_parameters(self) -> dict:
-        """Return slurm.conf parameters maintained my this charm."""
-        return {
-            "AuthAltParameters": f"jwt_key={self._jwt_rsa_key_file}",
-            "AuthAltTypes": "auth/jwt",
-            "AuthInfo": f"{self.munge_socket}",
-            "AuthType": "auth/munge",
-            "GresTypes": "gpu",
-            "HealthCheckInterval": "600",
-            "HealthCheckNodeState": "ANY,CYCLE",
-            "HealthCheckProgram": "/usr/sbin/omni-nhc-wrapper",
-            "MailProg": "/usr/bin/mail.mailutils",
-            "PluginDir": "/usr/lib/x86_64-linux-gnu/slurm-wlm",
-            "PlugStackConfig": f"{self._slurm_plugstack_conf}",
-            "ProctrackType": "proctrack/linuxproc" if _is_container() else "proctrack/cgroup",
-            "SelectType": "select/cons_tres",
-            "SlurmctldPort": "6817",
-            "SlurmdPort": "6818",
-            "StateSaveLocation": f"{self._slurm_state_dir}",
-            "SlurmdSpoolDir": "/var/spool/slurmd",
-            "SlurmctldParameters": "enable_configless",
-            "SlurmctldLogFile": f"{self._slurmctld_log_file}",
-            "SlurmdLogFile": f"{self._slurmd_log_file}",
-            "SlurmdPidFile": f"{self._slurmd_pid_file}",
-            "SlurmctldPidFile": f"{self._slurmctld_pid_file}",
-            "SlurmUser": self._slurm_user,
-            "SlurmdUser": self._slurmd_user,
-            "RebootProgram": '"/usr/sbin/reboot --reboot"',
-        }
+    def version(self) -> str:
+        """Return slurm version."""
+        return self._slurmctld_package.version()
+
+    def slurm_cmd(self, command, arg_string) -> None:
+        """Run a slurm command."""
+        try:
+            subprocess.call([f"{command}"] + arg_string.split())
+        except subprocess.CalledProcessError as e:
+            raise (e)
+            logger.error(f"Error running {command} - {e}")
 
     def write_slurm_conf(self, slurm_conf: dict) -> None:
         """Render the context to a template, adding in common configs."""
-        target = self._slurm_conf_path
-
-        if not isinstance(slurm_conf, dict):
-            raise TypeError("Incorrect type for config.")
-
-        if target.exists():
-            target.unlink()
+        slurm_user_uid, slurm_group_gid = _get_slurm_user_uid_and_slurm_group_gid()
 
+        target = Path("/etc/slurm/slurm.conf")
         target.write_text(slurm_conf_as_string(slurm_conf))
 
-        user_group = f"{self._slurm_user}:{self._slurm_group}"
-        subprocess.call(["chown", user_group, target])
+        os.chown(f"{target}", slurm_user_uid, slurm_group_gid)
 
-    def write_munge_key(self, munge_key) -> None:
+    def write_munge_key(self, munge_key: str) -> None:
         """Base64 decode and write the munge key."""
-        key = b64decode(munge_key.encode())
-        self._munge_key_path.write_bytes(key)
+        munge_user_uid = getpwnam("munge").pw_uid
+        munge_group_gid = getgrnam("munge").gr_gid
+
+        target = Path("/etc/munge/munge.key")
+        target.write_bytes(b64decode(munge_key.encode()))
+
+        target.chmod(0o600)
+        os.chown(f"{target}", munge_user_uid, munge_group_gid)
 
-    def write_jwt_rsa(self, jwt_rsa) -> None:
+    def write_jwt_rsa(self, jwt_rsa: str) -> None:
         """Write the jwt_rsa key."""
-        # Remove jwt_rsa if exists.
-        if self._jwt_rsa_key_file.exists():
-            self._jwt_rsa_key_file.write_bytes(os.urandom(2048))
-            self._jwt_rsa_key_file.unlink()
-
-        # Write the jwt_rsa key to the file and chmod 0600,
-        # chown to slurm_user.
-        self._jwt_rsa_key_file.write_text(jwt_rsa)
-        self._jwt_rsa_key_file.chmod(0o600)
-        subprocess.call(
-            [
-                "chown",
-                self._slurm_user,
-                str(self._jwt_rsa_key_file),
-            ]
-        )
+        slurm_user_uid, slurm_group_gid = _get_slurm_user_uid_and_slurm_group_gid()
+
+        target = Path("/var/spool/slurmctld/jwt_hs256.key")
+        target.write_text(jwt_rsa)
 
-    def write_cgroup_conf(self, content: str) -> None:
+        target.chmod(0o600)
+        os.chown(f"{target}", slurm_user_uid, slurm_group_gid)
+
+    def write_cgroup_conf(self, cgroup_conf: str) -> None:
         """Write the cgroup.conf file."""
-        cgroup_conf_path = self._slurm_conf_dir / "cgroup.conf"
-        if cgroup_conf_path.exists():
-            cgroup_conf_path.unlink()
-        cgroup_conf_path.write_text(content)
+        slurm_user_uid, slurm_group_gid = _get_slurm_user_uid_and_slurm_group_gid()
+
+        target = Path("/etc/slurm/cgroup.conf")
+        target.write_text(cgroup_conf)
+
+        target.chmod(0o600)
+        os.chown(f"{target}", slurm_user_uid, slurm_group_gid)
+
+    def generate_jwt_rsa(self) -> str:
+        """Generate the rsa key to encode the jwt with."""
+        return RSA.generate(2048).export_key("PEM").decode()
+
+    def generate_munge_key(self) -> str:
+        """Generate the munge.key."""
+        munge_key_as_string = ""
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            tmp_munge_key = Path(tmp_dir) / "munge.key"
+            subprocess.check_call(["mungekey", "-c", "-k", tmp_munge_key, "-b", "2048"])
+            munge_key_as_string = b64encode(tmp_munge_key.read_bytes()).decode()
+        return munge_key_as_string
 
     def get_munge_key(self) -> str:
         """Read the bytes, encode to base64, decode to a string, return."""
-        munge_key = self._munge_key_path.read_bytes()
+        munge_key = Path("/etc/munge/munge.key").read_bytes()
         return b64encode(munge_key).decode()
 
-    def start_munged(self) -> bool:
-        """Start munge.service."""
-        logger.debug("## Starting munge")
+    def stop_slurmctld(self) -> None:
+        """Stop slurmctld service."""
+        systemd.service_stop("slurmctld")
 
-        munge = self._munged_systemd_service
-        try:
-            subprocess.check_output(["systemctl", "start", munge])
-        except subprocess.CalledProcessError as e:
-            logger.error(f"## Error starting munge: {e}")
-            return False
+    def start_slurmctld(self) -> None:
+        """Start slurmctld service."""
+        systemd.service_start("slurmctld")
+
+    def stop_munged(self) -> None:
+        """Stop munge."""
+        systemd.service_stop("munge")
 
-        return self._is_active_munged()
+    def start_munged(self) -> bool:
+        """Start the munged process.
 
-    def _is_active_munged(self) -> bool:
-        munge = self._munged_systemd_service
+        Return True on success, and False otherwise.
+        """
+        logger.debug("Starting munge.")
         try:
-            status = subprocess.check_output(f"systemctl is-active {munge}", shell=True)
-            status_str = status.decode().strip()
-            if "active" in status_str:
-                logger.debug("#### Munge daemon active")
-                return True
-            else:
-                logger.error(f"## Munge not running: {status_str}")
-                return False
-        except subprocess.CalledProcessError as e:
-            logger.error(f"## Error querring munged - {e}")
+            systemd.service_start("munge")
+        # Ignore pyright error for is not a valid exception class, reportGeneralTypeIssues
+        except SlurmctldManagerError(
+            "Cannot start munge."
+        ) as e:  # pyright: ignore [reportGeneralTypeIssues]
+            logger.error(e)
             return False
+        return self.check_munged()
 
     def check_munged(self) -> bool:
         """Check if munge is working correctly."""
-        # check if systemd service unit is active
-        if not self._is_active_munged():
+        if not systemd.service_running("munge"):
             return False
 
+        output = ""
         # check if munge is working, i.e., can use the credentials correctly
         try:
             logger.debug("## Testing if munge is working correctly")
-            cmd = "munge -n"
             munge = subprocess.Popen(
-                shlex.split(cmd), stdout=subprocess.PIPE, stderr=subprocess.PIPE
+                ["munge", "-n"], stdout=subprocess.PIPE, stderr=subprocess.PIPE
             )
             if munge is not None:
                 unmunge = subprocess.Popen(
@@ -340,196 +264,7 @@ def check_munged(self) -> bool:
 
         return False
 
-    def version(self) -> str:
-        """Return slurm version."""
-        return Slurmctld().version()
-
-    def _setup_paths(self) -> None:
-        """Create needed paths with correct permissions."""
-        user = f"{self._slurm_user}:{self._slurm_group}"
-
-        all_paths = [
-            self._slurm_plugstack_dir,
-            self._slurm_conf_dir,
-            self._slurm_log_dir,
-            self._slurm_state_dir,
-        ]
-        for syspath in all_paths:
-            if not syspath.exists():
-                syspath.mkdir()
-            subprocess.call(["chown", "-R", user, syspath])
-
-    def restart_munged(self) -> bool:
-        """Restart the munged process.
-
-        Return True on success, and False otherwise.
-        """
-        try:
-            logger.debug("## Restarting munge")
-            systemd.service_restart("munge")
-        except SlurmctldException("Cannot restart munge.") as e:  # type: ignore [misc]
-            logger.error(e)
-            raise (e)
-            return False
-        return self.check_munged()
-
-    def restart_slurmctld(self) -> bool:
-        """Restart the slurmctld process.
-
-        Return True on success, and False otherwise.
-        """
-        try:
-            logger.debug("## Restarting slurmctld")
-            systemd.service_restart("slurmctld")
-        except SlurmctldException("Cannot restart slurmctld.") as e:  # type: ignore [misc]
-            logger.error(e)
-            return False
-        return True
-
-    def slurm_cmd(self, command, arg_string) -> None:
-        """Run a slurm command."""
-        try:
-            subprocess.call([f"{command}"] + arg_string.split())
-        except subprocess.CalledProcessError as e:
-            raise (e)
-            logger.error(f"Error running {command} - {e}")
-
-    def generate_jwt_rsa(self) -> str:
-        """Generate the rsa key to encode the jwt with."""
-        return RSA.generate(2048).export_key("PEM").decode()
-
-    @property
-    def slurm_component(self) -> str:
-        """Return the slurm component."""
-        return "slurmctld"
-
-    @property
-    def fluentbit_config_slurm(self) -> list:
-        """Return Fluentbit configuration parameters to forward Slurm logs."""
-        log_file = self._slurmctld_log_file
-
-        cfg = [
-            {
-                "input": [
-                    ("name", "tail"),
-                    ("path", log_file.as_posix()),
-                    ("path_key", "filename"),
-                    ("tag", "slurmctld"),
-                    ("parser", "slurm"),
-                ]
-            },
-            {
-                "parser": [
-                    ("name", "slurm"),
-                    ("format", "regex"),
-                    ("regex", r"^\[(?<time>[^\]]*)\] (?<log>.*)$"),
-                    ("time_key", "time"),
-                    ("time_format", "%Y-%m-%dT%H:%M:%S.%L"),
-                ]
-            },
-            {
-                "filter": [
-                    ("name", "record_modifier"),
-                    ("match", "slurmctld"),
-                    ("record", "hostname ${HOSTNAME}"),
-                    ("record", f"cluster-name {self._charm.cluster_name}"),
-                    ("record", "service slurmctld"),
-                ]
-            },
-        ]
-        return cfg
-
-    @property
-    def munge_socket(self) -> Path:
-        """Return the munge socket."""
-        return Path("/var/run/munge/munge.socket.2")
-
     @property
     def hostname(self) -> str:
         """Return the hostname."""
         return socket.gethostname().split(".")[0]
-
-    @property
-    def slurm_conf_path(self) -> Path:
-        """Return the slurm conf path."""
-        return self._slurm_conf_path
-
-    @property
-    def _slurm_bin_dir(self) -> Path:
-        """Return the directory where the slurm bins live."""
-        return Path("/usr/bin")
-
-    @property
-    def _slurm_conf_dir(self) -> Path:
-        """Return the directory for Slurm configuration files."""
-        return Path("/etc/slurm")
-
-    @property
-    def _slurm_state_dir(self) -> Path:
-        """Return the directory for slurmctld's state information."""
-        return Path("/var/spool/slurmctld")
-
-    @property
-    def _slurm_log_dir(self) -> Path:
-        """Return the directory for Slurm logs."""
-        return Path("/var/log/slurm")
-
-    @property
-    def _slurm_pid_dir(self) -> Path:
-        """Return the directory for Slurm PID file."""
-        return Path("/var/run/")
-
-    @property
-    def _jwt_rsa_key_file(self) -> Path:
-        """Return the jwt rsa key file path."""
-        return self._slurm_state_dir / "jwt_hs256.key"
-
-    @property
-    def _munge_key_path(self) -> Path:
-        """Return the full path to the munge key."""
-        return Path("/etc/munge/munge.key")
-
-    @property
-    def _munged_systemd_service(self) -> str:
-        """Return the name of the Munge Systemd unit file."""
-        return "munge.service"
-
-    @property
-    def _munge_user(self) -> str:
-        """Return the user for munge daemon."""
-        return "munge"
-
-    @property
-    def _munge_group(self) -> str:
-        """Return the group for munge daemon."""
-        return "munge"
-
-    @property
-    def _slurm_plugstack_dir(self) -> Path:
-        """Return the directory to the SPANK plugins."""
-        return Path("/etc/slurm/plugstack.conf.d")
-
-    @property
-    def _slurm_plugstack_conf(self) -> Path:
-        """Return the full path to the root plugstack configuration file."""
-        return self._slurm_conf_dir / "plugstack.conf"
-
-    @property
-    def _slurm_user(self) -> str:
-        """Return the slurm user."""
-        return "slurm"
-
-    @property
-    def _slurm_group(self) -> str:
-        """Return the slurm group."""
-        return "slurm"
-
-    @property
-    def _slurm_group_id(self) -> str:
-        """Return the slurm group ID."""
-        return "64030"
-
-    @property
-    def _slurmd_user(self) -> str:
-        """Return the slurmd user."""
-        return "root"
diff --git a/tox.ini b/tox.ini
index ed98596..a071fe3 100644
--- a/tox.ini
+++ b/tox.ini
@@ -31,15 +31,15 @@ deps =
     ruff
 commands =
     black {[vars]all_path}
-    ruff --fix {[vars]all_path}
+    ruff check {[vars]all_path} --fix
 
 [testenv:type]
-description = Type checking with mypy.
+description = Type checking with pyright.
 deps =
-    mypy
+    pyright
     -r{toxinidir}/requirements.txt
 commands =
-    mypy {[vars]src_path}
+    pyright {[vars]src_path}
 
 [testenv:lint]
 description = Check code against coding style standards