Merge charm-k8s-jenkins-agent:relations-config into charm-k8s-jenkins-agent:master

[Alexandre Gomes]

Add feature to configure agents through juju relations

[🤖 Canonical IS Merge Bot (canonical-is-mergebot)]

This merge proposal is being monitored by mergebot. Change the status to Approved to merge.

[Tom Haddon (mthaddon)]

Some comments inline. Tests will need updating a little based on what changes you make.

review: Needs Fixing

[🤖 Canonical IS Merge Bot (canonical-is-mergebot)]

This merge proposal is being monitored by mergebot. Change the status to Approved to merge.

[Alexandre Gomes (alejdg)]

All comments have been addressed and tests have been updated too.

review: Needs Resubmitting

[Tom Haddon (mthaddon)]

Some comments/questions inline.

[Alexandre Gomes (alejdg)]

The interface is still called jenkins-slave, so we need to keep all the references to 'slave' until the interface gets updated.

[Tom Haddon (mthaddon)]

Thanks, a few more comments (sorry for not catching those before). With these addressed I think we can put this up for review with ~charmcrafters.

[Alexandre Gomes (alejdg)]

All comments have been addressed. @mthaddon could you check if the changes in the _is_valid_config are more in line with the pattern you mentioned?

review: Needs Resubmitting

[Tom Haddon (mthaddon)]

A few more comments inline. Hopefully final changes now, and then we can get this up for review with the charmcrafters. Thanks.

[Alexandre Gomes (alejdg)]

All addressed in the last commit.

review: Needs Resubmitting

[Tom Haddon (mthaddon)]

LGTM, thx. Have requested a review from ~charmcrafters.

[Facundo Batista (facundo)]

Annotated a couple of small comments, thanks!

[Alexandre Gomes (alejdg)]

> Annotated a couple of small comments, thanks!

Hey Facundo, the _spec thing was just something I got from another charm and I thought it was a best practice. I've addressed it and the other comments as well.

review: Needs Resubmitting

[Facundo Batista (facundo)]

Awesome, thanks!

review: Approve

[Tom Haddon (mthaddon)]

Adding an approving comment so we can merge, having had charmcraft review (thanks!)

review: Approve

[🤖 Canonical IS Merge Bot (canonical-is-mergebot)]

Change successfully merged at revision 3d32fe405416600da88ceb51f21453f9fbe2aec9

diff --git a/.gitignore b/.gitignore
index bf7fffd..eea14ad 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,3 +6,4 @@ __pycache__
 build
 lib/ops
 lib/ops-*.dist-info
+unit/
diff --git a/Makefile b/Makefile
index 86bd8d3..8c8056a 100644
--- a/Makefile
+++ b/Makefile
@@ -18,6 +18,13 @@ build-image: | $(dockerfile_dir)
 	  --build-arg REVISION="$(revision)" \
 	  -t $(JENKINS_IMAGE) $(dockerfile_dir)
 
+build-image-no-cache: | $(dockerfile_dir)
+	docker build \
+	  --build-arg AUTHOR=$(author) \
+	  --build-arg REVISION="$(revision)" \
+	  --no-cache \
+	  -t $(JENKINS_IMAGE) $(dockerfile_dir)
+
 build-release-image: | $(dockerfile_dir)
 	docker build \
 	  --build-arg DATE_CREATED="$(date_created)" \
diff --git a/config.yaml b/config.yaml
index 7ad8e02..c419381 100644
--- a/config.yaml
+++ b/config.yaml
@@ -3,32 +3,30 @@ options:
     type: string
     default: "jenkins-agent-operator"
     description: "The docker image to install. Required. Defaults to jenkins-agent-operator from rocks.canonical.com"
-  tools:
-    type: string
-    default: git gcc make bzr
-    description: Tooling to deploy on jenkins agent node
-  labels:
-    type: string
-    description: Jenkins labels to associate with jenkins agent node
-    default: ""
   jenkins_master_url:
     type: string
     default: ""
     description: |
-      Configure the agent to use an explicit jenkins master instead of using
-      the jenkins-agent relation. This allows for the agent and master to
-      be deployed in different environments.
+      Configure the agent to use an explicit Jenkins master instead of using
+      the jenkins-agent relation. This allows the agent to connect to a Jenkins instance not managed 
+      by Juju.
   jenkins_agent_name:
     type: string
     default: ""
     description: |
