installers/charm/pol/src/charm.py

   1 #!/usr/bin/env python3
   2 # Copyright 2021 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 # pylint: disable=E0213
  24
  25
  26 import logging
  27 import re
  28 from typing import NoReturn, Optional
  29
  30 from ops.main import main
  31 from opslib.osm.charm import CharmedOsmBase, RelationsMissing
  32 from opslib.osm.interfaces.kafka import KafkaClient
  33 from opslib.osm.interfaces.mongo import MongoClient
  34 from opslib.osm.interfaces.mysql import MysqlClient
  35 from opslib.osm.pod import (
  36     ContainerV3Builder,
  37     PodRestartPolicy,
  38     PodSpecV3Builder,
  39 )
  40 from opslib.osm.validator import ModelValidator, validator
  41
  42
  43 logger = logging.getLogger(__name__)
  44
  45 PORT = 9999
  46 DEFAULT_MYSQL_DATABASE = "pol"
  47
  48
  49 class ConfigModel(ModelValidator):
  50     log_level: str
  51     mongodb_uri: Optional[str]
  52     mysql_uri: Optional[str]
  53     image_pull_policy: str
  54     debug_mode: bool
  55     security_context: bool
  56
  57     @validator("log_level")
  58     def validate_log_level(cls, v):
  59         if v not in {"INFO", "DEBUG"}:
  60             raise ValueError("value must be INFO or DEBUG")
  61         return v
  62
  63     @validator("mongoddb_uri")
  64     def validate_mongodb_uri(cls, v):
  65         if v and not v.startswith("mongodb://"):
  66             raise ValueError("mongodb_uri is not properly formed")
  67         return v
  68
  69     @validator("mysql_uri")
  70     def validate_mysql_uri(cls, v):
  71         pattern = re.compile("^mysql:\/\/.*:.*@.*:\d+\/.*$")  # noqa: W605
  72         if v and not pattern.search(v):
  73             raise ValueError("mysql_uri is not properly formed")
  74         return v
  75
  76     @validator("image_pull_policy")
  77     def validate_image_pull_policy(cls, v):
  78         values = {
  79             "always": "Always",
  80             "ifnotpresent": "IfNotPresent",
  81             "never": "Never",
  82         }
  83         v = v.lower()
  84         if v not in values.keys():
  85             raise ValueError("value must be always, ifnotpresent or never")
  86         return values[v]
  87
  88
  89 class PolCharm(CharmedOsmBase):
  90     def __init__(self, *args) -> NoReturn:
  91         super().__init__(
  92             *args,
  93             oci_image="image",
  94             vscode_workspace=VSCODE_WORKSPACE,
  95         )
  96         if self.config.get("debug_mode"):
  97             self.enable_debug_mode(
  98                 pubkey=self.config.get("debug_pubkey"),
  99                 hostpaths={
 100                     "POL": {
 101                         "hostpath": self.config.get("debug_pol_local_path"),
 102                         "container-path": "/usr/lib/python3/dist-packages/osm_policy_module",
 103                     },
 104                     "osm_common": {
 105                         "hostpath": self.config.get("debug_common_local_path"),
 106                         "container-path": "/usr/lib/python3/dist-packages/osm_common",
 107                     },
 108                 },
 109             )
 110         self.kafka_client = KafkaClient(self, "kafka")
 111         self.framework.observe(self.on["kafka"].relation_changed, self.configure_pod)
 112         self.framework.observe(self.on["kafka"].relation_broken, self.configure_pod)
 113
 114         self.mongodb_client = MongoClient(self, "mongodb")
 115         self.framework.observe(self.on["mongodb"].relation_changed, self.configure_pod)
 116         self.framework.observe(self.on["mongodb"].relation_broken, self.configure_pod)
 117
 118         self.mysql_client = MysqlClient(self, "mysql")
 119         self.framework.observe(self.on["mysql"].relation_changed, self.configure_pod)
 120         self.framework.observe(self.on["mysql"].relation_broken, self.configure_pod)
 121
 122     def _check_missing_dependencies(self, config: ConfigModel):
 123         missing_relations = []
 124
 125         if (
 126             self.kafka_client.is_missing_data_in_unit()
 127             and self.kafka_client.is_missing_data_in_app()
 128         ):
 129             missing_relations.append("kafka")
 130         if not config.mongodb_uri and self.mongodb_client.is_missing_data_in_unit():
 131             missing_relations.append("mongodb")
 132         if not config.mysql_uri and self.mysql_client.is_missing_data_in_unit():
 133             missing_relations.append("mysql")
 134         if missing_relations:
 135             raise RelationsMissing(missing_relations)
 136
 137     def build_pod_spec(self, image_info):
 138         # Validate config
 139         config = ConfigModel(**dict(self.config))
 140
 141         if config.mongodb_uri and not self.mongodb_client.is_missing_data_in_unit():
 142             raise Exception("Mongodb data cannot be provided via config and relation")
 143         if config.mysql_uri and not self.mysql_client.is_missing_data_in_unit():
 144             raise Exception("Mysql data cannot be provided via config and relation")
 145
 146         # Check relations
 147         self._check_missing_dependencies(config)
 148
 149         security_context_enabled = (
 150             config.security_context if not config.debug_mode else False
 151         )
 152
 153         # Create Builder for the PodSpec
 154         pod_spec_builder = PodSpecV3Builder(
 155             enable_security_context=security_context_enabled
 156         )
 157
 158         # Add secrets to the pod
 159         mongodb_secret_name = f"{self.app.name}-mongodb-secret"
 160         pod_spec_builder.add_secret(
 161             mongodb_secret_name,
 162             {"uri": config.mongodb_uri or self.mongodb_client.connection_string},
 163         )
 164         mysql_secret_name = f"{self.app.name}-mysql-secret"
 165         pod_spec_builder.add_secret(
 166             mysql_secret_name,
 167             {
 168                 "uri": config.mysql_uri
 169                 or self.mysql_client.get_root_uri(DEFAULT_MYSQL_DATABASE)
 170             },
 171         )
 172
 173         # Build Container
 174         container_builder = ContainerV3Builder(
 175             self.app.name,
 176             image_info,
 177             config.image_pull_policy,
 178             run_as_non_root=security_context_enabled,
 179         )
 180         container_builder.add_port(name=self.app.name, port=PORT)
 181         container_builder.add_envs(
 182             {
 183                 # General configuration
 184                 "ALLOW_ANONYMOUS_LOGIN": "yes",
 185                 "OSMPOL_GLOBAL_LOGLEVEL": config.log_level,
 186                 # Kafka configuration
 187                 "OSMPOL_MESSAGE_DRIVER": "kafka",
 188                 "OSMPOL_MESSAGE_HOST": self.kafka_client.host,
 189                 "OSMPOL_MESSAGE_PORT": self.kafka_client.port,
 190                 # Database configuration
 191                 "OSMPOL_DATABASE_DRIVER": "mongo",
 192             }
 193         )
 194         container_builder.add_secret_envs(
 195             mongodb_secret_name, {"OSMPOL_DATABASE_URI": "uri"}
 196         )
 197         container_builder.add_secret_envs(
 198             mysql_secret_name, {"OSMPOL_SQL_DATABASE_URI": "uri"}
 199         )
 200         container = container_builder.build()
 201
 202         # Add Pod restart policy
 203         restart_policy = PodRestartPolicy()
 204         restart_policy.add_secrets(
 205             secret_names=(mongodb_secret_name, mysql_secret_name)
 206         )
 207         pod_spec_builder.set_restart_policy(restart_policy)
 208
 209         # Add container to pod spec
 210         pod_spec_builder.add_container(container)
 211
 212         return pod_spec_builder.build()
 213
 214
 215 VSCODE_WORKSPACE = {
 216     "folders": [
 217         {"path": "/usr/lib/python3/dist-packages/osm_policy_module"},
 218         {"path": "/usr/lib/python3/dist-packages/osm_common"},
 219     ],
 220     "settings": {},
 221     "launch": {
 222         "version": "0.2.0",
 223         "configurations": [
 224             {
 225                 "name": "POL",
 226                 "type": "python",
 227                 "request": "launch",
 228                 "module": "osm_policy_module.cmd.policy_module_agent",
 229                 "justMyCode": False,
 230             }
 231         ],
 232     },
 233 }
 234
 235
 236 if __name__ == "__main__":
 237     main(PolCharm)