X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=installers%2Fcharm%2Fmon%2Fsrc%2Fcharm.py;h=db047c0be964a30c8a52b456b213e3964983445a;hb=5ec6be5562a16c472a10db91b5a28e852cdc62ad;hp=98c3297be76dc239af55b6928c7860424a671b7d;hpb=49379ced23b5e344a773ce77ac9cb59c1864e19b;p=osm%2Fdevops.git diff --git a/installers/charm/mon/src/charm.py b/installers/charm/mon/src/charm.py index 98c3297b..db047c0b 100755 --- a/installers/charm/mon/src/charm.py +++ b/installers/charm/mon/src/charm.py @@ -23,26 +23,24 @@ # pylint: disable=E0213 +import base64 import logging -from typing import NoReturn +from typing import NoReturn, Optional -from ops.main import main +from charms.kafka_k8s.v0.kafka import KafkaEvents, KafkaRequires +from ops.main import main from opslib.osm.charm import CharmedOsmBase, RelationsMissing - +from opslib.osm.interfaces.keystone import KeystoneClient +from opslib.osm.interfaces.mongo import MongoClient +from opslib.osm.interfaces.prometheus import PrometheusClient from opslib.osm.pod import ( ContainerV3Builder, + FilesV3Builder, + PodRestartPolicy, PodSpecV3Builder, ) - -from opslib.osm.validator import ( - ModelValidator, - validator, -) - -from opslib.osm.interfaces.kafka import KafkaClient -from opslib.osm.interfaces.mongo import MongoClient -from opslib.osm.interfaces.prometheus import PrometheusClient +from opslib.osm.validator import ModelValidator, validator logger = logging.getLogger(__name__) @@ -50,20 +48,47 @@ logger = logging.getLogger(__name__) PORT = 8000 +def _check_certificate_data(name: str, content: str): + if not name or not content: + raise ValueError("certificate name and content must be a non-empty string") + + +def _extract_certificates(certs_config: str): + certificates = {} + if certs_config: + cert_list = certs_config.split(",") + for cert in cert_list: + name, content = cert.split(":") + _check_certificate_data(name, content) + certificates[name] = content + return certificates + + +def decode(content: str): + return base64.b64decode(content.encode("utf-8")).decode("utf-8") + + class ConfigModel(ModelValidator): + keystone_enabled: bool vca_host: str vca_user: str - vca_password: str + vca_secret: str vca_cacert: str database_commonkey: str + mongodb_uri: Optional[str] log_level: str openstack_default_granularity: int global_request_timeout: int collector_interval: int + vm_infra_metrics: bool evaluator_interval: int grafana_url: str grafana_user: str grafana_password: str + certificates: Optional[str] + image_pull_policy: str + debug_mode: bool + security_context: bool @validator("log_level") def validate_log_level(cls, v): @@ -71,14 +96,66 @@ class ConfigModel(ModelValidator): raise ValueError("value must be INFO or DEBUG") return v + @validator("certificates") + def validate_certificates(cls, v): + # Raises an exception if it cannot extract the certificates + _extract_certificates(v) + return v + + @validator("mongodb_uri") + def validate_mongodb_uri(cls, v): + if v and not v.startswith("mongodb://"): + raise ValueError("mongodb_uri is not properly formed") + return v + + @validator("image_pull_policy") + def validate_image_pull_policy(cls, v): + values = { + "always": "Always", + "ifnotpresent": "IfNotPresent", + "never": "Never", + } + v = v.lower() + if v not in values.keys(): + raise ValueError("value must be always, ifnotpresent or never") + return values[v] + + @property + def certificates_dict(cls): + return _extract_certificates(cls.certificates) if cls.certificates else {} + class MonCharm(CharmedOsmBase): - def __init__(self, *args) -> NoReturn: - super().__init__(*args, oci_image="image") - self.kafka_client = KafkaClient(self, "kafka") - self.framework.observe(self.on["kafka"].relation_changed, self.configure_pod) - self.framework.observe(self.on["kafka"].relation_broken, self.configure_pod) + on = KafkaEvents() + + def __init__(self, *args) -> NoReturn: + super().__init__( + *args, + oci_image="image", + vscode_workspace=VSCODE_WORKSPACE, + ) + if self.config.get("debug_mode"): + self.enable_debug_mode( + pubkey=self.config.get("debug_pubkey"), + hostpaths={ + "MON": { + "hostpath": self.config.get("debug_mon_local_path"), + "container-path": "/usr/lib/python3/dist-packages/osm_mon", + }, + "N2VC": { + "hostpath": self.config.get("debug_n2vc_local_path"), + "container-path": "/usr/lib/python3/dist-packages/n2vc", + }, + "osm_common": { + "hostpath": self.config.get("debug_common_local_path"), + "container-path": "/usr/lib/python3/dist-packages/osm_common", + }, + }, + ) + self.kafka = KafkaRequires(self) + self.framework.observe(self.on.kafka_available, self.configure_pod) + self.framework.observe(self.on.kafka_broken, self.configure_pod) self.mongodb_client = MongoClient(self, "mongodb") self.framework.observe(self.on["mongodb"].relation_changed, self.configure_pod) @@ -92,28 +169,96 @@ class MonCharm(CharmedOsmBase): self.on["prometheus"].relation_broken, self.configure_pod ) + self.keystone_client = KeystoneClient(self, "keystone") + self.framework.observe(self.on["keystone"].relation_changed, self.configure_pod) + self.framework.observe(self.on["keystone"].relation_broken, self.configure_pod) + def _check_missing_dependencies(self, config: ConfigModel): missing_relations = [] - if self.kafka_client.is_missing_data_in_unit(): + if not self.kafka.host or not self.kafka.port: missing_relations.append("kafka") - if self.mongodb_client.is_missing_data_in_unit(): + if not config.mongodb_uri and self.mongodb_client.is_missing_data_in_unit(): missing_relations.append("mongodb") if self.prometheus_client.is_missing_data_in_app(): missing_relations.append("prometheus") + if config.keystone_enabled: + if self.keystone_client.is_missing_data_in_app(): + missing_relations.append("keystone") if missing_relations: raise RelationsMissing(missing_relations) + def _build_cert_files( + self, + config: ConfigModel, + ): + cert_files_builder = FilesV3Builder() + for name, content in config.certificates_dict.items(): + cert_files_builder.add_file(name, decode(content), mode=0o600) + return cert_files_builder.build() + def build_pod_spec(self, image_info): # Validate config config = ConfigModel(**dict(self.config)) + + if config.mongodb_uri and not self.mongodb_client.is_missing_data_in_unit(): + raise Exception("Mongodb data cannot be provided via config and relation") + # Check relations self._check_missing_dependencies(config) + + security_context_enabled = ( + config.security_context if not config.debug_mode else False + ) + # Create Builder for the PodSpec - pod_spec_builder = PodSpecV3Builder() + pod_spec_builder = PodSpecV3Builder( + enable_security_context=security_context_enabled + ) + + # Add secrets to the pod + mongodb_secret_name = f"{self.app.name}-mongodb-secret" + pod_spec_builder.add_secret( + mongodb_secret_name, + { + "uri": config.mongodb_uri or self.mongodb_client.connection_string, + "commonkey": config.database_commonkey, + }, + ) + grafana_secret_name = f"{self.app.name}-grafana-secret" + pod_spec_builder.add_secret( + grafana_secret_name, + { + "url": config.grafana_url, + "user": config.grafana_user, + "password": config.grafana_password, + }, + ) + + vca_secret_name = f"{self.app.name}-vca-secret" + pod_spec_builder.add_secret( + vca_secret_name, + { + "host": config.vca_host, + "user": config.vca_user, + "secret": config.vca_secret, + "cacert": config.vca_cacert, + }, + ) + # Build Container - container_builder = ContainerV3Builder(self.app.name, image_info) + container_builder = ContainerV3Builder( + self.app.name, + image_info, + config.image_pull_policy, + run_as_non_root=security_context_enabled, + ) + certs_files = self._build_cert_files(config) + + if certs_files: + container_builder.add_volume_config("certs", "/certs", certs_files) + container_builder.add_port(name=self.app.name, port=PORT) container_builder.add_envs( { @@ -123,33 +268,129 @@ class MonCharm(CharmedOsmBase): "OSMMON_GLOBAL_REQUEST_TIMEOUT": config.global_request_timeout, "OSMMON_GLOBAL_LOGLEVEL": config.log_level, "OSMMON_COLLECTOR_INTERVAL": config.collector_interval, + "OSMMON_COLLECTOR_VM_INFRA_METRICS": config.vm_infra_metrics, "OSMMON_EVALUATOR_INTERVAL": config.evaluator_interval, # Kafka configuration "OSMMON_MESSAGE_DRIVER": "kafka", - "OSMMON_MESSAGE_HOST": self.kafka_client.host, - "OSMMON_MESSAGE_PORT": self.kafka_client.port, + "OSMMON_MESSAGE_HOST": self.kafka.host, + "OSMMON_MESSAGE_PORT": self.kafka.port, # Database configuration "OSMMON_DATABASE_DRIVER": "mongo", - "OSMMON_DATABASE_URI": self.mongodb_client.connection_string, - "OSMMON_DATABASE_COMMONKEY": config.database_commonkey, # Prometheus configuration "OSMMON_PROMETHEUS_URL": f"http://{self.prometheus_client.hostname}:{self.prometheus_client.port}", - # VCA configuration - "OSMMON_VCA_HOST": config.vca_host, - "OSMMON_VCA_USER": config.vca_user, - "OSMMON_VCA_SECRET": config.vca_password, - "OSMMON_VCA_CACERT": config.vca_cacert, - "OSMMON_GRAFANA_URL": config.grafana_url, - "OSMMON_GRAFANA_USER": config.grafana_user, - "OSMMON_GRAFANA_PASSWORD": config.grafana_password, } ) - + prometheus_user = self.prometheus_client.user + prometheus_password = self.prometheus_client.password + if prometheus_user and prometheus_password: + container_builder.add_envs( + { + "OSMMON_PROMETHEUS_USER": prometheus_user, + "OSMMON_PROMETHEUS_PASSWORD": prometheus_password, + } + ) + container_builder.add_secret_envs( + secret_name=mongodb_secret_name, + envs={ + "OSMMON_DATABASE_URI": "uri", + "OSMMON_DATABASE_COMMONKEY": "commonkey", + }, + ) + container_builder.add_secret_envs( + secret_name=vca_secret_name, + envs={ + "OSMMON_VCA_HOST": "host", + "OSMMON_VCA_USER": "user", + "OSMMON_VCA_SECRET": "secret", + "OSMMON_VCA_CACERT": "cacert", + }, + ) + container_builder.add_secret_envs( + secret_name=grafana_secret_name, + envs={ + "OSMMON_GRAFANA_URL": "url", + "OSMMON_GRAFANA_USER": "user", + "OSMMON_GRAFANA_PASSWORD": "password", + }, + ) + if config.keystone_enabled: + keystone_secret_name = f"{self.app.name}-keystone-secret" + pod_spec_builder.add_secret( + keystone_secret_name, + { + "url": self.keystone_client.host, + "user_domain": self.keystone_client.user_domain_name, + "project_domain": self.keystone_client.project_domain_name, + "service_username": self.keystone_client.username, + "service_password": self.keystone_client.password, + "service_project": self.keystone_client.service, + }, + ) + container_builder.add_env("OSMMON_KEYSTONE_ENABLED", True) + container_builder.add_secret_envs( + secret_name=keystone_secret_name, + envs={ + "OSMMON_KEYSTONE_URL": "url", + "OSMMON_KEYSTONE_DOMAIN_NAME": "user_domain", + "OSMMON_KEYSTONE_PROJECT_DOMAIN_NAME": "project_domain", + "OSMMON_KEYSTONE_SERVICE_USER": "service_username", + "OSMMON_KEYSTONE_SERVICE_PASSWORD": "service_password", + "OSMMON_KEYSTONE_SERVICE_PROJECT": "service_project", + }, + ) container = container_builder.build() + + # Add restart policy + restart_policy = PodRestartPolicy() + restart_policy.add_secrets() + pod_spec_builder.set_restart_policy(restart_policy) + # Add container to pod spec pod_spec_builder.add_container(container) + return pod_spec_builder.build() +VSCODE_WORKSPACE = { + "folders": [ + {"path": "/usr/lib/python3/dist-packages/osm_mon"}, + {"path": "/usr/lib/python3/dist-packages/osm_common"}, + {"path": "/usr/lib/python3/dist-packages/n2vc"}, + ], + "settings": {}, + "launch": { + "version": "0.2.0", + "configurations": [ + { + "name": "MON Server", + "type": "python", + "request": "launch", + "module": "osm_mon.cmd.mon_server", + "justMyCode": False, + }, + { + "name": "MON evaluator", + "type": "python", + "request": "launch", + "module": "osm_mon.cmd.mon_evaluator", + "justMyCode": False, + }, + { + "name": "MON collector", + "type": "python", + "request": "launch", + "module": "osm_mon.cmd.mon_collector", + "justMyCode": False, + }, + { + "name": "MON dashboarder", + "type": "python", + "request": "launch", + "module": "osm_mon.cmd.mon_dashboarder", + "justMyCode": False, + }, + ], + }, +} if __name__ == "__main__": main(MonCharm)