-      Jenkins agent name that will be seen on the jenkins master.
-      Will default to the hostname of the container.
-  jenkins_api_token:
+      Agent name as configured in Jenkins. Multiple names can be input by using `:` as a separator. 
+      Example: "agent-one:agent-two:agent-three"
+  jenkins_agent_token:
     type: string
     default: ""
-    description: "Jenkins API token used to join the master"
-  jenkins_user:
+    description: |
+      Agent token provided by Jenkins. Can be found in your Jenkins instance at 
+      ${JENKINS_URL}/computer/${AGENT_NAME}/. Multiple tokens can be input by 
+      using `:` as a separator matching the order of the agents in `jenkins_agent_name`.
+      Example: "token-one:token-two:token-three"
+  jenkins_agent_labels:
     type: string
-    default: "admin"
-    description: "Jenkins user to download agent.jar from master"
+    default: ""
+    description: |
+      Comma-separated list of labels to be assigned to the agent in Jenkins. If not set it will default to 
+      the agents hardware identifier, e.g.: 'x86_64'
diff --git a/dockerfile/Dockerfile b/dockerfile/Dockerfile
index 1abd7e6..700e70f 100644
--- a/dockerfile/Dockerfile
+++ b/dockerfile/Dockerfile
@@ -47,7 +47,9 @@ RUN apt-get update -y \
 
 WORKDIR /var/lib/jenkins
 
-USER ${USER}
+# Using root due to https://bugs.launchpad.net/juju/+bug/1879598
+#USER ${USER}
+USER root
 
 COPY files/entrypoint.sh /
 
diff --git a/dockerfile/files/entrypoint.sh b/dockerfile/files/entrypoint.sh
index c4e879c..a2f820e 100755
--- a/dockerfile/files/entrypoint.sh
+++ b/dockerfile/files/entrypoint.sh
@@ -3,6 +3,7 @@
 set -eu -o pipefail
 
 export LC_ALL=C
+export TERM=xterm
 
 # defaults for jenkins-agent component of the jenkins continuous integration
 # system
@@ -20,17 +21,11 @@ typeset JAVA_ARGS=${JAVA_ARGS:-""}
 # job from running.
 typeset JENKINS_URL="${JENKINS_URL:?"URL of a jenkins server must be provided"}"
 
-# Name of agent configuration to use at JENKINS_URL
-# Override if it need to be something other than the
-# hostname of the server the agent is running on.
-typeset JENKINS_HOSTNAME="${JENKINS_HOSTNAME:-$(hostname)}"
+typeset JENKINS_WORKDIR="/var/lib/jenkins"
 
 # Arguments to pass to jenkins agent on startup
 typeset -a JENKINS_ARGS
 
-JENKINS_ARGS+=(-jnlpUrl "${JENKINS_URL}"/computer/"${JENKINS_HOSTNAME}"/slave-agent.jnlp)
-JENKINS_ARGS+=(-jnlpCredentials "${JENKINS_API_USER:?Please specify JENKINS_API_USER}:${JENKINS_API_TOKEN:?Please specify JENKINS_API_TOKEN}")
-
 # Path of the agent.jar
 typeset AGENT_JAR=/var/lib/jenkins/agent.jar
 
@@ -55,5 +50,13 @@ download_agent
 # Specify the pod as ready
 touch /var/lib/jenkins/agents/.ready
 
