installers/charm/osm-ro/src/charm.py

   1 #!/usr/bin/env python3
   2 # Copyright 2022 Canonical Ltd.
   3 #
   4 # Licensed under the Apache License, Version 2.0 (the "License"); you may
   5 # not use this file except in compliance with the License. You may obtain
   6 # a copy of the License at
   7 #
   8 #         http://www.apache.org/licenses/LICENSE-2.0
   9 #
  10 # Unless required by applicable law or agreed to in writing, software
  11 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  12 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  13 # License for the specific language governing permissions and limitations
  14 # under the License.
  15 #
  16 # For those usages not covered by the Apache License, Version 2.0 please
  17 # contact: legal@canonical.com
  18 #
  19 # To get in touch with the maintainers, please contact:
  20 # osm-charmers@lists.launchpad.net
  21 #
  22 #
  23 # Learn more at: https://juju.is/docs/sdk
  24
  25 """OSM RO charm.
  26
  27 See more: https://charmhub.io/osm
  28 """
  29
  30 import base64
  31 import logging
  32 from typing import Any, Dict
  33
  34 from charms.kafka_k8s.v0.kafka import KafkaEvents, KafkaRequires
  35 from charms.observability_libs.v1.kubernetes_service_patch import KubernetesServicePatch
  36 from charms.osm_libs.v0.utils import (
  37     CharmError,
  38     DebugMode,
  39     HostPath,
  40     check_container_ready,
  41     check_service_active,
  42 )
  43 from charms.osm_ro.v0.ro import RoProvides
  44 from lightkube.models.core_v1 import ServicePort
  45 from ops.charm import ActionEvent, CharmBase, RelationJoinedEvent
  46 from ops.framework import StoredState
  47 from ops.main import main
  48 from ops.model import ActiveStatus, Container
  49
  50 from legacy_interfaces import MongoClient
  51
  52 HOSTPATHS = [
  53     HostPath(
  54         config="ro-hostpath",
  55         container_path="/usr/lib/python3/dist-packages/osm_ro",
  56     ),
  57     HostPath(
  58         config="common-hostpath",
  59         container_path="/usr/lib/python3/dist-packages/osm_common",
  60     ),
  61 ]
  62 SERVICE_PORT = 9090
  63 USER = GROUP = "appuser"
  64
  65 logger = logging.getLogger(__name__)
  66
  67
  68 def decode(content: str):
  69     """Base64 decoding of a string."""
  70     return base64.b64decode(content.encode("utf-8")).decode("utf-8")
  71
  72
  73 class OsmRoCharm(CharmBase):
  74     """OSM RO Kubernetes sidecar charm."""
  75
  76     on = KafkaEvents()
  77     service_name = "ro"
  78     _stored = StoredState()
  79
  80     def __init__(self, *args):
  81         super().__init__(*args)
  82         self._stored.set_default(certificates=set())
  83         self.kafka = KafkaRequires(self)
  84         self.mongodb_client = MongoClient(self, "mongodb")
  85         self._observe_charm_events()
  86         self._patch_k8s_service()
  87         self.ro = RoProvides(self)
  88         self.container: Container = self.unit.get_container("ro")
  89         self.debug_mode = DebugMode(self, self._stored, self.container, HOSTPATHS)
  90
  91     # ---------------------------------------------------------------------------
  92     #   Handlers for Charm Events
  93     # ---------------------------------------------------------------------------
  94
  95     def _on_config_changed(self, _) -> None:
  96         """Handler for the config-changed event."""
  97         try:
  98             self._validate_config()
  99             self._check_relations()
 100             # Check if the container is ready.
 101             # Eventually it will become ready after the first pebble-ready event.
 102             check_container_ready(self.container)
 103
 104             self._configure_certificates()
 105             if not self.debug_mode.started:
 106                 self._configure_service()
 107             self._update_ro_relation()
 108
 109             # Update charm status
 110             self._on_update_status()
 111         except CharmError as e:
 112             logger.debug(e.message)
 113             self.unit.status = e.status
 114
 115     def _on_update_status(self, _=None) -> None:
 116         """Handler for the update-status event."""
 117         try:
 118             self._validate_config()
 119             self._check_relations()
 120             check_container_ready(self.container)
 121             if self.debug_mode.started:
 122                 return
 123             check_service_active(self.container, self.service_name)
 124             self.unit.status = ActiveStatus()
 125         except CharmError as e:
 126             logger.debug(e.message)
 127             self.unit.status = e.status
 128
 129     def _on_required_relation_broken(self, _) -> None:
 130         """Handler for the kafka-broken event."""
 131         try:
 132             check_container_ready(self.container)
 133             check_service_active(self.container, "ro")
 134             self.container.stop("ro")
 135         except CharmError:
 136             pass
 137
 138         self._on_update_status()
 139
 140     def _update_ro_relation(self, event: RelationJoinedEvent = None) -> None:
 141         """Handler for the ro-relation-joined event."""
 142         try:
 143             if self.unit.is_leader():
 144                 check_container_ready(self.container)
 145                 check_service_active(self.container, "ro")
 146                 self.ro.set_host_info(
 147                     self.app.name, SERVICE_PORT, event.relation if event else None
 148                 )
 149         except CharmError as e:
 150             self.unit.status = e.status
 151
 152     def _on_get_debug_mode_information_action(self, event: ActionEvent) -> None:
 153         """Handler for the get-debug-mode-information action event."""
 154         if not self.debug_mode.started:
 155             event.fail(
 156                 f"debug-mode has not started. Hint: juju config {self.app.name} debug-mode=true"
 157             )
 158             return
 159
 160         debug_info = {"command": self.debug_mode.command, "password": self.debug_mode.password}
 161         event.set_results(debug_info)
 162
 163     # ---------------------------------------------------------------------------
 164     #   Validation and configuration and more
 165     # ---------------------------------------------------------------------------
 166
 167     def _patch_k8s_service(self) -> None:
 168         port = ServicePort(SERVICE_PORT, name=f"{self.app.name}")
 169         self.service_patcher = KubernetesServicePatch(self, [port])
 170
 171     def _observe_charm_events(self) -> None:
 172         event_handler_mapping = {
 173             # Core lifecycle events
 174             self.on.ro_pebble_ready: self._on_config_changed,
 175             self.on.config_changed: self._on_config_changed,
 176             self.on.update_status: self._on_update_status,
 177             # Relation events
 178             self.on.kafka_available: self._on_config_changed,
 179             self.on["kafka"].relation_broken: self._on_required_relation_broken,
 180             self.on["mongodb"].relation_changed: self._on_config_changed,
 181             self.on["mongodb"].relation_broken: self._on_required_relation_broken,
 182             self.on.ro_relation_joined: self._update_ro_relation,
 183             # Action events
 184             self.on.get_debug_mode_information_action: self._on_get_debug_mode_information_action,
 185         }
 186
 187         for event, handler in event_handler_mapping.items():
 188             self.framework.observe(event, handler)
 189
 190     def _validate_config(self) -> None:
 191         """Validate charm configuration.
 192
 193         Raises:
 194             CharmError: if charm configuration is invalid.
 195         """
 196         logger.debug("validating charm config")
 197         if self.config["log-level"].upper() not in [
 198             "TRACE",
 199             "DEBUG",
 200             "INFO",
 201             "WARN",
 202             "ERROR",
 203             "FATAL",
 204         ]:
 205             raise CharmError("invalid value for log-level option")
 206
 207         refresh_period = self.config.get("period_refresh_active")
 208         if refresh_period and refresh_period < 60 and refresh_period != -1:
 209             raise ValueError(
 210                 "Refresh Period is too tight, insert >= 60 seconds or disable using -1"
 211             )
 212
 213     def _check_relations(self) -> None:
 214         """Validate charm relations.
 215
 216         Raises:
 217             CharmError: if charm configuration is invalid.
 218         """
 219         logger.debug("check for missing relations")
 220         missing_relations = []
 221
 222         if not self.kafka.host or not self.kafka.port:
 223             missing_relations.append("kafka")
 224         if self.mongodb_client.is_missing_data_in_unit():
 225             missing_relations.append("mongodb")
 226
 227         if missing_relations:
 228             relations_str = ", ".join(missing_relations)
 229             one_relation_missing = len(missing_relations) == 1
 230             error_msg = f'need {relations_str} relation{"" if one_relation_missing else "s"}'
 231             logger.warning(error_msg)
 232             raise CharmError(error_msg)
 233
 234     def _configure_certificates(self) -> None:
 235         """Push certificates to the RO container."""
 236         if not (certificate_config := self.config.get("certificates")):
 237             return
 238
 239         certificates_list = certificate_config.split(",")
 240         updated_certificates = set()
 241
 242         for certificate in certificates_list:
 243             if ":" not in certificate:
 244                 continue
 245             name, content = certificate.split(":")
 246             content = decode(content)
 247             self.container.push(
 248                 f"/certs/{name}",
 249                 content,
 250                 permissions=0o400,
 251                 make_dirs=True,
 252                 user=USER,
 253                 group=GROUP,
 254             )
 255             updated_certificates.add(name)
 256             self._stored.certificates.add(name)
 257             logger.info(f"certificate {name} pushed successfully")
 258
 259         stored_certificates = {c for c in self._stored.certificates}
 260         for certificate_to_remove in stored_certificates.difference(updated_certificates):
 261             self.container.remove_path(f"/certs/{certificate_to_remove}")
 262             self._stored.certificates.remove(certificate_to_remove)
 263             logger.info(f"certificate {certificate_to_remove} removed successfully")
 264
 265     def _configure_service(self) -> None:
 266         """Add Pebble layer with the ro service."""
 267         logger.debug(f"configuring {self.app.name} service")
 268         self.container.add_layer("ro", self._get_layer(), combine=True)
 269         self.container.replan()
 270
 271     def _get_layer(self) -> Dict[str, Any]:
 272         """Get layer for Pebble."""
 273         return {
 274             "summary": "ro layer",
 275             "description": "pebble config layer for ro",
 276             "services": {
 277                 "ro": {
 278                     "override": "replace",
 279                     "summary": "ro service",
 280                     "command": "python3 -u -m osm_ng_ro.ro_main",
 281                     "startup": "enabled",
 282                     "user": USER,
 283                     "group": GROUP,
 284                     "environment": {
 285                         # General configuration
 286                         "OSMRO_LOG_LEVEL": self.config["log-level"].upper(),
 287                         # Kafka configuration
 288                         "OSMRO_MESSAGE_HOST": self.kafka.host,
 289                         "OSMRO_MESSAGE_PORT": self.kafka.port,
 290                         "OSMRO_MESSAGE_DRIVER": "kafka",
 291                         # Database configuration
 292                         "OSMRO_DATABASE_DRIVER": "mongo",
 293                         "OSMRO_DATABASE_URI": self.mongodb_client.connection_string,
 294                         "OSMRO_DATABASE_COMMONKEY": self.config["database-commonkey"],
 295                         # Storage configuration
 296                         "OSMRO_STORAGE_DRIVER": "mongo",
 297                         "OSMRO_STORAGE_PATH": "/app/storage",
 298                         "OSMRO_STORAGE_COLLECTION": "files",
 299                         "OSMRO_STORAGE_URI": self.mongodb_client.connection_string,
 300                         "OSMRO_PERIOD_REFRESH_ACTIVE": self.config.get("period_refresh_active")
 301                         or 60,
 302                     },
 303                 }
 304             },
 305         }
 306
 307
 308 if __name__ == "__main__":  # pragma: no cover
 309     main(OsmRoCharm)