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
 112     @validator("log_level")
 113     def validate_log_level(cls, v):
 114         if v not in {"INFO", "DEBUG"}:
 115             raise ValueError("value must be INFO or DEBUG")
 116         return v
 117
 118     @validator("mongodb_uri")
 119     def validate_mongodb_uri(cls, v):
 120         if v and not v.startswith("mongodb://"):
 121             raise ValueError("mongodb_uri is not properly formed")
 122         return v
 123
 124
 125 class LcmCharm(CharmedOsmBase):
 126     def __init__(self, *args) -> NoReturn:
 127         super().__init__(*args, oci_image="image")
 128
 129         self.kafka_client = KafkaClient(self, "kafka")
 130         self.framework.observe(self.on["kafka"].relation_changed, self.configure_pod)
 131         self.framework.observe(self.on["kafka"].relation_broken, self.configure_pod)
 132
 133         self.mongodb_client = MongoClient(self, "mongodb")
 134         self.framework.observe(self.on["mongodb"].relation_changed, self.configure_pod)
 135         self.framework.observe(self.on["mongodb"].relation_broken, self.configure_pod)
 136
 137         self.ro_client = HttpClient(self, "ro")
 138         self.framework.observe(self.on["ro"].relation_changed, self.configure_pod)
 139         self.framework.observe(self.on["ro"].relation_broken, self.configure_pod)
 140
 141     def _check_missing_dependencies(self, config: ConfigModel):
 142         missing_relations = []
 143
 144         if self.kafka_client.is_missing_data_in_unit():
 145             missing_relations.append("kafka")
 146         if not config.mongodb_uri and self.mongodb_client.is_missing_data_in_unit():
 147             missing_relations.append("mongodb")
 148         if self.ro_client.is_missing_data_in_app():
 149             missing_relations.append("ro")
 150
 151         if missing_relations:
 152             raise RelationsMissing(missing_relations)
 153
 154     def build_pod_spec(self, image_info):
 155         # Validate config
 156         config = ConfigModel(**dict(self.config))
 157
 158         if config.mongodb_uri and not self.mongodb_client.is_missing_data_in_unit():
 159             raise Exception("Mongodb data cannot be provided via config and relation")
 160
 161         # Check relations
 162         self._check_missing_dependencies(config)
 163
 164         # Create Builder for the PodSpec
 165         pod_spec_builder = PodSpecV3Builder()
 166
 167         # Build Container
 168         container_builder = ContainerV3Builder(self.app.name, image_info)
 169         container_builder.add_port(name=self.app.name, port=PORT)
 170         container_builder.add_envs(
 171             {
 172                 # General configuration
 173                 "ALLOW_ANONYMOUS_LOGIN": "yes",
 174                 "OSMLCM_GLOBAL_LOGLEVEL": config.log_level,
 175                 # RO configuration
 176                 "OSMLCM_RO_HOST": self.ro_client.host,
 177                 "OSMLCM_RO_PORT": self.ro_client.port,
 178                 "OSMLCM_RO_TENANT": "osm",
 179                 # Kafka configuration
 180                 "OSMLCM_MESSAGE_DRIVER": "kafka",
 181                 "OSMLCM_MESSAGE_HOST": self.kafka_client.host,
 182                 "OSMLCM_MESSAGE_PORT": self.kafka_client.port,
 183                 # Database configuration
 184                 "OSMLCM_DATABASE_DRIVER": "mongo",
 185                 "OSMLCM_DATABASE_URI": config.mongodb_uri
 186                 or self.mongodb_client.connection_string,
 187                 "OSMLCM_DATABASE_COMMONKEY": config.database_commonkey,
 188                 # Storage configuration
 189                 "OSMLCM_STORAGE_DRIVER": "mongo",
 190                 "OSMLCM_STORAGE_PATH": "/app/storage",
 191                 "OSMLCM_STORAGE_COLLECTION": "files",
 192                 "OSMLCM_STORAGE_URI": self.mongodb_client.connection_string,
 193             }
 194         )
 195         if config.vca_host:
 196             container_builder.add_envs(
 197                 {
 198                     # VCA configuration
 199                     "OSMLCM_VCA_HOST": config.vca_host,
 200                     "OSMLCM_VCA_PORT": config.vca_port,
 201                     "OSMLCM_VCA_USER": config.vca_user,
 202                     "OSMLCM_VCA_PUBKEY": config.vca_pubkey,
 203                     "OSMLCM_VCA_SECRET": config.vca_secret,
 204                     "OSMLCM_VCA_CACERT": config.vca_cacert,
 205                     "OSMLCM_VCA_CLOUD": config.vca_cloud,
 206                     "OSMLCM_VCA_K8S_CLOUD": config.vca_k8s_cloud,
 207                 }
 208             )
 209             if config.vca_apiproxy:
 210                 container_builder.add_env("OSMLCM_VCA_APIPROXY", config.vca_apiproxy)
 211
 212             model_config_envs = {
 213                 f"OSMLCM_{k.upper()}": v
 214                 for k, v in self.config.items()
 215                 if k.startswith("vca_model_config")
 216             }
 217             if model_config_envs:
 218                 container_builder.add_envs(model_config_envs)
 219         container = container_builder.build()
 220
 221         # Add container to pod spec
 222         pod_spec_builder.add_container(container)
 223
 224         return pod_spec_builder.build()
 225
 226
 227 if __name__ == "__main__":
 228     main(LcmCharm)
 229
 230
 231 # class ConfigurePodEvent(EventBase):
 232 #     """Configure Pod event"""
 233
 234 #     pass
 235
 236
 237 # class LcmEvents(CharmEvents):
 238 #     """LCM Events"""
 239
 240 #     configure_pod = EventSource(ConfigurePodEvent)
 241
 242
 243 # class LcmCharm(CharmBase):
 244 #     """LCM Charm."""
 245
 246 #     state = StoredState()
 247 #     on = LcmEvents()
 248
 249 #     def __init__(self, *args) -> NoReturn:
 250 #         """LCM Charm constructor."""
 251 #         super().__init__(*args)
 252
 253 #         # Internal state initialization
 254 #         self.state.set_default(pod_spec=None)
 255
 256 #         # Message bus data initialization
 257 #         self.state.set_default(message_host=None)
 258 #         self.state.set_default(message_port=None)
 259
 260 #         # Database data initialization
 261 #         self.state.set_default(database_uri=None)
 262
 263 #         # RO data initialization
 264 #         self.state.set_default(ro_host=None)
 265 #         self.state.set_default(ro_port=None)
 266
 267 #         self.port = LCM_PORT
 268 #         self.image = OCIImageResource(self, "image")
 269
 270 #         # Registering regular events
 271 #         self.framework.observe(self.on.start, self.configure_pod)
 272 #         self.framework.observe(self.on.config_changed, self.configure_pod)
 273 #         self.framework.observe(self.on.upgrade_charm, self.configure_pod)
 274
 275 #         # Registering custom internal events
 276 #         self.framework.observe(self.on.configure_pod, self.configure_pod)
 277
 278 #         # Registering required relation events
 279 #         self.framework.observe(
 280 #             self.on.kafka_relation_changed, self._on_kafka_relation_changed
 281 #         )
 282 #         self.framework.observe(
 283 #             self.on.mongodb_relation_changed, self._on_mongodb_relation_changed
 284 #         )
 285 #         self.framework.observe(
 286 #             self.on.ro_relation_changed, self._on_ro_relation_changed
 287 #         )
 288
 289 #         # Registering required relation broken events
 290 #         self.framework.observe(
 291 #             self.on.kafka_relation_broken, self._on_kafka_relation_broken
 292 #         )
 293 #         self.framework.observe(
 294 #             self.on.mongodb_relation_broken, self._on_mongodb_relation_broken
 295 #         )
 296 #         self.framework.observe(
 297 #             self.on.ro_relation_broken, self._on_ro_relation_broken
 298 #         )
 299
 300 #     def _on_kafka_relation_changed(self, event: EventBase) -> NoReturn:
 301 #         """Reads information about the kafka relation.
 302
 303 #         Args:
 304 #             event (EventBase): Kafka relation event.
 305 #         """
 306 #         message_host = event.relation.data[event.unit].get("host")
 307 #         message_port = event.relation.data[event.unit].get("port")
 308
 309 #         if (
 310 #             message_host
 311 #             and message_port
 312 #             and (
 313 #                 self.state.message_host != message_host
 314 #                 or self.state.message_port != message_port
 315 #             )
 316 #         ):
 317 #             self.state.message_host = message_host
 318 #             self.state.message_port = message_port
 319 #             self.on.configure_pod.emit()
 320
 321 #     def _on_kafka_relation_broken(self, event: EventBase) -> NoReturn:
 322 #         """Clears data from kafka relation.
 323
 324 #         Args:
 325 #             event (EventBase): Kafka relation event.
 326 #         """
 327 #         self.state.message_host = None
 328 #         self.state.message_port = None
 329 #         self.on.configure_pod.emit()
 330
 331 #     def _on_mongodb_relation_changed(self, event: EventBase) -> NoReturn:
 332 #         """Reads information about the DB relation.
 333
 334 #         Args:
 335 #             event (EventBase): DB relation event.
 336 #         """
 337 #         database_uri = event.relation.data[event.unit].get("connection_string")
 338
 339 #         if database_uri and self.state.database_uri != database_uri:
 340 #             self.state.database_uri = database_uri
 341 #             self.on.configure_pod.emit()
 342
 343 #     def _on_mongodb_relation_broken(self, event: EventBase) -> NoReturn:
 344 #         """Clears data from mongodb relation.
 345
 346 #         Args:
 347 #             event (EventBase): DB relation event.
 348 #         """
 349 #         self.state.database_uri = None
 350 #         self.on.configure_pod.emit()
 351
 352 #     def _on_ro_relation_changed(self, event: EventBase) -> NoReturn:
 353 #         """Reads information about the RO relation.
 354
 355 #         Args:
 356 #             event (EventBase): Keystone relation event.
 357 #         """
 358 #         ro_host = event.relation.data[event.unit].get("host")
 359 #         ro_port = event.relation.data[event.unit].get("port")
 360
 361 #         if (
 362 #             ro_host
 363 #             and ro_port
 364 #             and (self.state.ro_host != ro_host or self.state.ro_port != ro_port)
 365 #         ):
 366 #             self.state.ro_host = ro_host
 367 #             self.state.ro_port = ro_port
 368 #             self.on.configure_pod.emit()
 369
 370 #     def _on_ro_relation_broken(self, event: EventBase) -> NoReturn:
 371 #         """Clears data from ro relation.
 372
 373 #         Args:
 374 #             event (EventBase): Keystone relation event.
 375 #         """
 376 #         self.state.ro_host = None
 377 #         self.state.ro_port = None
 378 #         self.on.configure_pod.emit()
 379
 380 #     def _missing_relations(self) -> str:
 381 #         """Checks if there missing relations.
 382
 383 #         Returns:
 384 #             str: string with missing relations
 385 #         """
 386 #         data_status = {
 387 #             "kafka": self.state.message_host,
 388 #             "mongodb": self.state.database_uri,
 389 #             "ro": self.state.ro_host,
 390 #         }
 391
 392 #         missing_relations = [k for k, v in data_status.items() if not v]
 393
 394 #         return ", ".join(missing_relations)
 395
 396 #     @property
 397 #     def relation_state(self) -> Dict[str, Any]:
 398 #         """Collects relation state configuration for pod spec assembly.
 399
 400 #         Returns:
 401 #             Dict[str, Any]: relation state information.
 402 #         """
 403 #         relation_state = {
 404 #             "message_host": self.state.message_host,
 405 #             "message_port": self.state.message_port,
 406 #             "database_uri": self.state.database_uri,
 407 #             "ro_host": self.state.ro_host,
 408 #             "ro_port": self.state.ro_port,
 409 #         }
 410
 411 #         return relation_state
 412
 413 #     def configure_pod(self, event: EventBase) -> NoReturn:
 414 #         """Assemble the pod spec and apply it, if possible.
 415
 416 #         Args:
 417 #             event (EventBase): Hook or Relation event that started the
 418 #                                function.
 419 #         """
 420 #         if missing := self._missing_relations():
 421 #             self.unit.status = BlockedStatus(
 422 #                 "Waiting for {0} relation{1}".format(
 423 #                     missing, "s" if "," in missing else ""
 424 #                 )
 425 #             )
 426 #             return
 427
 428 #         if not self.unit.is_leader():
 429 #             self.unit.status = ActiveStatus("ready")
 430 #             return
 431
 432 #         self.unit.status = MaintenanceStatus("Assembling pod spec")
 433
 434 #         # Fetch image information
 435 #         try:
 436 #             self.unit.status = MaintenanceStatus("Fetching image information")
 437 #             image_info = self.image.fetch()
 438 #         except OCIImageResourceError:
 439 #             self.unit.status = BlockedStatus("Error fetching image information")
 440 #             return
 441
 442 #         try:
 443 #             pod_spec = make_pod_spec(
 444 #                 image_info,
 445 #                 self.model.config,
 446 #                 self.relation_state,
 447 #                 self.model.app.name,
 448 #                 self.port,
 449 #             )
 450 #         except ValueError as exc:
 451 #             logger.exception("Config/Relation data validation error")
 452 #             self.unit.status = BlockedStatus(str(exc))
 453 #             return
 454
 455 #         if self.state.pod_spec != pod_spec:
 456 #             self.model.pod.set_spec(pod_spec)
 457 #             self.state.pod_spec = pod_spec
 458
 459 #         self.unit.status = ActiveStatus("ready")
 460
 461
 462 # if __name__ == "__main__":
 463 #     main(LcmCharm)