installers/charm/lcm/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 from typing import NoReturn, Optional
  28
  29
  30 from ops.main import main
  31 from opslib.osm.charm import CharmedOsmBase, RelationsMissing
  32 from opslib.osm.interfaces.http import HttpClient
  33 from opslib.osm.interfaces.kafka import KafkaClient
  34 from opslib.osm.interfaces.mongo import MongoClient
  35 from opslib.osm.pod import ContainerV3Builder, PodSpecV3Builder
  36 from opslib.osm.validator import ModelValidator, validator
  37
  38
  39 logger = logging.getLogger(__name__)
  40
  41 PORT = 9999
  42
  43
  44 class ConfigModel(ModelValidator):
  45     vca_host: Optional[str]
  46     vca_port: Optional[int]
  47     vca_user: Optional[str]
  48     vca_secret: Optional[str]
  49     vca_pubkey: Optional[str]
  50     vca_cacert: Optional[str]
  51     vca_cloud: Optional[str]
  52     vca_k8s_cloud: Optional[str]
  53     database_commonkey: str
  54     mongodb_uri: Optional[str]
  55     log_level: str
  56     vca_apiproxy: Optional[str]
  57     # Model-config options
  58     vca_model_config_agent_metadata_url: Optional[str]
  59     vca_model_config_agent_stream: Optional[str]
  60     vca_model_config_apt_ftp_proxy: Optional[str]
  61     vca_model_config_apt_http_proxy: Optional[str]
  62     vca_model_config_apt_https_proxy: Optional[str]
  63     vca_model_config_apt_mirror: Optional[str]
  64     vca_model_config_apt_no_proxy: Optional[str]
  65     vca_model_config_automatically_retry_hooks: Optional[bool]
  66     vca_model_config_backup_dir: Optional[str]
  67     vca_model_config_cloudinit_userdata: Optional[str]
  68     vca_model_config_container_image_metadata_url: Optional[str]
  69     vca_model_config_container_image_stream: Optional[str]
  70     vca_model_config_container_inherit_properties: Optional[str]
  71     vca_model_config_container_networking_method: Optional[str]
  72     vca_model_config_default_series: Optional[str]
  73     vca_model_config_default_space: Optional[str]
  74     vca_model_config_development: Optional[bool]
  75     vca_model_config_disable_network_management: Optional[bool]
  76     vca_model_config_egress_subnets: Optional[str]
  77     vca_model_config_enable_os_refresh_update: Optional[bool]
  78     vca_model_config_enable_os_upgrade: Optional[bool]
  79     vca_model_config_fan_config: Optional[str]
  80     vca_model_config_firewall_mode: Optional[str]
  81     vca_model_config_ftp_proxy: Optional[str]
  82     vca_model_config_http_proxy: Optional[str]
  83     vca_model_config_https_proxy: Optional[str]
  84     vca_model_config_ignore_machine_addresses: Optional[bool]
  85     vca_model_config_image_metadata_url: Optional[str]
  86     vca_model_config_image_stream: Optional[str]
  87     vca_model_config_juju_ftp_proxy: Optional[str]
  88     vca_model_config_juju_http_proxy: Optional[str]
  89     vca_model_config_juju_https_proxy: Optional[str]
  90     vca_model_config_juju_no_proxy: Optional[str]
  91     vca_model_config_logforward_enabled: Optional[bool]
  92     vca_model_config_logging_config: Optional[str]
  93     vca_model_config_lxd_snap_channel: Optional[str]
  94     vca_model_config_max_action_results_age: Optional[str]
  95     vca_model_config_max_action_results_size: Optional[str]
  96     vca_model_config_max_status_history_age: Optional[str]
  97     vca_model_config_max_status_history_size: Optional[str]
  98     vca_model_config_net_bond_reconfigure_delay: Optional[str]
  99     vca_model_config_no_proxy: Optional[str]
 100     vca_model_config_provisioner_harvest_mode: Optional[str]
 101     vca_model_config_proxy_ssh: Optional[bool]
 102     vca_model_config_snap_http_proxy: Optional[str]
 103     vca_model_config_snap_https_proxy: Optional[str]
 104     vca_model_config_snap_store_assertions: Optional[str]
 105     vca_model_config_snap_store_proxy: Optional[str]
 106     vca_model_config_snap_store_proxy_url: Optional[str]
 107     vca_model_config_ssl_hostname_verification: Optional[bool]
 108     vca_model_config_test_mode: Optional[bool]
 109     vca_model_config_transmit_vendor_metrics: Optional[bool]
 110     vca_model_config_update_status_hook_interval: Optional[str]
 111     vca_stablerepourl: Optional[str]
 112     vca_helm_ca_certs: Optional[str]
 113
 114     @validator("log_level")
 115     def validate_log_level(cls, v):
 116         if v not in {"INFO", "DEBUG"}:
 117             raise ValueError("value must be INFO or DEBUG")
 118         return v
 119
 120     @validator("mongodb_uri")
 121     def validate_mongodb_uri(cls, v):
 122         if v and not v.startswith("mongodb://"):
 123             raise ValueError("mongodb_uri is not properly formed")
 124         return v
 125
 126
 127 class LcmCharm(CharmedOsmBase):
 128     def __init__(self, *args) -> NoReturn:
 129         super().__init__(*args, oci_image="image")
 130
 131         self.kafka_client = KafkaClient(self, "kafka")
 132         self.framework.observe(self.on["kafka"].relation_changed, self.configure_pod)
 133         self.framework.observe(self.on["kafka"].relation_broken, self.configure_pod)
 134
 135         self.mongodb_client = MongoClient(self, "mongodb")
 136         self.framework.observe(self.on["mongodb"].relation_changed, self.configure_pod)
 137         self.framework.observe(self.on["mongodb"].relation_broken, self.configure_pod)
 138
 139         self.ro_client = HttpClient(self, "ro")
 140         self.framework.observe(self.on["ro"].relation_changed, self.configure_pod)
 141         self.framework.observe(self.on["ro"].relation_broken, self.configure_pod)
 142
 143     def _check_missing_dependencies(self, config: ConfigModel):
 144         missing_relations = []
 145
 146         if self.kafka_client.is_missing_data_in_unit():
 147             missing_relations.append("kafka")
 148         if not config.mongodb_uri and self.mongodb_client.is_missing_data_in_unit():
 149             missing_relations.append("mongodb")
 150         if self.ro_client.is_missing_data_in_app():
 151             missing_relations.append("ro")
 152
 153         if missing_relations:
 154             raise RelationsMissing(missing_relations)
 155
 156     def build_pod_spec(self, image_info):
 157         # Validate config
 158         config = ConfigModel(**dict(self.config))
 159
 160         if config.mongodb_uri and not self.mongodb_client.is_missing_data_in_unit():
 161             raise Exception("Mongodb data cannot be provided via config and relation")
 162
 163         # Check relations
 164         self._check_missing_dependencies(config)
 165
 166         # Create Builder for the PodSpec
 167         pod_spec_builder = PodSpecV3Builder()
 168
 169         # Build Container
 170         container_builder = ContainerV3Builder(self.app.name, image_info)
 171         container_builder.add_port(name=self.app.name, port=PORT)
 172         container_builder.add_envs(
 173             {
 174                 # General configuration
 175                 "ALLOW_ANONYMOUS_LOGIN": "yes",
 176                 "OSMLCM_GLOBAL_LOGLEVEL": config.log_level,
 177                 # RO configuration
 178                 "OSMLCM_RO_HOST": self.ro_client.host,
 179                 "OSMLCM_RO_PORT": self.ro_client.port,
 180                 "OSMLCM_RO_TENANT": "osm",
 181                 # Kafka configuration
 182                 "OSMLCM_MESSAGE_DRIVER": "kafka",
 183                 "OSMLCM_MESSAGE_HOST": self.kafka_client.host,
 184                 "OSMLCM_MESSAGE_PORT": self.kafka_client.port,
 185                 # Database configuration
 186                 "OSMLCM_DATABASE_DRIVER": "mongo",
 187                 "OSMLCM_DATABASE_URI": config.mongodb_uri
 188                 or self.mongodb_client.connection_string,
 189                 "OSMLCM_DATABASE_COMMONKEY": config.database_commonkey,
 190                 # Storage configuration
 191                 "OSMLCM_STORAGE_DRIVER": "mongo",
 192                 "OSMLCM_STORAGE_PATH": "/app/storage",
 193                 "OSMLCM_STORAGE_COLLECTION": "files",
 194                 "OSMLCM_STORAGE_URI": config.mongodb_uri
 195                 or self.mongodb_client.connection_string,
 196                 "OSMLCM_VCA_STABLEREPOURL": config.vca_stablerepourl,
 197                 "OSMLCM_VCA_HELM_CA_CERTS": config.vca_helm_ca_certs,
 198             }
 199         )
 200         if config.vca_host:
 201             container_builder.add_envs(
 202                 {
 203                     # VCA configuration
 204                     "OSMLCM_VCA_HOST": config.vca_host,
 205                     "OSMLCM_VCA_PORT": config.vca_port,
 206                     "OSMLCM_VCA_USER": config.vca_user,
 207                     "OSMLCM_VCA_PUBKEY": config.vca_pubkey,
 208                     "OSMLCM_VCA_SECRET": config.vca_secret,
 209                     "OSMLCM_VCA_CACERT": config.vca_cacert,
 210                     "OSMLCM_VCA_CLOUD": config.vca_cloud,
 211                     "OSMLCM_VCA_K8S_CLOUD": config.vca_k8s_cloud,
 212                 }
 213             )
 214             if config.vca_apiproxy:
 215                 container_builder.add_env("OSMLCM_VCA_APIPROXY", config.vca_apiproxy)
 216
 217             model_config_envs = {
 218                 f"OSMLCM_{k.upper()}": v
 219                 for k, v in self.config.items()
 220                 if k.startswith("vca_model_config")
 221             }
 222             if model_config_envs:
 223                 container_builder.add_envs(model_config_envs)
 224         container = container_builder.build()
 225
 226         # Add container to pod spec
 227         pod_spec_builder.add_container(container)
 228
 229         return pod_spec_builder.build()
 230
 231
 232 if __name__ == "__main__":
 233     main(LcmCharm)
 234
 235
 236 # class ConfigurePodEvent(EventBase):
 237 #     """Configure Pod event"""
 238
 239 #     pass
 240
 241
 242 # class LcmEvents(CharmEvents):
 243 #     """LCM Events"""
 244
 245 #     configure_pod = EventSource(ConfigurePodEvent)
 246
 247
 248 # class LcmCharm(CharmBase):
 249 #     """LCM Charm."""
 250
 251 #     state = StoredState()
 252 #     on = LcmEvents()
 253
 254 #     def __init__(self, *args) -> NoReturn:
 255 #         """LCM Charm constructor."""
 256 #         super().__init__(*args)
 257
 258 #         # Internal state initialization
 259 #         self.state.set_default(pod_spec=None)
 260
 261 #         # Message bus data initialization
 262 #         self.state.set_default(message_host=None)
 263 #         self.state.set_default(message_port=None)
 264
 265 #         # Database data initialization
 266 #         self.state.set_default(database_uri=None)
 267
 268 #         # RO data initialization
 269 #         self.state.set_default(ro_host=None)
 270 #         self.state.set_default(ro_port=None)
 271
 272 #         self.port = LCM_PORT
 273 #         self.image = OCIImageResource(self, "image")
 274
 275 #         # Registering regular events
 276 #         self.framework.observe(self.on.start, self.configure_pod)
 277 #         self.framework.observe(self.on.config_changed, self.configure_pod)
 278 #         self.framework.observe(self.on.upgrade_charm, self.configure_pod)
 279
 280 #         # Registering custom internal events
 281 #         self.framework.observe(self.on.configure_pod, self.configure_pod)
 282
 283 #         # Registering required relation events
 284 #         self.framework.observe(
 285 #             self.on.kafka_relation_changed, self._on_kafka_relation_changed
 286 #         )
 287 #         self.framework.observe(
 288 #             self.on.mongodb_relation_changed, self._on_mongodb_relation_changed
 289 #         )
 290 #         self.framework.observe(
 291 #             self.on.ro_relation_changed, self._on_ro_relation_changed
 292 #         )
 293
 294 #         # Registering required relation broken events
 295 #         self.framework.observe(
 296 #             self.on.kafka_relation_broken, self._on_kafka_relation_broken
 297 #         )
 298 #         self.framework.observe(
 299 #             self.on.mongodb_relation_broken, self._on_mongodb_relation_broken
 300 #         )
 301 #         self.framework.observe(
 302 #             self.on.ro_relation_broken, self._on_ro_relation_broken
 303 #         )
 304
 305 #     def _on_kafka_relation_changed(self, event: EventBase) -> NoReturn:
 306 #         """Reads information about the kafka relation.
 307
 308 #         Args:
 309 #             event (EventBase): Kafka relation event.
 310 #         """
 311 #         message_host = event.relation.data[event.unit].get("host")
 312 #         message_port = event.relation.data[event.unit].get("port")
 313
 314 #         if (
 315 #             message_host
 316 #             and message_port
 317 #             and (
 318 #                 self.state.message_host != message_host
 319 #                 or self.state.message_port != message_port
 320 #             )
 321 #         ):
 322 #             self.state.message_host = message_host
 323 #             self.state.message_port = message_port
 324 #             self.on.configure_pod.emit()
 325
 326 #     def _on_kafka_relation_broken(self, event: EventBase) -> NoReturn:
 327 #         """Clears data from kafka relation.
 328
 329 #         Args:
 330 #             event (EventBase): Kafka relation event.
 331 #         """
 332 #         self.state.message_host = None
 333 #         self.state.message_port = None
 334 #         self.on.configure_pod.emit()
 335
 336 #     def _on_mongodb_relation_changed(self, event: EventBase) -> NoReturn:
 337 #         """Reads information about the DB relation.
 338
 339 #         Args:
 340 #             event (EventBase): DB relation event.
 341 #         """
 342 #         database_uri = event.relation.data[event.unit].get("connection_string")
 343
 344 #         if database_uri and self.state.database_uri != database_uri:
 345 #             self.state.database_uri = database_uri
 346 #             self.on.configure_pod.emit()
 347
 348 #     def _on_mongodb_relation_broken(self, event: EventBase) -> NoReturn:
 349 #         """Clears data from mongodb relation.
 350
 351 #         Args:
 352 #             event (EventBase): DB relation event.
 353 #         """
 354 #         self.state.database_uri = None
 355 #         self.on.configure_pod.emit()
 356
 357 #     def _on_ro_relation_changed(self, event: EventBase) -> NoReturn:
 358 #         """Reads information about the RO relation.
 359
 360 #         Args:
 361 #             event (EventBase): Keystone relation event.
 362 #         """
 363 #         ro_host = event.relation.data[event.unit].get("host")
 364 #         ro_port = event.relation.data[event.unit].get("port")
 365
 366 #         if (
 367 #             ro_host
 368 #             and ro_port
 369 #             and (self.state.ro_host != ro_host or self.state.ro_port != ro_port)
 370 #         ):
 371 #             self.state.ro_host = ro_host
 372 #             self.state.ro_port = ro_port
 373 #             self.on.configure_pod.emit()
 374
 375 #     def _on_ro_relation_broken(self, event: EventBase) -> NoReturn:
 376 #         """Clears data from ro relation.
 377
 378 #         Args:
 379 #             event (EventBase): Keystone relation event.
 380 #         """
 381 #         self.state.ro_host = None
 382 #         self.state.ro_port = None
 383 #         self.on.configure_pod.emit()
 384
 385 #     def _missing_relations(self) -> str:
 386 #         """Checks if there missing relations.
 387
 388 #         Returns:
 389 #             str: string with missing relations
 390 #         """
 391 #         data_status = {
 392 #             "kafka": self.state.message_host,
 393 #             "mongodb": self.state.database_uri,
 394 #             "ro": self.state.ro_host,
 395 #         }
 396
 397 #         missing_relations = [k for k, v in data_status.items() if not v]
 398
 399 #         return ", ".join(missing_relations)
 400
 401 #     @property
 402 #     def relation_state(self) -> Dict[str, Any]:
 403 #         """Collects relation state configuration for pod spec assembly.
 404
 405 #         Returns:
 406 #             Dict[str, Any]: relation state information.
 407 #         """
 408 #         relation_state = {
 409 #             "message_host": self.state.message_host,
 410 #             "message_port": self.state.message_port,
 411 #             "database_uri": self.state.database_uri,
 412 #             "ro_host": self.state.ro_host,
 413 #             "ro_port": self.state.ro_port,
 414 #         }
 415
 416 #         return relation_state
 417
 418 #     def configure_pod(self, event: EventBase) -> NoReturn:
 419 #         """Assemble the pod spec and apply it, if possible.
 420
 421 #         Args:
 422 #             event (EventBase): Hook or Relation event that started the
 423 #                                function.
 424 #         """
 425 #         if missing := self._missing_relations():
 426 #             self.unit.status = BlockedStatus(
 427 #                 "Waiting for {0} relation{1}".format(
 428 #                     missing, "s" if "," in missing else ""
 429 #                 )
 430 #             )
 431 #             return
 432
 433 #         if not self.unit.is_leader():
 434 #             self.unit.status = ActiveStatus("ready")
 435 #             return
 436
 437 #         self.unit.status = MaintenanceStatus("Assembling pod spec")
 438
 439 #         # Fetch image information
 440 #         try:
 441 #             self.unit.status = MaintenanceStatus("Fetching image information")
 442 #             image_info = self.image.fetch()
 443 #         except OCIImageResourceError:
 444 #             self.unit.status = BlockedStatus("Error fetching image information")
 445 #             return
 446
 447 #         try:
 448 #             pod_spec = make_pod_spec(
 449 #                 image_info,
 450 #                 self.model.config,
 451 #                 self.relation_state,
 452 #                 self.model.app.name,
 453 #                 self.port,
 454 #             )
 455 #         except ValueError as exc:
 456 #             logger.exception("Config/Relation data validation error")
 457 #             self.unit.status = BlockedStatus(str(exc))
 458 #             return
 459
 460 #         if self.state.pod_spec != pod_spec:
 461 #             self.model.pod.set_spec(pod_spec)
 462 #             self.state.pod_spec = pod_spec
 463
 464 #         self.unit.status = ActiveStatus("ready")
 465
 466
 467 # if __name__ == "__main__":
 468 #     main(LcmCharm)