-#shellcheck disable=SC2086
-"${JAVA}" ${JAVA_ARGS} -jar "${AGENT_JAR}"  "${JENKINS_ARGS[@]}"
+# Transform the env variables in arrays to iterate through it
+IFS=':' read -r -a AGENTS <<< ${JENKINS_AGENTS}
+IFS=':' read -r -a TOKENS <<< ${JENKINS_TOKENS}
+
+echo ${!AGENTS[@]}
+
+for index in ${!AGENTS[@]}; do
+    echo "About to run ${JAVA}" "${JAVA_ARGS}" -jar "${AGENT_JAR}" -jnlpUrl "${JENKINS_URL}"/computer/"${AGENTS[$index]}"/slave-agent.jnlp -workDir "${JENKINS_WORKDIR}" -noReconnect -secret "${TOKENS[$index]}"
+    ${JAVA} ${JAVA_ARGS} -jar ${AGENT_JAR} -jnlpUrl ${JENKINS_URL}/computer/${AGENTS[$index]}/slave-agent.jnlp -workDir ${JENKINS_WORKDIR} -noReconnect -secret ${TOKENS[$index]} || echo "Invalid or already used credentials."
+done
diff --git a/metadata.yaml b/metadata.yaml
index b53a613..dd92ccb 100644
--- a/metadata.yaml
+++ b/metadata.yaml
@@ -9,3 +9,6 @@ series:
   - kubernetes
 deployment:
   service: omit
+provides:
+  slave:
+    interface: jenkins-slave
diff --git a/src/charm.py b/src/charm.py
index 4ba8782..9ade818 100755
--- a/src/charm.py
+++ b/src/charm.py
@@ -4,8 +4,9 @@
 # Licensed under the GPLv3, see LICENCE file for details.
 
 import io
-import pprint
 import logging
+import os
+import pprint
 
 from ops.charm import CharmBase
 from ops.framework import StoredState
@@ -16,59 +17,58 @@ from ops.model import ActiveStatus, BlockedStatus, MaintenanceStatus
 logger = logging.getLogger()
 
 
-def generate_pod_config(config, secured=True):
-    """Kubernetes pod config generator.
-
-    generate_pod_config generates Kubernetes deployment config.
-    If the secured keyword is set then it will return a sanitised copy
-    without exposing secrets.
-    """
-    pod_config = {}
-
-    pod_config["JENKINS_API_USER"] = config["jenkins_user"]
-    if config.get("jenkins_master_url", None):
-        pod_config["JENKINS_URL"] = config["jenkins_master_url"]
-    if config.get("jenkins_agent_name", None):
-        pod_config["JENKINS_HOSTNAME"] = config["jenkins_agent_name"]
-
-    if secured:
-        return pod_config
+class JenkinsAgentCharm(CharmBase):
+    _stored = StoredState()
 
-    # Add secrets from charm config
-    pod_config["JENKINS_API_TOKEN"] = config["jenkins_api_token"]
+    def __init__(self, *args):
+        super().__init__(*args)
 
-    return pod_config
+        self.framework.observe(self.on.start, self.configure_pod)
+        self.framework.observe(self.on.config_changed, self.configure_pod)
+        self.framework.observe(self.on.upgrade_charm, self.configure_pod)
+        self.framework.observe(self.on.slave_relation_joined, self.on_agent_relation_joined)
+        self.framework.observe(self.on.slave_relation_changed, self.on_agent_relation_changed)
 
+        self._stored.set_default(spec=None, jenkins_url=None, agent_tokens=None, agents=None)
 
-class JenkinsAgentCharm(CharmBase):
-    state = StoredState()
+    def generate_pod_config(self, config, secured=True):
+        """Kubernetes pod config generator.
 
-    def __init__(self, framework, parent):
-        super().__init__(framework, parent)
+        generate_pod_config generates Kubernetes deployment config.
+        If the secured keyword is set then it will return a sanitised copy
+        without exposing secrets.
+        """
+        pod_config = {}
 
-        framework.observe(self.on.start, self.configure_pod)
-        framework.observe(self.on.config_changed, self.configure_pod)
-        framework.observe(self.on.upgrade_charm, self.configure_pod)
+        if self._stored.jenkins_url:
+            pod_config["JENKINS_URL"] = self._stored.jenkins_url
+        else:
+            pod_config["JENKINS_URL"] = config["jenkins_master_url"]
 
-        self.state.set_default(_spec=None)
+        if secured:
+            return pod_config
 
-    def on_upgrade_charm(self, event):
-        pass
+        if self._stored.agent_tokens and self._stored.agents:
+            pod_config["JENKINS_AGENTS"] = ":".join(self._stored.agents)
+            pod_config["JENKINS_TOKENS"] = ":".join(self._stored.agent_tokens)
+        else:
+            pod_config["JENKINS_AGENTS"] = config["jenkins_agent_name"]
+            pod_config["JENKINS_TOKENS"] = config["jenkins_agent_token"]
 
