Merge ~ballot/charm-k8s-mm-pd-bot/+git/charm-k8s-mm-pd-bot:reboot into charm-k8s-mm-pd-bot:master

[Benjamin Allot]

Unmerged commits

c8449a3... by Benjamin Allot on 2023-01-31

Huge revamp using old code and new ones

* Convert to pebble
* Use https://github.com/canonical/nginx-ingress-integrator-operator
* Revamp of the docs (but not quite finished)
* Tests need to be fixed
* Using charmcraft and resources ibstead of an image path

diff --git a/Makefile b/Makefile
index 0e38a25..6e00e0b 100644
--- a/Makefile
+++ b/Makefile
@@ -8,7 +8,7 @@ TESTS := $(shell find $(PROJECTPATH)/tests -name "*.py" -o -name "requirements.t
 
 # Rebuild the charm each time we have an update in the sources or tests
 $(CHARM_FILE): $(SOURCES) $(TESTS) $(PROJECTPATH)/requirements.txt
-	charmcraft build -f $(PROJECTPATH)
+	charmcraft pack -v -p $(PROJECTPATH)
 
 all: test
 
@@ -25,6 +25,10 @@ unittest: $(CHARM_FILE)
 
 test: lint unittest
 
+build:
+	@rm -f $(CHARM_FILE)
+	charmcraft pack -v -p $(PROJECTPATH)
+
 clean:
 	@echo "Cleaning files"
 	@find $(PROJECTPATH) -name "*.pyc" -exec rm -f {} +
@@ -32,4 +36,4 @@ clean:
 	@rm -f $(CHARM_FILE)
 	@rm -rf $(PROJECTPATH)/{build,charm} # Delete the build directory
 
-.PHONY: all lint test unittest clean
+.PHONY: all lint test unittest clean build
diff --git a/README.md b/README.md
index a62e135..d8e5ac0 100644
--- a/README.md
+++ b/README.md
@@ -2,30 +2,39 @@
 
 A juju charm deploying Mattermost PagerDuty Bot.
 
+## Prerequisites
+
+To deploy and use this charm you will need:
+
+ * [Juju and a kubernetes cluster](https://juju.is/docs/olm/installing-juju)
+ * [A PagerDuty account and a General access PagerDuty token](https://support.pagerduty.com/docs/generating-api-keys)
+ * [A Bot account on a Mattermost server](https://docs.mattermost.com/developer/bot-accounts.html)
+ * A kubernetes deployment with an ingress activated. [Microk8s is recommended for a test environment](https://microk8s.io/docs/addon-ingress)
+
 ## Overview
 
-This is a k8s workload charm and can only be deployed to to a Juju k8s
-cloud, attached to a controller using `juju add-k8s`.
+This charm will deploy a daemon interacting with PagerDuty and Mattermost.
+
+Alerts in PagerDuty will be displayed on a Mattermost channel and you will be able to interact with those alerts through the chat.
+
+You can quickly acknowledge, resolve or reassign incidents directly from Mattermost.
 
-A valid configuration file will be needed. See [the example](examples/bot.cfg)
+The Mattermost PagerDuty Bot uses a configuration file. See [the example](https://git.launchpad.net/charm-k8s-mm-pd-bot/tree/examples/bot.cfg).
 
 ## Getting Started
 
-For details on the configuration file, [see here](https://charmhub.io/mm-pd-bot-k8s/docs/configuration).
-To deploy into a juju k8s model, run:
+For details on the configuration file, [see here](https://charmhub.io/mm-pd-bot/docs/configuration).
+To deploy into a juju kubernetes model, run:
 
 ```
-juju deploy mm-pd-bot-k8s \
-  --config image_path=rocks.example.com/mm-pd-bot:devel \
-  --config mm_pd_bot_cfg="$(cat bot.cfg)" \ # Don't forget the double quotes here
-  --config juju-external-hostname=mm-pd-bot.local \
-  --config kubernetes-ingress-allow-http=true \
+juju deploy ch:mm-pd-bot \
+  --config mm_pd_bot_cfg=@bot.cfg \
+  --config external_hostname=mm-pd-bot.mydomain.com \
   mm-pd-bot
-juju wait
-juju status
-juju expose mm-pd-bot
+juju deploy nginx-ingress-integrator
+juju relate mm-pd-bot nginx-ingress-integrator
 ```
 
 ---
 
-For more details, [see here](https://charmhub.io/mm-pd-bot-k8s/docs)
+For more details, [see here](https://charmhub.io/mm-pd-bot/docs)
diff --git a/actions.yaml b/actions.yaml
new file mode 100644
index 0000000..2d869d9
--- /dev/null
+++ b/actions.yaml
@@ -0,0 +1,18 @@
+---
+set-pagerduty-credentials:
+  description: Set the general access PagerDuty token
+  params:
+    account:
+      type: string
+      description: The PagerDuty account
+    token:
+      type: string
+      description: The PagerDuty token
+  required: [account, token]
+set-mattermost-bot-token:
+  description: Set the Mattermost Bot account token
+  params:
+    token:
+      type: string
+      description: The Mattermost bot token
+  required: [token]
diff --git a/charmcraft.yaml b/charmcraft.yaml
new file mode 100644
index 0000000..e72c4e8
--- /dev/null
+++ b/charmcraft.yaml
@@ -0,0 +1,10 @@
+---
+type: "charm"
+
+bases:
+  - build-on:
+    - name: ubuntu
+      channel: "20.04"
+    run-on:
+    - name: ubuntu
+      channel: "20.04"
diff --git a/config.yaml b/config.yaml
index 1e1e3e8..95e6a90 100644
--- a/config.yaml
+++ b/config.yaml
@@ -1,27 +1,15 @@
 options:
-  image_path:
+  mm_pd_bot_cfg:
     type: string
     description: |
-      The location of the image to use, e.g. "registry.example.com/mm-pd-bot:v1".
+      The whole configuration file of the bot is passed as content to this setting.
 
       This setting is required.
     default: ''
-  image_username:
-    type: string
-    description: |
-      The username for accessing the registry specified in image_path.
-    default: ''
-  image_password:
-    type: string
-    description: |
-      The password associated with image_username for accessing the registry specified in image_path.
-    default: ''
-  mm_pd_bot_cfg:
+  external_hostname:
     type: string
     description: |
-      The whole configuration file of the bot is passed as content to this setting.
-
-      This setting is required.
+      The FQDN used to reach the bot via the webhooks.
     default: ''
   tls_secret_name:
     type: string
@@ -30,10 +18,3 @@ options:
 
       This setting is ignored unless juju-external-hostname begins with "https://".
     default: ''
-  ingress_whitelist_source_range:
-    type: string
-    description: |
-      A comma-separated list of CIDRs to store in the ingress.kubernetes.io/whitelist-source-range annotation.
-
-      This can be used to lock down access to Mattermost PagerDuty Bot based on source IP address.
-    default: ''
diff --git a/lib/charms/nginx_ingress_integrator/v0/ingress.py b/lib/charms/nginx_ingress_integrator/v0/ingress.py
new file mode 100644
index 0000000..4ed6345
--- /dev/null
+++ b/lib/charms/nginx_ingress_integrator/v0/ingress.py
@@ -0,0 +1,398 @@
+# Copyright 2023 Canonical Ltd.
+# Licensed under the Apache2.0, see LICENCE file in charm source for details.
+"""Library for the ingress relation.
+
+This library contains the Requires and Provides classes for handling
+the ingress interface.
+
+Import `IngressRequires` in your charm, with two required options:
+- "self" (the charm itself)
+- config_dict
+
+`config_dict` accepts the following keys:
+- additional-hostnames
+- limit-rps
+- limit-whitelist
+- max-body-size
+- owasp-modsecurity-crs
+- owasp-modsecurity-custom-rules
+- path-routes
+- retry-errors
+- rewrite-enabled
+- rewrite-target
+- service-hostname (required)
+- service-name (required)
+- service-namespace
+- service-port (required)
+- session-cookie-max-age
+- tls-secret-name
+
+See [the config section](https://charmhub.io/nginx-ingress-integrator/configure) for descriptions
+of each, along with the required type.
+
+As an example, add the following to `src/charm.py`:
+```
+from charms.nginx_ingress_integrator.v0.ingress import IngressRequires
+
+# In your charm's `__init__` method.
+self.ingress = IngressRequires(self, {
+        "service-hostname": self.config["external_hostname"],
+        "service-name": self.app.name,
+        "service-port": 80,
+    }
+)
+
+# In your charm's `config-changed` handler.
+self.ingress.update_config({"service-hostname": self.config["external_hostname"]})
+```
+And then add the following to `metadata.yaml`:
+```
+requires:
+  ingress:
+    interface: ingress
+```
+You _must_ register the IngressRequires class as part of the `__init__` method
+rather than, for instance, a config-changed event handler, for the relation
+changed event to be properly handled.
+"""
+
+import copy
+import logging
+from typing import Dict
+
+from ops.charm import CharmEvents, RelationBrokenEvent, RelationChangedEvent
+from ops.framework import EventBase, EventSource, Object
+from ops.model import BlockedStatus
+
+INGRESS_RELATION_NAME = "ingress"
+INGRESS_PROXY_RELATION_NAME = "ingress-proxy"
+
+# The unique Charmhub library identifier, never change it
+LIBID = "db0af4367506491c91663468fb5caa4c"
+
+# 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 = 14
+
+LOGGER = logging.getLogger(__name__)
+
+REQUIRED_INGRESS_RELATION_FIELDS = {"service-hostname", "service-name", "service-port"}
+
+OPTIONAL_INGRESS_RELATION_FIELDS = {
+    "additional-hostnames",
+    "limit-rps",
+    "limit-whitelist",
+    "max-body-size",
+    "owasp-modsecurity-crs",
+    "owasp-modsecurity-custom-rules",
+    "path-routes",
+    "retry-errors",
+    "rewrite-target",
+    "rewrite-enabled",
+    "service-namespace",
+    "session-cookie-max-age",
+    "tls-secret-name",
+}
+
+RELATION_INTERFACES_MAPPINGS = {
+    "service-hostname": "host",
+    "service-name": "name",
+    "service-namespace": "model",
+    "service-port": "port",
+}
+RELATION_INTERFACES_MAPPINGS_VALUES = {v for v in RELATION_INTERFACES_MAPPINGS.values()}
+
+
+class IngressAvailableEvent(EventBase):
+    """IngressAvailableEvent custom event.
+
+    This event indicates the Ingress provider is available.
+    """
+
+
+class IngressProxyAvailableEvent(EventBase):
+    """IngressProxyAvailableEvent custom event.
+
+    This event indicates the IngressProxy provider is available.
+    """
+
+
+class IngressBrokenEvent(RelationBrokenEvent):
+    """IngressBrokenEvent custom event.
+
+    This event indicates the Ingress provider is broken.
+    """
+
+
+class IngressCharmEvents(CharmEvents):
+    """Custom charm events.
+
+    Attrs:
+        ingress_available: Event to indicate that Ingress is available.
+        ingress_proxy_available: Event to indicate that IngressProxy is available.
+        ingress_broken: Event to indicate that Ingress is broken.
+    """
+
+    ingress_available = EventSource(IngressAvailableEvent)
+    ingress_proxy_available = EventSource(IngressProxyAvailableEvent)
+    ingress_broken = EventSource(IngressBrokenEvent)
+
+
+class IngressRequires(Object):
+    """This class defines the functionality for the 'requires' side of the 'ingress' relation.
+
+    Hook events observed:
+        - relation-changed
+
+    Attrs:
+        model: Juju model where the charm is deployed.
+        config_dict: Contains all the configuration options for Ingress.
+    """
+
+    def __init__(self, charm, config_dict):
+        """Init function for the IngressRequires class.
+
+        Args:
+            charm: The charm that requires the ingress relation.
+            config_dict: Contains all the configuration options for Ingress.
+        """
+        super().__init__(charm, INGRESS_RELATION_NAME)
+
+        self.framework.observe(
+            charm.on[INGRESS_RELATION_NAME].relation_changed, self._on_relation_changed
+        )
+
+        # Set default values.
+        default_relation_fields = {
+            "service-namespace": self.model.name,
+        }
+        config_dict.update(
+            (key, value)
+            for key, value in default_relation_fields.items()
+            if key not in config_dict or not config_dict[key]
+        )
+
+        self.config_dict = self._convert_to_relation_interface(config_dict)
+
+    @staticmethod
+    def _convert_to_relation_interface(config_dict: Dict) -> Dict:
+        """Create a new relation dict that conforms with charm-relation-interfaces.
+
+        Args:
+            config_dict: Ingress configuration that doesn't conform with charm-relation-interfaces.
+
+        Returns:
+            The Ingress configuration conforming with charm-relation-interfaces.
+        """
+        config_dict = copy.copy(config_dict)
+        config_dict.update(
+            (key, config_dict[old_key])
+            for old_key, key in RELATION_INTERFACES_MAPPINGS.items()
+            if old_key in config_dict and config_dict[old_key]
+        )
+        return config_dict
+
+    def _config_dict_errors(self, config_dict: Dict, update_only: bool = False) -> bool:
+        """Check our config dict for errors.
+
+        Args:
+            config_dict: Contains all the configuration options for Ingress.
+            update_only: If the charm needs to update only existing keys.
+
+        Returns:
+            If we need to update the config dict ot not.
+        """
+        blocked_message = "Error in ingress relation, check `juju debug-log`"
+        unknown = [
+            config_key
+            for config_key in config_dict
+            if config_key
+            not in REQUIRED_INGRESS_RELATION_FIELDS
+            | OPTIONAL_INGRESS_RELATION_FIELDS
+            | RELATION_INTERFACES_MAPPINGS_VALUES
+        ]
+        if unknown:
+            LOGGER.error(
+                "Ingress relation error, unknown key(s) in config dictionary found: %s",
+                ", ".join(unknown),
+            )
+            self.model.unit.status = BlockedStatus(blocked_message)
+            return True
+        if not update_only:
+            missing = tuple(
+                config_key
+                for config_key in REQUIRED_INGRESS_RELATION_FIELDS
+                if config_key not in self.config_dict
+            )
+            if missing:
+                LOGGER.error(
+                    "Ingress relation error, missing required key(s) in config dictionary: %s",
+                    ", ".join(sorted(missing)),
+                )
+                self.model.unit.status = BlockedStatus(blocked_message)
+                return True
+        return False
+
+    def _on_relation_changed(self, event: RelationChangedEvent) -> None:
+        """Handle the relation-changed event.
+
+        Args:
+            event: Event triggering the relation-changed hook for the relation.
+        """
+        # `self.unit` isn't available here, so use `self.model.unit`.
+        if self.model.unit.is_leader():
+            if self._config_dict_errors(config_dict=self.config_dict):
+                return
+            event.relation.data[self.model.app].update(
+                (key, str(self.config_dict[key])) for key in self.config_dict
+            )
+
+    def update_config(self, config_dict: Dict) -> None:
+        """Allow for updates to relation.
+
+        Args:
+            config_dict: Contains all the configuration options for Ingress.
+
+        Attrs:
+            config_dict: Contains all the configuration options for Ingress.
+        """
+        if self.model.unit.is_leader():
+            self.config_dict = self._convert_to_relation_interface(config_dict)
+            if self._config_dict_errors(self.config_dict, update_only=True):
+                return
+            relation = self.model.get_relation(INGRESS_RELATION_NAME)
+            if relation:
+                for key in self.config_dict:
+                    relation.data[self.model.app][key] = str(self.config_dict[key])
+
+
+class IngressBaseProvides(Object):
+    """Parent class for IngressProvides and IngressProxyProvides.
+
+    Attrs:
+        model: Juju model where the charm is deployed.
+    """
+
+    def _on_relation_changed(self, event: RelationChangedEvent) -> None:
+        """Handle a change to the ingress/ingress-proxy relation.
+
+        Confirm we have the fields we expect to receive.
+
+        Args:
+            event: Event triggering the relation-changed hook for the relation.
+        """
+        # `self.unit` isn't available here, so use `self.model.unit`.
+        if not self.model.unit.is_leader():
+            return
+
+        relation_name = event.relation.name
+
+        if not event.relation.data[event.app]:
+            LOGGER.info(
+                "%s hasn't finished configuring, waiting until relation is changed again.",
+                relation_name,
+            )
+            return
+
+        ingress_data = {
+            field: event.relation.data[event.app].get(field)
+            for field in REQUIRED_INGRESS_RELATION_FIELDS | OPTIONAL_INGRESS_RELATION_FIELDS
+        }
+
+        missing_fields = sorted(
+            field for field in REQUIRED_INGRESS_RELATION_FIELDS if ingress_data.get(field) is None
+        )
+
+        if missing_fields:
+            LOGGER.warning(
+                "Missing required data fields for %s relation: %s",
+                relation_name,
+                ", ".join(missing_fields),
+            )
+            self.model.unit.status = BlockedStatus(
+                f"Missing fields for {relation_name}: {', '.join(missing_fields)}"
+            )
+
+        if relation_name == INGRESS_RELATION_NAME:
+            # Conform to charm-relation-interfaces.
+            if "name" in ingress_data and "port" in ingress_data:
+                name = ingress_data["name"]
+                port = ingress_data["port"]
+            else:
+                name = ingress_data["service-name"]
+                port = ingress_data["service-port"]
+            event.relation.data[self.model.app]["url"] = f"http://{name}:{port}/"
+
+            # Create an event that our charm can use to decide it's okay to
+            # configure the ingress.
+            self.charm.on.ingress_available.emit()
+        elif relation_name == INGRESS_PROXY_RELATION_NAME:
+            self.charm.on.ingress_proxy_available.emit()
+
+
+class IngressProvides(IngressBaseProvides):
+    """Class containing the functionality for the 'provides' side of the 'ingress' relation.
+
+    Attrs:
+        charm: The charm that provides the ingress relation.
+
+    Hook events observed:
+        - relation-changed
+    """
+
+    def __init__(self, charm):
+        """Init function for the IngressProvides class.
+
+        Args:
+            charm: The charm that provides the ingress relation.
+        """
+        super().__init__(charm, INGRESS_RELATION_NAME)
+        # Observe the relation-changed hook event and bind
+        # self.on_relation_changed() to handle the event.
+        self.framework.observe(
+            charm.on[INGRESS_RELATION_NAME].relation_changed, self._on_relation_changed
+        )
+        self.framework.observe(
+            charm.on[INGRESS_RELATION_NAME].relation_broken, self._on_relation_broken
+        )
+        self.charm = charm
+
+    def _on_relation_broken(self, event: RelationBrokenEvent) -> None:
+        """Handle a relation-broken event in the ingress relation.
+
+        Args:
+            event: Event triggering the relation-broken hook for the relation.
+        """
+        if not self.model.unit.is_leader():
+            return
+
+        # Create an event that our charm can use to remove the ingress resource.
+        self.charm.on.ingress_broken.emit(event.relation)
+
+
+class IngressProxyProvides(IngressBaseProvides):
+    """Class containing the functionality for the 'provides' side of the 'ingress-proxy' relation.
+
+    Attrs:
+        charm: The charm that provides the ingress-proxy relation.
+
+    Hook events observed:
+        - relation-changed
+    """
+
+    def __init__(self, charm):
+        """Init function for the IngressProxyProvides class.
+
+        Args:
+            charm: The charm that provides the ingress-proxy relation.
+        """
+        super().__init__(charm, INGRESS_PROXY_RELATION_NAME)
+        # Observe the relation-changed hook event and bind
+        # self.on_relation_changed() to handle the event.
+        self.framework.observe(
+            charm.on[INGRESS_PROXY_RELATION_NAME].relation_changed, self._on_relation_changed
+        )
+        self.charm = charm
diff --git a/metadata.yaml b/metadata.yaml
index 427f0c7..603c650 100644
--- a/metadata.yaml
+++ b/metadata.yaml
@@ -1,14 +1,33 @@
-name: mm-pd-bot-k8s
+name: mm-pd-bot
+
 display-name: Mattermost PagerDuty Bot
-docs: https://discourse.charmhub.io/t/mattermost-pagerduty-bot-docs-index/4596
+
+docs: https://charmhub.io/mm-pd-bot
+
 summary: MatterMost Pagerduty Bot charm
+
 maintainers:
   - launchpad.net/~mm-pd-bot-charmers
+
 description: |
   A charm which deploys Mattermost Pagerduty Bot on kubernetes.
   Mattermost is a flexible, open source messaging platform that enables
   secure team collaboration.
   This bot manages incidents on PagerDuty through commands sent to a MatterMost channel
-min-juju-version: 2.8.0  # charm storage in state
-series:
-  - kubernetes
+
+requires:
+  ingress:
+    interface: ingress
+
+assumes:
+  - juju < 3.0
+  - k8s-api
+
+containers:
+  mm-pd-bot:
+    resource: mm-pd-bot-image
+
+resources:
+  mm-pd-bot-image:
+    type: oci-image
+    description: Docker image for Mattermost PagerDuty Bot to run
diff --git a/requirements.txt b/requirements.txt
index eaae2b5..b8a4bc5 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1 +1 @@
-ops>=0.8
+ops>=1.5.0
diff --git a/src/charm.py b/src/charm.py
index 7b2807f..9d45a93 100755
--- a/src/charm.py
+++ b/src/charm.py
@@ -3,10 +3,12 @@
 # Copyright 2020 Canonical Ltd.
 # Licensed under the GPLv3, see LICENCE file for details.
 
+import collections
 import configparser
 import logging
-from urllib.parse import urlparse
+import io
 
+from charms.nginx_ingress_integrator.v0.ingress import IngressRequires
 import ops
 from ops.charm import CharmBase
 from ops.main import main
@@ -14,15 +16,16 @@ from ops.model import (
     ActiveStatus,
     BlockedStatus,
 )
+from ops.pebble import ConnectionError, PathError, ServiceStatus
 
 
-logger = logging.getLogger()
+logger = logging.getLogger(__name__)
 
-REQUIRED_JUJU_SETTINGS = ["image_path", "mm_pd_bot_cfg"]
+REQUIRED_JUJU_SETTINGS = ["external_hostname", "mm_pd_bot_cfg"]
 REQUIRED_CFG_SETTINGS = {
-    "PagerDuty": ["account", "api-token", "private-channel", "public-channel"],
+    "PagerDuty": ["private-channel", "public-channel"],
     "Prometheus": ["max_cache_size"],
-    "httpd": ["hostname", "listen-ip", "listen-port", "magic-uuid"],
+    "httpd": ["listen-ip", "listen-port", "magic-uuid"],
     "MattermostBot": ["bot_url", "bot_team"],
     # Those sections can be empty
     "nickname to email": [],
@@ -30,20 +33,219 @@ REQUIRED_CFG_SETTINGS = {
     "PagerDuty service to Mattermost Channel": [],
 }
 BOT_CFG_SECTION = "MattermostBot"
+# TODO: get it from the metadata.yaml dynamically
+CONTAINER_NAME = "mm-pd-bot"
 
 
 class MmPdBotK8sCharmConfigError(Exception):
     """Exception when configuration is bad."""
 
 
+class MmPdBotPebbleLayerError(Exception):
+    """Exception when configuration is bad."""
+
+
 class MmPdBotK8sCharm(CharmBase):
     def __init__(self, *args) -> None:
         super().__init__(*args)
 
-        self.framework.observe(self.on.start, self.configure_pod)
-        self.framework.observe(self.on.config_changed, self.configure_pod)
-        self.framework.observe(self.on.leader_elected, self.configure_pod)
-        self.framework.observe(self.on.upgrade_charm, self.configure_pod)
+        # PEBBLE: on.start probably useless
+        # Need the following actions
+        # 1. Validate configuration (everything except secrets comapred to before)
+        # 2. Check ingress availability. block on lack of relation
+        # 3. Check secrets availability. Block on lack of tokens for PD and MM
+        # 4. 3. must be set via an action in a second time, for now still in the conf file.
+        # 5. Application leader is relevant for any action towards MM/PD. No need to do every actions several times.
+        # 6. Upgrade-charm does not call config-changed so it needs to be handled
+
+        # self.framework.observe(self.on.start, self.configure_pod)
+
+        # No need for install as config-changed is called right after
+        # https://juju.is/docs/sdk/events
+        self.framework.observe(self.on.config_changed, self.configure_workload)
+        # The name of the event is the key in metadata.yaml for "containers" + _pebble_ready
+        # See https://ops.readthedocs.io/en/latest/#ops.charm.PebbleReadyEvent
+        self.framework.observe(self.on.mm_pd_bot_pebble_ready, self._on_pebble_ready)
+        self.framework.observe(self.on.ingress_relation_changed, self._configure_ingress)
+        self.framework.observe(self.on.set_mattermost_bot_token_action, self._set_mm_bot_token)
+        self.framework.observe(self.on.set_pagerduty_credentials_action, self._set_pagerduty_credentials)
+
+        self.ingress = IngressRequires(self, {})
+        self.bot_config = self._load_mm_pd_bot_configuration(self.config["mm_pd_bot_cfg"])
+
+    def _configure_ingress(self, event: ops.charm.EventBase) -> None:
+        """Configure the ingress relation."""
+
+        if not self._check_charm_config():
+            logger.info("Configuration is not ready yet. Deferring ingress configuration.")
+            event.defer()
+            return
+        container_port = self.bot_config.getint("httpd", "listen-port")
+        # magic_uuid = self.bot_config.get("httpd", "magic-uuid")
+        ingress_data = {
+            "service-hostname": self.config["external_hostname"],
+            "service-name": self.app.name,
+            "service-port": container_port,
+            # Default is empty string and the ingress won't configure it if that's the case
+            # TODO: Check how a switch from 443 to 80 behave on ingress side
+            "tls-secret-name": self.config["tls_secret_name"],
+        }
+
+        logger.debug("Ingress relation data: %s", ingress_data)
+        self.ingress.update_config(ingress_data)
+
+    def _get_pebble_layers(self) -> dict:
+        """Configure pebble layers.
+
+        :returns: a dict representing the various pebble layers.
+        """
+
+        mm_pd_bot_layers = {
+            "summary": "Pebble layers for Mattermost PagerDuty Bot",
+            "description": "All pebble layers for the various mm-pd-bot workload",
+            "services": {
+                "mm-pd-bot": {
+                    "override": "replace",
+                    "summary": "mm-pd-bot",
+                    "command": "bash -c '/app/bot.py --log-level debug /app/bot.cfg &>/proc/1/fd/1'",
+                    "startup": "enabled",
+                }
+            },
+        }
+
+        return mm_pd_bot_layers
+
+    def _set_pagerduty_credentials(self, event: ops.charm.ActionEvent):
+        """Set the PagerDuty token in pebble layer
+
+        :param event: ActionEvent
+        """
+        if not self._is_pebble_ready():
+            logger.info("Pebble is not ready.")
+            event.defer()
+            return
+        account: str = event.params.get("account")
+        token: str = event.params.get("token")
+        msg: str = "Setting PagerDuty credentials"
+        logger.debug(msg)
+        event.log(msg)
+        self.bot_config["PagerDuty"]["account"] = account
+        self.bot_config["PagerDuty"]["api-token"] = token
+        self.configure_workload(event)
+
+    def _set_mm_bot_token(self, event: ops.charm.ActionEvent):
+        """Set the Mattermost Bot token in pebble layer
+
+        :param event: ActionEvent
+        """
+        if not self._is_pebble_ready():
+            logger.info("Pebble is not ready.")
+            event.defer()
+            return
+        token: str = event.params.get("token")
+        msg: str = "Setting Mattermost Bot token"
+        logger.debug(msg)
+        event.log(msg)
+        self.bot_config[BOT_CFG_SECTION]["bot_token"] = token
+        self.configure_workload(event)
+
+    def _load_current_config(self):
+        """Load the current mm-pd-bot configuration."""
+        try:
+            deployed_config = self.container.pull("/app/bot.cfg").read()
+            self.current_config = self._load_mm_pd_bot_configuration(deployed_config)
+        except PathError:
+            logger.debug("Current configuration /app/bot.cfg does not exist.")
+            self.current_config = None
+
+    def _on_pebble_ready(self, event: ops.charm.EventBase) -> None:
+        """Handle PebbleReady event
+
+        :param event: Event fired.
+        """
+        if not self._is_pebble_ready():
+            logger.error("PebbleReady received but pebble is not ready.")
+            event.defer()
+            return
+        logger.info("Pebble is ready.")
+        self.configure_workload(event)
+
+    def _is_pebble_ready(self) -> bool:
+        """Check that Pebble is ready.
+
+        Try to get a plan from Pebble. If that fails, it will throw an exception and we will know it was not ready.
+        :returns: True if Pebble is ready. False otherwise.
+        """
+        logger.debug("Checking Pebble status.")
+        self.container = self.unit.get_container(CONTAINER_NAME)
+        try:
+            self.container.get_plan().to_dict().get("services", {})
+            logger.debug("Pebble is ready.")
+            logger.debug("Load current configuration if it exists")
+            self._load_current_config()
+        except ConnectionError as exc:
+            logger.info("Pebble is not ready yet.")
+            logger.debug(str(exc))
+            return False
+        return True
+
+    def configure_workload(self, event: ops.charm.EventBase) -> None:
+        """Configure the workload container.
+
+        Configure the workload container and the application once pebble is started and ready.
+
+        :param event: Event fired.
+        """
+
+        if not self._is_pebble_ready():
+            logger.info("Aborting workload container configuration.")
+            if event:
+                event.defer()
+            return
+
+        if not self._check_charm_config():
+            logger.info("Charm configuration is not ready.")
+            return
+
+        mm_pd_bot_layers = self._get_pebble_layers()
+
+        # Ensure the ingress relation has the external hostname.
+        self._configure_ingress(event)
+
+        restart = False
+        if self.bot_config != self.current_config:
+            logger.info("Configuration needs to be updated. Restarting mm-pd-bot...")
+            with io.StringIO() as current, io.StringIO() as new:
+                if self.current_config:
+                    self.current_config.write(current)
+                    current.seek(0)
+                    logger.debug("Current config : %s", current.read())
+                self.bot_config.write(new)
+                new.seek(0)
+                logger.debug("New config : %s", new.read())
+            restart = True
+
+        # Compare the current plan with the one we generated
+        services = self.container.get_plan().to_dict().get("services", {})
+        if services != mm_pd_bot_layers["services"]:
+            logger.info("Adding pebble layer: %s", mm_pd_bot_layers)
+            self.container.add_layer("mm_pd_bot", mm_pd_bot_layers, combine=True)
+
+        if restart:
+            # TODO Figure out the UID and lessen the permission or inject environment variables)
+            with io.StringIO() as buffer:
+                logger.debug("Pushing file bot.cfg to /app/bot.cfg")
+                self.bot_config.write(buffer)
+                buffer.seek(0)
+                self.container.push(path="/app/bot.cfg", permissions=0o644, source=buffer.read())
+            status = self.container.get_service(CONTAINER_NAME)
+            if status.current == ServiceStatus.ACTIVE:
+                logger.debug("Pebble service %s is active. Stopping it", CONTAINER_NAME)
+                self.container.stop(CONTAINER_NAME)
+            logger.debug("Starting pebble service %s", CONTAINER_NAME)
+            self.container.start(CONTAINER_NAME)
+
+        self.unit.status = ActiveStatus()
 
     def _validate_bot_creds(self) -> None:
         """Validate the authentication method input for the bot.
@@ -52,15 +254,38 @@ class MmPdBotK8sCharm(CharmBase):
         bot_password.
         """
         bot_token = self.bot_config.get(BOT_CFG_SECTION, "bot_token", fallback=None)
-        bot_login = self.bot_config.get(BOT_CFG_SECTION, "bot_login", fallback=None)
-        bot_password = self.bot_config.get(BOT_CFG_SECTION, "bot_password", fallback=None)
-
-        if not bot_token and (not bot_login or not bot_password):
-            err_msg = "bot_token or bot_login/bot_password in {0} section required".format(BOT_CFG_SECTION)
+        pd_account = self.bot_config.get("PagerDuty", "account", fallback=None)
+        pd_token = self.bot_config.get("PagerDuty", "api-token", fallback=None)
+        try:
+            cur_bot_token = self.current_config.get(BOT_CFG_SECTION, "bot_token", fallback=None)
+            cur_pd_account = self.current_config.get("PagerDuty", "account", fallback=None)
+            cur_pd_token = self.current_config.get("PagerDuty", "api-token", fallback=None)
+        except AttributeError:  # self.current_config is None
+            cur_bot_token = None
+            cur_pd_account = None
+            cur_pd_token = None
+
+        # Load the values present in current configuration if not specified.
+        # This way we retrieve previously set values and overwrite when using an action
+        if not bot_token and cur_bot_token:
+            logger.debug("Current secret Mattermost bot_token already set")
+            self.bot_config[BOT_CFG_SECTION]["bot_token"] = cur_bot_token
+            bot_token = cur_bot_token
+        if not pd_account and cur_pd_account:
+            logger.debug("Current secret PagerDuty account already set")
+            self.bot_config["PagerDuty"]["account"] = cur_pd_account
+            pd_account = cur_pd_account
+        if not pd_token and cur_pd_token:
+            logger.debug("Current secret PagerDuty api-token already set")
+            self.bot_config["PagerDuty"]["api-token"] = cur_pd_token
+            pd_token = cur_pd_token
+
+        if not bot_token:
+            err_msg = 'bot_token in {0} section required. See juju action "set-mattermost-bot-token".'
             logger.error(err_msg)
             raise MmPdBotK8sCharmConfigError(err_msg)
-        if bot_token and bot_login:
-            err_msg = "bot_token and bot_login are both set. Pick one of them"
+        if not pd_account or not pd_token:
+            err_msg = 'PagerDuty credentials incomplete. See juju action "set-pagerduty-credentials".'
             logger.error(err_msg)
             raise MmPdBotK8sCharmConfigError(err_msg)
 
@@ -71,7 +296,7 @@ class MmPdBotK8sCharm(CharmBase):
         """
         errors = []
         for required in REQUIRED_JUJU_SETTINGS:
-            if not self.model.config[required]:
+            if not self.config[required]:
                 logger.error("Required setting empty: %s", required)
                 errors.append(required)
         if errors:
@@ -118,156 +343,44 @@ class MmPdBotK8sCharm(CharmBase):
         :returns: Returns a configparser.ConfigParser object with the configuration.
         :raises: MmPdBotK8sCharmConfigError if the configuration is invalid.
         """
-        config = configparser.ConfigParser(allow_no_value=True)
+        config = configparser.ConfigParser(allow_no_value=True, dict_type=collections.OrderedDict)
         try:
             config.read_string(configuration)
-        except configparser.Error as exc:
-            err_msg = "Error while parsing mm_pd_bot_cfg setting"
+        except configparser.Error:
+            err_msg = "Error while parsing mm_pd_bot_cfg setting. \
+                Check https://git.launchpad.net/charm-k8s-mm-pd-bot/tree/examples/bot.cfg."
             logger.error(err_msg)
-            raise MmPdBotK8sCharmConfigError(err_msg) from exc
+            self.unit.status = BlockedStatus(err_msg)
+            return
+        for section in config._sections:
+            config._sections[section] = collections.OrderedDict(
+                sorted(config._sections[section].items(), key=lambda t: t[0])
+            )
+        config._sections = collections.OrderedDict(sorted(config._sections.items(), key=lambda t: t[0]))
         return config
 
     def _validate_mm_pd_bot_configuration(self) -> None:
         """Check the configuration part related to mm_pd_bot configuration."""
-        self.bot_config = self._load_mm_pd_bot_configuration(self.model.config["mm_pd_bot_cfg"])
+        logger.debug("Validate mm-pd-bot configuration.")
         self._validate_mm_pd_bot_configuration_content()
+        logger.debug("Validate mm-pd-bot secrets.")
         self._validate_bot_creds()
 
-    def _check_for_config_problems(self) -> None:
+    def _check_charm_config(self) -> bool:
         """Check that the mandatory configuration items are all set.
 
         Each method will raise an exception if an error is detected.
-        """
-        self._check_juju_settings()
-        self._validate_mm_pd_bot_configuration()
-
-    def _make_pod_config(self) -> dict:
-        """Return an envConfig with some core configuration.
-
-        :returns: A dictionary used for envConfig in podspec
-        """
-        config = self.model.config
-        pod_config = {
-            "MM_PD_BOT_CFG": config["mm_pd_bot_cfg"],
-        }
-
-        return pod_config
-
-    def _update_pod_spec_for_k8s_ingress(self, pod_spec: dict) -> None:
-        """Add resources to pod_spec configuring site ingress, if needed.
-
-        :param pod_spec: pod spec v3 as defined by juju.
-        """
-
-        hostname = self.bot_config.get("httpd", "hostname")
-        container_port = self.bot_config.getint("httpd", "listen-port")
-        magic_uuid = self.bot_config.get("httpd", "magic-uuid")
-        tls_secret_name = self.model.config.get("tls_secret_name", None)
-
-        if tls_secret_name:
-            scheme = "https"
-        else:
-            scheme = "http"
-
-        bot_listening_url = "{0}://{1}:{2}/{3}/".format(scheme, hostname, container_port, magic_uuid)
-        bot_listening_url_parsed = urlparse(bot_listening_url)
-
-        annotations = {}
-        ingress = {
-            "name": "{}-ingress".format(self.app.name),
-            "spec": {
-                "rules": [
-                    {
-                        "host": bot_listening_url_parsed.hostname,
-                        "http": {
-                            "paths": [
-                                {
-                                    "path": "/{0}/".format(magic_uuid),
-                                    "backend": {"serviceName": self.app.name, "servicePort": container_port},
-                                }
-                            ]
-                        },
-                    }
-                ]
-            },
-        }
-        if tls_secret_name:
-            ingress["spec"]["tls"] = [
-                {"hosts": [bot_listening_url_parsed.hostname], "secretName": tls_secret_name},
-            ]
-        else:
-            annotations["nginx.ingress.kubernetes.io/ssl-redirect"] = "false"
-
-        ingress_whitelist_source_range = self.model.config.get("ingress_whitelist_source_range", None)
-        if ingress_whitelist_source_range:
-            annotations["nginx.ingress.kubernetes.io/whitelist-source-range"] = ingress_whitelist_source_range
-
-        if annotations:
-            ingress["annotations"] = annotations
-
-        # Due to https://github.com/canonical/operator/issues/293 we
-        # can't use pod.set_spec's k8s_resources argument.
-        resources = pod_spec.get("kubernetesResources", {})
-        resources["ingressResources"] = [ingress]
-        pod_spec["kubernetesResources"] = resources
-
-    def _make_pod_spec(self) -> None:
-        """Create a pod spec with some core configuration."""
-
-        config = self.model.config
-        container_port = self.bot_config.getint("httpd", "listen-port")
-        # TODO: The bot replies 501 on HTTP GET so until we have something to probe readiness, magic-uuid is not needed
-        # here
-        # magic_uuid = self.bot_config.get('httpd', 'magic-uuid')
-        image_details = {
-            "imagePath": config["image_path"],
-        }
-        if config.get("image_username", None):
-            image_details.update({"username": config["image_username"], "password": config["image_password"]})
-        pod_config = self._make_pod_config()
-
-        return {
-            "version": 3,  # otherwise resources are ignored
-            "containers": [
-                {
-                    "name": self.app.name,
-                    "imageDetails": image_details,
-                    # TODO: debatable. The idea is that if you want to force an update with the same image name, you
-                    # don't need to empty kubelet cache on each node to have the right version.
-                    # This implies a performance drop upon start.
-                    "imagePullPolicy": "Always",
-                    "ports": [{"containerPort": container_port, "protocol": "TCP"}],
-                    "envConfig": pod_config,
-                    # TODO: Add readiness probe in the bot.
-                    # 'kubernetes': {
-                    #     'readinessProbe': {'httpGet': {'path': '/{0}/'.format(magic_uuid), 'port': container_port}},
-                    # },
-                }
-            ],
-        }
-
-    def configure_pod(self, event: ops.framework.EventBase) -> None:
-        """Assemble the pod spec and apply it, if possible.
-
-        :param event: Event that triggered the method.
+        :returns: True if the configuration is valid. False otherwise.
         """
 
-        if not self.unit.is_leader():
-            self.unit.status = ActiveStatus()
-            return
         try:
-            self._check_for_config_problems()
+            self._check_juju_settings()
+            self._validate_mm_pd_bot_configuration()
         except MmPdBotK8sCharmConfigError as exc:
             self.unit.status = BlockedStatus(str(exc))
-            return
-
-        logger.info("Assembling pod spec")
-        pod_spec = self._make_pod_spec()
-        self._update_pod_spec_for_k8s_ingress(pod_spec)
-        logger.info("Setting pod spec")
-        self.model.pod.set_spec(pod_spec)
-        self.unit.status = ActiveStatus()
+            return False
+        return True
 
 
 if __name__ == "__main__":  # pragma: no cover
-    main(MmPdBotK8sCharm, use_juju_for_storage=True)
+    main(MmPdBotK8sCharm)
diff --git a/tests/unit/scenario.py b/tests/unit/scenario.py
index e46c189..212ca54 100644
--- a/tests/unit/scenario.py
+++ b/tests/unit/scenario.py
@@ -57,37 +57,35 @@ def get_juju_settings_default_value() -> list:
 JUJU_SETTINGS_DEFAULT = get_juju_settings_default_value()
 
 TEST_JUJU_SETTINGS = {
-    "empty_image_path": {
-        "config": {"mm_pd_bot_cfg": "dummy"},
-        "logger": ["ERROR:root:Required setting empty: image_path"],
-        "expected": "Required setting(s) empty: image_path",
-    },
     "empty_mm_pd_bot_cfg": {
-        "config": {"image_path": "mm_pd_bot:devel"},
+        "config": {"external_hostname": "mm-pd-bot.internal"},
         "logger": ["ERROR:root:Required setting empty: mm_pd_bot_cfg"],
         "expected": "Required setting(s) empty: mm_pd_bot_cfg",
     },
     "empty_all_settings": {
         "config": {},
-        "logger": ["ERROR:root:Required setting empty: image_path", "ERROR:root:Required setting empty: mm_pd_bot_cfg"],
-        "expected": "Required setting(s) empty: image_path, mm_pd_bot_cfg",
+        "logger": [
+            "ERROR:root:Required setting empty: external_hostname",
+            "ERROR:root:Required setting empty: mm_pd_bot_cfg",
+        ],
+        "expected": "Required setting(s) empty: external_hostname, mm_pd_bot_cfg",
     },
 }
 
 
 VALIDATE_MM_PD_BOT_CFG = {
     "good_configuration": {
-        "config": {"image_path": "mm_pd_bot:devel", "mm_pd_bot_cfg": get_cfg_content("good_configuration")},
+        "config": {"external_hostname": "mm-pd-bot.internal", "mm_pd_bot_cfg": get_cfg_content("good_configuration")},
         "expected": True,
         "logger": [],
     },
     "bad_formatted_configuration": {
-        "config": {"image_path": "mm_pd_bot:devel", "mm_pd_bot_cfg": "[PagerDuty"},
+        "config": {"external_hostname": "mm-pd-bot.internal", "mm_pd_bot_cfg": "[PagerDuty"},
         "expected": "Error while parsing mm_pd_bot_cfg setting",
         "logger": ["ERROR:root:Error while parsing mm_pd_bot_cfg setting"],
     },
     "missing_sections": {
-        "config": {"image_path": "mm_pd_bot:devel", "mm_pd_bot_cfg": get_cfg_content("missing_sections")},
+        "config": {"external_hostname": "mm-pd-bot.internal", "mm_pd_bot_cfg": get_cfg_content("missing_sections")},
         "expected": "Required section(s) missing in bot configuration file: "
         "MattermostBot, Prometheus, httpd, nickname to email",
         "logger": [
@@ -98,7 +96,7 @@ VALIDATE_MM_PD_BOT_CFG = {
         ],
     },
     "missing_options": {
-        "config": {"image_path": "mm_pd_bot:devel", "mm_pd_bot_cfg": get_cfg_content("missing_options")},
+        "config": {"external_hostname": "mm-pd-bot.internal", "mm_pd_bot_cfg": get_cfg_content("missing_options")},
         "expected": "Required option(s) missing in section MattermostBot: bot_team, bot_url, "
         "Required option(s) missing in section PagerDuty: api-token, "
         "Required option(s) missing in section httpd: hostname, listen-ip, listen-port, magic-uuid",
@@ -131,7 +129,7 @@ VALIDATE_POD_SPEC = {
             "version": 3,  # otherwise resources are ignored
             "containers": [
                 {
-                    "name": "mm-pd-bot-k8s",
+                    "name": "mm-pd-bot",
                     "imageDetails": {
                         "imagePath": "mm_pd_bot:devel",
                     },
@@ -153,7 +151,7 @@ VALIDATE_POD_SPEC = {
             "version": 3,  # otherwise resources are ignored
             "containers": [
                 {
-                    "name": "mm-pd-bot-k8s",
+                    "name": "mm-pd-bot",
                     "imageDetails": {"imagePath": "mm_pd_bot:devel", "username": "rockity", "password": "rock"},
                     "imagePullPolicy": "Always",
                     "ports": [{"containerPort": 2160, "protocol": "TCP"}],
@@ -172,7 +170,7 @@ VALIDATE_POD_SPEC_AND_INGRESS = {
             "version": 3,  # otherwise resources are ignored
             "containers": [
                 {
-                    "name": "mm-pd-bot-k8s",
+                    "name": "mm-pd-bot",
                     "imageDetails": {"imagePath": "mm_pd_bot:devel"},
                     "imagePullPolicy": "Always",
                     "ports": [{"containerPort": 2160, "protocol": "TCP"}],
@@ -182,7 +180,7 @@ VALIDATE_POD_SPEC_AND_INGRESS = {
             "kubernetesResources": {
                 "ingressResources": [
                     {
-                        "name": "mm-pd-bot-k8s-ingress",
+                        "name": "mm-pd-bot-ingress",
                         "spec": {
                             "rules": [
                                 {
@@ -191,7 +189,7 @@ VALIDATE_POD_SPEC_AND_INGRESS = {
                                         "paths": [
                                             {
                                                 "path": "/bdddcacb-ab42-40ac-9106-4275c1db1519/",
-                                                "backend": {"serviceName": "mm-pd-bot-k8s", "servicePort": 2160},
+                                                "backend": {"serviceName": "mm-pd-bot", "servicePort": 2160},
                                             },
                                         ],
                                     },
@@ -215,7 +213,7 @@ VALIDATE_POD_SPEC_AND_INGRESS = {
             "version": 3,  # otherwise resources are ignored
             "containers": [
                 {
-                    "name": "mm-pd-bot-k8s",
+                    "name": "mm-pd-bot",
                     "imageDetails": {"imagePath": "mm_pd_bot:devel"},
                     "imagePullPolicy": "Always",
                     "ports": [{"containerPort": 2160, "protocol": "TCP"}],
@@ -225,7 +223,7 @@ VALIDATE_POD_SPEC_AND_INGRESS = {
             "kubernetesResources": {
                 "ingressResources": [
                     {
-                        "name": "mm-pd-bot-k8s-ingress",
+                        "name": "mm-pd-bot-ingress",
                         "spec": {
                             "rules": [
                                 {
@@ -234,7 +232,7 @@ VALIDATE_POD_SPEC_AND_INGRESS = {
                                         "paths": [
                                             {
                                                 "path": "/bdddcacb-ab42-40ac-9106-4275c1db1519/",
-                                                "backend": {"serviceName": "mm-pd-bot-k8s", "servicePort": 2160},
+                                                "backend": {"serviceName": "mm-pd-bot", "servicePort": 2160},
                                             },
                                         ],
                                     },
@@ -258,7 +256,7 @@ VALIDATE_POD_SPEC_AND_INGRESS = {
             "version": 3,  # otherwise resources are ignored
             "containers": [
                 {
-                    "name": "mm-pd-bot-k8s",
+                    "name": "mm-pd-bot",
                     "imageDetails": {"imagePath": "mm_pd_bot:devel"},
                     "imagePullPolicy": "Always",
                     "ports": [{"containerPort": 2160, "protocol": "TCP"}],
@@ -268,7 +266,7 @@ VALIDATE_POD_SPEC_AND_INGRESS = {
             "kubernetesResources": {
                 "ingressResources": [
                     {
-                        "name": "mm-pd-bot-k8s-ingress",
+                        "name": "mm-pd-bot-ingress",
                         "spec": {
                             "rules": [
                                 {
@@ -277,7 +275,7 @@ VALIDATE_POD_SPEC_AND_INGRESS = {
                                         "paths": [
                                             {
                                                 "path": "/bdddcacb-ab42-40ac-9106-4275c1db1519/",
-                                                "backend": {"serviceName": "mm-pd-bot-k8s", "servicePort": 2160},
+                                                "backend": {"serviceName": "mm-pd-bot", "servicePort": 2160},
                                             },
                                         ],
                                     },
diff --git a/tests/unit/test_charm.py b/tests/unit/test_charm.py
index d56fcde..93527a3 100755
--- a/tests/unit/test_charm.py
+++ b/tests/unit/test_charm.py
@@ -4,7 +4,7 @@
 
 import unittest
 import configparser
-from unittest.mock import MagicMock, patch
+from unittest.mock import patch
 
 from charm import (
     MmPdBotK8sCharm,
@@ -12,17 +12,15 @@ from charm import (
 )
 
 from ops import testing
-from ops.model import (
-    ActiveStatus,
-    BlockedStatus,
-)
+# from ops.model import (
+#     ActiveStatus,
+#     BlockedStatus,
+# )
 
 from scenario import (
     JUJU_SETTINGS_DEFAULT,
     TEST_JUJU_SETTINGS,
     VALIDATE_MM_PD_BOT_CFG,
-    VALIDATE_POD_SPEC,
-    VALIDATE_POD_SPEC_AND_INGRESS,
 )
 
 
@@ -41,14 +39,15 @@ class TestMmPdBotK8sCharmBlockedStatus(unittest.TestCase):
 
     @patch("charm.MmPdBotK8sCharm._validate_mm_pd_bot_configuration")
     @patch("charm.MmPdBotK8sCharm._check_juju_settings")
-    def test_check_for_config_problems(self, mock_juju, mock_mm_pd_bot):
+    def test_check_charm_config(self, mock_juju, mock_mm_pd_bot):
         """Check the calls for config problems."""
-        self.harness.charm._check_for_config_problems()
+        self.harness.charm._check_charm_config()
         mock_juju.assert_called_once()
         mock_mm_pd_bot.assert_called_once()
 
     def test_check_juju_settings(self):
         """Check the required juju settings."""
+        self.harness.disable_hooks()
         for scenario, values in TEST_JUJU_SETTINGS.items():
             with self.subTest(scenario=scenario):
                 with self.assertLogs(level="ERROR") as logger:
@@ -59,9 +58,11 @@ class TestMmPdBotK8sCharmBlockedStatus(unittest.TestCase):
                 self.assertEqual(sorted(logger.output), sorted(values["logger"]))
                 self.assertEqual(str(exc.exception), values["expected"])
             self.harness.update_config(JUJU_SETTINGS_DEFAULT)  # You need to clean the config after each run
+        self.harness.enable_hooks()
 
     def test_validate_mm_pd_bot_configuration(self):
         """Check the MM_PD_BOT_CFG string is a valid INI."""
+        self.harness.disable_hooks()
         for scenario, values in VALIDATE_MM_PD_BOT_CFG.items():
             with self.subTest(scenario=scenario):
                 self.harness.update_config(values["config"])
@@ -74,6 +75,7 @@ class TestMmPdBotK8sCharmBlockedStatus(unittest.TestCase):
                     self.assertEqual(str(exc.exception), values["expected"])
                     self.assertEqual(sorted(logger.output), sorted(values["logger"]))
             self.harness.update_config(JUJU_SETTINGS_DEFAULT)  # You need to clean the config after each run
+        self.harness.enable_hooks()
 
     def test_load_mm_pd_bot_configuration(self):
         """Test the loading of the configuration for the bot."""
@@ -86,64 +88,70 @@ class TestMmPdBotK8sCharmBlockedStatus(unittest.TestCase):
             loaded_config = self.harness.charm._load_mm_pd_bot_configuration(config)
         self.assertEqual(str(exc.exception), VALIDATE_MM_PD_BOT_CFG["bad_formatted_configuration"]["expected"])
 
-    def test_configure_pod(self):
-        """Test the pod configuration."""
-        mock_event = MagicMock()
-
-        # Good configuration but not leader
-        self.harness.update_config(VALIDATE_MM_PD_BOT_CFG["good_configuration"]["config"])
-        self.harness.set_leader(False)
-        self.harness.charm.unit.status = BlockedStatus("Testing")
-        self.harness.charm.configure_pod(mock_event)
-        self.assertEqual(self.harness.charm.unit.status, ActiveStatus())
-        self.harness.update_config(JUJU_SETTINGS_DEFAULT)  # You need to clean the config after each run
-
-        # Good configuration and leader
+    def test_configure_workload(self):
+        """Test the workload configuration."""
+        self.harness.disable_hooks()
         self.harness.update_config(VALIDATE_MM_PD_BOT_CFG["good_configuration"]["config"])
-        self.harness.set_leader(True)
-        self.harness.charm.unit.status = BlockedStatus("Testing")
-        self.harness.charm.configure_pod(mock_event)
-        with self.assertLogs(level="INFO") as logger:
-            self.harness.charm.configure_pod(mock_event)
-        self.assertEqual(
-            sorted(logger.output),
-            ["INFO:root:Assembling pod spec", "INFO:root:Setting pod spec"],
-        )
-        self.assertEqual(self.harness.charm.unit.status, ActiveStatus())
-        self.harness.update_config(JUJU_SETTINGS_DEFAULT)  # You need to clean the config after each run
-
-        # Bad configuration and leader
-        config = VALIDATE_MM_PD_BOT_CFG["bad_formatted_configuration"]["config"]
-        expected = VALIDATE_MM_PD_BOT_CFG["bad_formatted_configuration"]["expected"]
-        self.harness.update_config(config)
-        self.harness.set_leader(True)
-        self.harness.charm.configure_pod(mock_event)
-        self.assertEqual(self.harness.charm.unit.status, BlockedStatus(expected))
-        self.harness.update_config(JUJU_SETTINGS_DEFAULT)  # You need to clean the config after each run
-
-    def test_make_pod_spec(self):
-        """Check the crafting of the pod spec."""
-        for scenario, values in VALIDATE_POD_SPEC.items():
-            with self.subTest(scenario=scenario):
-                self.harness.update_config(values["config"])
-                self.harness.charm.bot_config = self.harness.charm._load_mm_pd_bot_configuration(
-                    values["config"]["mm_pd_bot_cfg"]
-                )
-                self.assertEqual(self.harness.charm._make_pod_spec(), values["pod_spec"])
-                self.harness.update_config(JUJU_SETTINGS_DEFAULT)  # You need to clean the config after each run
-
-    def test_update_pod_spec_for_k8s_ingress(self):
-        """Check the crafting of the ingress part of the pod spec."""
-        for scenario, values in VALIDATE_POD_SPEC_AND_INGRESS.items():
-            with self.subTest(scenario=scenario):
-                self.harness.update_config(values["config"])
-                self.harness.charm.bot_config = self.harness.charm._load_mm_pd_bot_configuration(
-                    values["config"]["mm_pd_bot_cfg"]
-                )
-                pod_spec = self.harness.charm._make_pod_spec()
-                self.harness.charm._update_pod_spec_for_k8s_ingress(pod_spec)
-                self.assertEqual(pod_spec, values["pod_spec"])
-                self.harness.update_config(JUJU_SETTINGS_DEFAULT)  # You need to clean the config after each run
+        self.harness.charm.configure_workload(None)
+        self.harness.enable_hooks()
+
+    # def test_configure_pod(self):
+    #     """Test the pod configuration."""
+
+    #     # Good configuration but not leader
+    #     self.harness.update_config(VALIDATE_MM_PD_BOT_CFG["good_configuration"]["config"])
+    #     self.harness.set_leader(False)
+    #     self.harness.charm.unit.status = BlockedStatus("Testing")
+    #     self.harness.charm.configure_pod(mock_event)
+    #     self.assertEqual(self.harness.charm.unit.status, ActiveStatus())
+    #     self.harness.update_config(JUJU_SETTINGS_DEFAULT)  # You need to clean the config after each run
+
+    #     # Good configuration and leader
+    #     self.harness.update_config(VALIDATE_MM_PD_BOT_CFG["good_configuration"]["config"])
+    #     self.harness.set_leader(True)
+    #     self.harness.charm.unit.status = BlockedStatus("Testing")
+    #     self.harness.charm.configure_pod(mock_event)
+    #     with self.assertLogs(level="INFO") as logger:
+    #         self.harness.charm.configure_pod(mock_event)
+    #     self.assertEqual(
+    #         sorted(logger.output),
+    #         ["INFO:root:Assembling pod spec", "INFO:root:Setting pod spec"],
+    #     )
+    #     self.assertEqual(self.harness.charm.unit.status, ActiveStatus())
+    #     self.harness.update_config(JUJU_SETTINGS_DEFAULT)  # You need to clean the config after each run
+
+    #     # Bad configuration and leader
+    #     config = VALIDATE_MM_PD_BOT_CFG["bad_formatted_configuration"]["config"]
+    #     expected = VALIDATE_MM_PD_BOT_CFG["bad_formatted_configuration"]["expected"]
+    #     self.harness.update_config(config)
+    #     self.harness.set_leader(True)
+    #     self.harness.charm.configure_pod(mock_event)
+    #     self.assertEqual(self.harness.charm.unit.status, BlockedStatus(expected))
+    #     self.harness.update_config(JUJU_SETTINGS_DEFAULT)  # You need to clean the config after each run
+
+    # def test_make_pod_spec(self):
+    #     """Check the crafting of the pod spec."""
+    #     for scenario, values in VALIDATE_POD_SPEC.items():
+    #         with self.subTest(scenario=scenario):
+    #             self.harness.update_config(values["config"])
+    #             self.harness.charm.bot_config = self.harness.charm._load_mm_pd_bot_configuration(
+    #                 values["config"]["mm_pd_bot_cfg"]
+    #             )
+    #             self.assertEqual(self.harness.charm._make_pod_spec(), values["pod_spec"])
+    #             self.harness.update_config(JUJU_SETTINGS_DEFAULT)  # You need to clean the config after each run
+
+    # def test_update_pod_spec_for_k8s_ingress(self):
+    #     """Check the crafting of the ingress part of the pod spec."""
+    #     for scenario, values in VALIDATE_POD_SPEC_AND_INGRESS.items():
+    #         with self.subTest(scenario=scenario):
+    #             self.harness.update_config(values["config"])
+    #             self.harness.charm.bot_config = self.harness.charm._load_mm_pd_bot_configuration(
+    #                 values["config"]["mm_pd_bot_cfg"]
+    #             )
+    #             pod_spec = self.harness.charm._make_pod_spec()
+    #             self.harness.charm._update_pod_spec_for_k8s_ingress(pod_spec)
+    #             self.assertEqual(pod_spec, values["pod_spec"])
+    #             self.harness.update_config(JUJU_SETTINGS_DEFAULT)  # You need to clean the config after each run
 
 
 if __name__ == "__main__":