-    def on_config_changed(self, event):
-        pass
+        return pod_config
 
     def configure_pod(self, event):
-        is_valid = self.is_valid_config()
+        """Assemble the pod spec and apply it, if possible."""
+        is_valid = self._is_valid_config()
         if not is_valid:
             return
 
-        spec = self.make_pod_spec()
-        if spec != self.state._spec:
-            self.state._spec = spec
+        spec = self._make_pod_spec()
+        if spec != self._stored.spec:
+            self._stored.spec = spec
             # only the leader can set_spec()
             if self.model.unit.is_leader():
-                spec = self.make_pod_spec()
+                spec = self._make_pod_spec()
 
                 logger.info("Configuring pod")
                 self.model.unit.status = MaintenanceStatus("Configuring pod")
@@ -81,13 +81,15 @@ class JenkinsAgentCharm(CharmBase):
         else:
             logger.info("Pod spec unchanged")
 
-        self.state.is_started = True
+        self._stored.is_started = True
         self.model.unit.status = ActiveStatus()
 
-    def make_pod_spec(self):
+    def _make_pod_spec(self):
+        """Prepare and return a pod spec."""
         config = self.model.config
-        full_pod_config = generate_pod_config(config, secured=False)
-        secure_pod_config = generate_pod_config(config, secured=True)
+
+        full_pod_config = self.generate_pod_config(config, secured=False)
+        secure_pod_config = self.generate_pod_config(config, secured=True)
 
         spec = {
             "containers": [
@@ -105,15 +107,31 @@ class JenkinsAgentCharm(CharmBase):
         logger.info("This is the Kubernetes Pod spec config (sans secrets) <<EOM\n{}\nEOM".format(out.getvalue()))
 
         secure_pod_config.update(full_pod_config)
-
         return spec
 
-    def is_valid_config(self):
-        is_valid = True
+    def _missing_charm_settings(self):
+        """Check configuration setting dependencies
+
+        Return a list of missing settings; otherwise return an empty list."""
         config = self.model.config
+        if self._stored.agent_tokens:
+            required_settings = ("image",)
+        else:
+            required_settings = ("image", "jenkins_master_url", "jenkins_agent_name", "jenkins_agent_token")
 
-        want = ("image", "jenkins_user", "jenkins_api_token")
-        missing = [k for k in want if config[k].rstrip() == ""]
+        missing = [setting for setting in required_settings if not config[setting]]
+
+        return sorted(missing)
+
+    def _is_valid_config(self):
+        """Validate required configuration.
+
+        When not configuring the agent through relations
+        'jenkins_master_url', 'jenkins_agent_name' and 'jenkins_agent_token'
+        are required."""
+        is_valid = True
+
+        missing = self._missing_charm_settings()
         if missing:
             message = "Missing required config: {}".format(" ".join(missing))
             logger.info(message)
@@ -122,6 +140,75 @@ class JenkinsAgentCharm(CharmBase):
 
         return is_valid
 
+    def on_agent_relation_joined(self, event):
+        """Set relation data for the unit once an agent has connected."""
+        logger.info("Jenkins relation joined")
+        num_executors = os.cpu_count()
+        config_labels = self.model.config.get('jenkins_agent_labels')
+        agent_name = self._gen_agent_name()
+
+        if config_labels:
+            labels = config_labels
+        else:
+            labels = os.uname().machine
+
+        event.relation.data[self.model.unit]["executors"] = str(num_executors)
+        event.relation.data[self.model.unit]["labels"] = labels
+        event.relation.data[self.model.unit]["slavehost"] = agent_name
+
+    def on_agent_relation_changed(self, event):
+        """Populate local configuration with data from relation."""
+        logger.info("Jenkins relation changed")
+        try:
+            self._stored.jenkins_url = event.relation.data[event.unit]['url']
+        except KeyError:
+            pass
+
+        try:
+            self._stored.agent_tokens = self._stored.agent_tokens or []
+            self._stored.agent_tokens.append(event.relation.data[event.unit]['secret'])
+            self._gen_agent_name(store=True)
+        except KeyError:
+            pass
+
+        self.configure_through_relation(event)
+
+    def configure_through_relation(self, event):
+        """Configure the agent through data from relation."""
+        logger.info("Setting up jenkins via agent relation")
+        self.model.unit.status = MaintenanceStatus("Configuring jenkins agent")
+
+        if self.model.config.get("jenkins_master_url"):
+            logger.info("Config option 'jenkins_master_url' is set. Can't use agent relation.")
+            self.model.unit.status = ActiveStatus()
+            return
+
+        if self._stored.jenkins_url is None:
+            logger.info("Jenkins hasn't exported its URL yet. Skipping setup for now.")
+            self.model.unit.status = ActiveStatus()
+            return
+
+        if self._stored.agent_tokens is None:
+            logger.info("Jenkins hasn't exported the agent secret yet. Skipping setup for now.")
+            self.model.unit.status = ActiveStatus()
+            return
+
+        self.configure_pod(event)
+
+    def _gen_agent_name(self, store=False):
+        """Generate the agent name or get the one already in use."""
+        agent_name = ""
+        if self._stored.agents:
+            name, number = self._stored.agents[-1].rsplit('-', 1)
+            agent_name = "{}-{}".format(name, int(number) + 1)
+            if store:
+                self._stored.agents.append(agent_name)
+        else:
+            agent_name = self.unit.name.replace('/', '-')
+            if store:
+                self._stored.agents = [agent_name]
+        return agent_name
+
 
 if __name__ == '__main__':
     main(JenkinsAgentCharm)
diff --git a/tests/unit/test_charm.py b/tests/unit/test_charm.py
index 65705e7..d029934 100644
--- a/tests/unit/test_charm.py
+++ b/tests/unit/test_charm.py
@@ -1,21 +1,312 @@
 # Copyright 2020 Canonical Ltd.
 # Licensed under the GPLv3, see LICENCE file for details.
 
+from mock import MagicMock, patch
 import unittest
 
-import sys
+from ops import testing
+from ops.model import ActiveStatus, BlockedStatus, MaintenanceStatus
 
-sys.path.append('src')  # noqa: E402
+from charm import JenkinsAgentCharm
 
-from charm import generate_pod_config
+CONFIG_DEFAULT = {
+    "image": "jenkins-agent-operator",
+    "jenkins_master_url": "",
+    "jenkins_agent_name": "",
+    "jenkins_agent_token": "",
+    "jenkins_agent_label": ""
+}
+
+CONFIG_ONE_AGENT = {
+    "jenkins_master_url": "http://test",
+    "jenkins_agent_name": "agent-one",
+    "jenkins_agent_token": "token-one"
+}
+
+CONFIG_ONE_AGENT_CUSTOM_IMAGE = {
+    "image": "image-name",
+    "jenkins_master_url": "http://test",
+    "jenkins_agent_name": "agent-one",
+    "jenkins_agent_token": "token-one"
+}
+
+SPEC_EXPECTED = {
+    'containers': [{
+        'config': {
+            'JENKINS_AGENTS': 'agent-one',
+            'JENKINS_TOKENS': 'token-one',
+            'JENKINS_URL': 'http://test'
+        },
+        'imageDetails': {
+            'imagePath': 'image-name'
+        },
+        'name': 'jenkins-agent',
+        'readinessProbe': {
+            'exec': {
+                'command': [
+                    '/bin/cat',
+                    '/var/lib/jenkins/agents/.ready'
+                ]
+            }
+        }
+    }]
+}
 
 
 class TestJenkinsAgentCharm(unittest.TestCase):
-    def test_generate_pod_config(self):
-        config = {
-            "jenkins_user": "test",
+    def setUp(self):
+        self.harness = testing.Harness(JenkinsAgentCharm)
+        self.harness.begin()
+        self.harness.disable_hooks()
+        self.harness.update_config(CONFIG_DEFAULT)
+
+    def test__generate_pod_config(self):
+        """Test generate_pod_config"""
+        expected = {
+            "JENKINS_URL": "http://test",
         }
+        self.assertEqual(self.harness.charm.generate_pod_config(CONFIG_ONE_AGENT, secured=True), expected)
+
+        expected["JENKINS_AGENTS"] = "agent-one"
+        expected["JENKINS_TOKENS"] = "token-one"
+        self.assertEqual(self.harness.charm.generate_pod_config(CONFIG_ONE_AGENT, secured=False), expected)
+
+    def test__generate_pod_config__with__relation__data(self):
+        """Test generate_pod_config with relation data."""
         expected = {
-            "JENKINS_API_USER": "test",
+            "JENKINS_URL": "http://test",
         }
-        self.assertEqual(generate_pod_config(config), expected)
+        agent_name = "jenkins-agent-0"
+        url = "http://test"
+        token = "token"
+
+        self.harness.charm._state.jenkins_url = url
+        self.harness.charm._state.agent_tokens = [token]
+        self.harness.charm._state.agents = [agent_name]
+
+        self.assertEqual(self.harness.charm.generate_pod_config(CONFIG_ONE_AGENT, secured=True), expected)
+
+        expected["JENKINS_AGENTS"] = "jenkins-agent-0"
+        expected["JENKINS_TOKENS"] = "token"
+        self.assertEqual(self.harness.charm.generate_pod_config(CONFIG_ONE_AGENT, secured=False), expected)
+
+    def test__configure_pod__invalid__config(self):
+        """Test configure_pod when the config is invalid."""
+        self.harness.charm.on.config_changed.emit()
+        message = "Missing required config: jenkins_agent_name jenkins_agent_token jenkins_master_url"
+        print(self.harness.model.unit.status)
+        print(BlockedStatus(message))
+        self.assertEqual(self.harness.model.unit.status, BlockedStatus(message))
+        self.assertEqual(self.harness.get_pod_spec(), None)
+
+    def test__configure_pod__unit__not__leader(self):
+        """Test configure_pod when the unit isn't leader."""
+        self.harness.set_leader(is_leader=False)
+        self.harness.update_config(CONFIG_ONE_AGENT)
+        with self.assertLogs(level='INFO') as logger:
+            self.harness.charm.on.config_changed.emit()
+            self.assertEqual(self.harness.model.unit.status, ActiveStatus())
+            message = "INFO:root:Spec changes ignored by non-leader"
+            self.assertEqual(logger.output[-1], message)
+            self.assertEqual(self.harness.get_pod_spec(), None)
+
+    def test__configure_pod(self):
+        """Test configure_pod."""
+        expected = (SPEC_EXPECTED, None)
+
+        self.harness.set_leader(is_leader=True)
+        self.harness.update_config(CONFIG_ONE_AGENT_CUSTOM_IMAGE)
+        self.harness.charm.on.config_changed.emit()
+        self.assertEqual(self.harness.model.unit.status, ActiveStatus())
+        self.assertEqual(self.harness.get_pod_spec(), expected)
+
+    def test__configure_pod__no__spec_change(self):
+        """Test configure_pod when there is no change in the spec."""
+        self.harness.set_leader(is_leader=True)
+        self.harness.update_config(CONFIG_ONE_AGENT_CUSTOM_IMAGE)
+        self.harness.charm._state._spec = self.harness.charm._make_pod_spec()
+        with self.assertLogs(level='INFO') as logger:
+            self.harness.charm.on.config_changed.emit()
+            self.assertEqual(self.harness.model.unit.status, ActiveStatus())
+            message = "INFO:root:Pod spec unchanged"
+            self.assertEqual(logger.output[-1], message)
+            self.assertEqual(self.harness.get_pod_spec(), None)
+
+    def test__make_pod_spec(self):
+        """Test the construction of the spec based on juju config."""
+        self.harness.update_config(CONFIG_ONE_AGENT_CUSTOM_IMAGE)
+        self.assertEqual(self.harness.charm._make_pod_spec(), SPEC_EXPECTED)
+
+    def test__is_valid_config(self):
+        """Test config validation."""
+        config = {
+            "image": "image-name",
+            "jenkins_master_url": "http://test",
+            "jenkins_agent_name": "agent-one",
+            "jenkins_agent_token": "token-one"
+        }
+        self.assertEqual(self.harness.charm._is_valid_config(), False)
+        with self.subTest("Config from relation"):
+            self.harness.charm._state.agent_tokens = "token"
+            self.assertEqual(self.harness.charm._is_valid_config(), True)
+        with self.subTest("Config from juju config"):
+            self.harness.update_config(config)
+            self.assertEqual(self.harness.charm._is_valid_config(), True)
+
+    @patch("os.uname")
+    @patch("os.cpu_count")
+    def test__on_agent_relation_joined(self, mock_os_cpu_count, mock_os_uname):
+        """Test relation_data is set when a new relation joins."""
+        mock_os_cpu_count.return_value = 8
+        mock_os_uname.return_value.machine = "x86_64"
+        expected_relation_data = {
+            'executors': '8',
+            'labels': 'x86_64',
+            'slavehost': 'jenkins-agent-0'
+        }
+        self.harness.enable_hooks()
+        rel_id = self.harness.add_relation("slave", "jenkins")
+        self.harness.add_relation_unit(rel_id, "jenkins/0")
+
+        self.assertEqual(self.harness.get_relation_data(rel_id, "jenkins-agent/0"), expected_relation_data)
+
+    @patch("charm.JenkinsAgentCharm.configure_pod")
+    def test__configure_through_relation__no__jenkins_master_url(self, mock_configure_pod):
+        """Test configure_through_relation when no configuration has been provided."""
+        mock_event = MagicMock()
+        with self.assertLogs(level='INFO') as logger:
+            self.harness.charm.configure_through_relation(mock_event)
+            expected_output = [
+                "INFO:root:Setting up jenkins via agent relation",
+                "INFO:root:Jenkins hasn't exported its URL yet. Skipping setup for now."
+            ]
+            self.assertEqual(logger.output, expected_output)
+            mock_configure_pod.assert_not_called()
+            self.assertEqual(self.harness.model.unit.status, ActiveStatus())
+
+    @patch("charm.JenkinsAgentCharm.configure_pod")
+    def test__configure_through_relation__no__jenkins_agent_tokens(self, mock_configure_pod):
+        """Test configure_through_relation when no tokens have been provided."""
+        mock_event = MagicMock()
+        self.harness.charm._state.jenkins_url = "http://test"
+        with self.assertLogs(level='INFO') as logger:
+            self.harness.charm.configure_through_relation(mock_event)
+            expected_output = [
+                "INFO:root:Setting up jenkins via agent relation",
+                "INFO:root:Jenkins hasn't exported the agent secret yet. Skipping setup for now."
+            ]
+            self.assertEqual(logger.output, expected_output)
+            mock_configure_pod.assert_not_called()
+            self.assertEqual(self.harness.model.unit.status, ActiveStatus())
+
+    @patch("charm.JenkinsAgentCharm.configure_pod")
+    def test__configure_through_relation__manual__config(self, mock_configure_pod):
+        """Test configure_through_relation when no configuration has been provided."""
+        mock_event = MagicMock()
+        self.harness.update_config({"jenkins_master_url": "http://test"})
+        with self.assertLogs(level='INFO') as logger:
+            self.harness.charm.configure_through_relation(mock_event)
+            expected_output = [
+                "INFO:root:Setting up jenkins via agent relation",
+                "INFO:root:Config option 'jenkins_master_url' is set. Can't use agent relation."
+            ]
+            self.assertEqual(logger.output, expected_output)
+            mock_configure_pod.assert_not_called()
+            self.assertEqual(self.harness.model.unit.status, ActiveStatus())
+
+    @patch("charm.JenkinsAgentCharm.configure_pod")
+    def test__configure_through_relation(self, mock_configure_pod):
+        """Test configure_through_relation when the relation have provided all needed data."""
+        mock_event = MagicMock()
+        self.harness.charm._state.jenkins_url = "http://test"
+        self.harness.charm._state.agent_tokens = "token"
+        with self.assertLogs(level='INFO') as logger:
+            self.harness.charm.configure_through_relation(mock_event)
+            expected_output = [
+                "INFO:root:Setting up jenkins via agent relation"
+            ]
+            self.assertEqual(logger.output, expected_output)
+            mock_configure_pod.assert_called()
+            self.assertEqual(self.harness.model.unit.status, MaintenanceStatus("Configuring jenkins agent"))
+
+    @patch("os.uname")
+    @patch("os.cpu_count")
+    def test__on_agent_relation_joined__custom__label(self, mock_os_cpu_count, mock_os_uname):
+        """Test relation_data is set when a new relation joins
+            and custom labels are set"""
+        mock_os_cpu_count.return_value = 8
+        mock_os_uname.return_value.machine = "x86_64"
+        labels = "test, label"
+        expected_relation_data = {
+            'executors': '8',
+            'labels': labels,
+            'slavehost': 'jenkins-agent-0'
+        }
+        self.harness.update_config({"jenkins_agent_labels": labels})
+        self.harness.enable_hooks()
+        rel_id = self.harness.add_relation("slave", "jenkins")
+        self.harness.add_relation_unit(rel_id, "jenkins/0")
+        self.assertEqual(self.harness.get_relation_data(rel_id, "jenkins-agent/0"), expected_relation_data)
+
+    @patch("charm.JenkinsAgentCharm.configure_through_relation")
+    @patch("os.uname")
+    @patch("os.cpu_count")
+    def test__on_agent_relation_changed__noop(self, mock_os_cpu_count, mock_os_uname, mock_configure_through_relation):
+        """Test on_agent_relation_changed when jenkins hasn't provided information yet."""
+        mock_os_cpu_count.return_value = 8
+        mock_os_uname.return_value.machine = "x86_64"
+        remote_unit = "jenkins/0"
+        self.harness.enable_hooks()
+        rel_id = self.harness.add_relation("slave", "jenkins")
+        self.harness.add_relation_unit(rel_id, remote_unit)
+        self.harness.update_relation_data(rel_id, remote_unit, {})
+
+        mock_configure_through_relation.assert_called()
+
+    @patch("charm.JenkinsAgentCharm.configure_through_relation")
+    @patch("os.uname")
+    @patch("os.cpu_count")
+    def test__on_agent_relation_changed_old(self, mock_os_cpu_count, mock_os_uname, mock_configure_through_relation):
+        """Test relation_data is set when a new relation joins."""
+        mock_os_cpu_count.return_value = 8
+        mock_os_uname.return_value.machine = "x86_64"
+        remote_unit = "jenkins/0"
+        agent_name = "jenkins-agent-0"
+        url = "http://test"
+        secret = "token"
+        self.harness.enable_hooks()
+        rel_id = self.harness.add_relation("slave", "jenkins")
+        self.harness.add_relation_unit(rel_id, remote_unit)
+        self.harness.update_relation_data(rel_id, remote_unit, {"url": url, "secret": secret})
+        self.assertEqual(self.harness.charm._state.jenkins_url, url)
+        self.assertEqual(self.harness.charm._state.agent_tokens[-1], secret)
+        self.assertEqual(self.harness.charm._state.agents[-1], agent_name)
+        mock_configure_through_relation.assert_called()
+
+    @patch("charm.JenkinsAgentCharm.configure_through_relation")
+    @patch("os.uname")
+    @patch("os.cpu_count")
+    def test__on_agent_relation_changed__multiple__agents(
+        self,
+        mock_os_cpu_count,
+        mock_os_uname,
+        mock_configure_through_relation
+    ):
+        """Test relation_data is set when a new relation joins."""
+        mock_os_cpu_count.return_value = 8
+        mock_os_uname.return_value.machine = "x86_64"
+        remote_unit = "jenkins/0"
+        agent_name = "jenkins-agent-0"
+        expected_new_agent = "jenkins-agent-1"
+        url = "http://test"
+        secret = "token"
+
+        self.harness.charm._state.agents = [agent_name]
+        self.harness.enable_hooks()
+        rel_id = self.harness.add_relation("slave", "jenkins")
+        self.harness.add_relation_unit(rel_id, remote_unit)
+        self.harness.update_relation_data(rel_id, remote_unit, {"url": url, "secret": secret})
+        self.assertEqual(self.harness.charm._state.jenkins_url, url)
+        self.assertEqual(self.harness.charm._state.agent_tokens[-1], secret)
+        self.assertEqual(self.harness.charm._state.agents[-1], expected_new_agent)
+        mock_configure_through_relation.assert_called()