#
# Learn more at: https://juju.is/docs/sdk
-"""OSM NBI charm.
+"""OSM MON charm.
See more: https://charmhub.io/osm
"""
import logging
from typing import Any, Dict
+from urllib.parse import urlparse
+from charms.data_platform_libs.v0.data_interfaces import DatabaseRequires
from charms.kafka_k8s.v0.kafka import KafkaRequires, _KafkaAvailableEvent
from charms.observability_libs.v1.kubernetes_service_patch import KubernetesServicePatch
from charms.osm_libs.v0.utils import (
check_service_active,
)
from charms.osm_vca_integrator.v0.vca import VcaDataChangedEvent, VcaRequires
+from charms.prometheus_k8s.v0.prometheus_scrape import MetricsEndpointProvider
from lightkube.models.core_v1 import ServicePort
from ops.charm import ActionEvent, CharmBase, CharmEvents
from ops.framework import EventSource, StoredState
from ops.main import main
from ops.model import ActiveStatus, Container
-from legacy_interfaces import KeystoneClient, MongoClient, PrometheusClient
+from grafana_datasource_handler import (
+ DatasourceConfig,
+ GrafanaConfig,
+ GrafanaDataSourceHandler,
+)
+from legacy_interfaces import KeystoneClient
HOSTPATHS = [
HostPath(
),
]
SERVICE_PORT = 8000
+PROMETHEUS_RELATION = "metrics-endpoint"
logger = logging.getLogger(__name__)
def __init__(self, *args):
super().__init__(*args)
self.kafka = KafkaRequires(self)
- self.mongodb_client = MongoClient(self, "mongodb")
- self.prometheus_client = PrometheusClient(self, "prometheus")
+ self.mongodb_client = DatabaseRequires(self, "mongodb", database_name="osm")
+ self._set_metrics_endpoint_provider()
self.keystone_client = KeystoneClient(self, "keystone")
self.vca = VcaRequires(self)
self._observe_charm_events()
self.debug_mode = DebugMode(self, self._stored, self.container, HOSTPATHS)
self._patch_k8s_service()
+ def _set_metrics_endpoint_provider(self):
+ prometheus_jobs = [
+ {
+ "job_name": "mon_exporter",
+ "static_configs": [{"targets": ["*:{}".format(SERVICE_PORT)]}],
+ }
+ ]
+ refresh_events = [
+ self.on.mon_pebble_ready,
+ self.on.update_status,
+ ]
+ self.prometheus_metrics_endpoint = MetricsEndpointProvider(
+ self, jobs=prometheus_jobs, refresh_event=refresh_events
+ )
+
@property
def external_hostname(self) -> str:
"""External hostname property.
self.unit.status = e.status
def _on_required_relation_broken(self, _) -> None:
- """Handler for the kafka-broken event."""
+ """Handler for the relation-broken event."""
try:
check_container_ready(self.container)
check_service_active(self.container, self.service_name)
event.fail("debug-mode has not started. Hint: juju config mon debug-mode=true")
return
- debug_info = {"command": self.debug_mode.command, "password": self.debug_mode.password}
+ debug_info = {
+ "command": self.debug_mode.command,
+ "password": self.debug_mode.password,
+ }
event.set_results(debug_info)
+ def _on_create_datasource_action(self, event: ActionEvent) -> None:
+ """Handler for the create-datasource action event."""
+ url = event.params["url"]
+ if not self._is_valid_url(url):
+ event.fail(f"Invalid datasource url '{url}'")
+ return
+ grafana_config = self._get_grafana_config()
+ datasource_config = DatasourceConfig(event.params["name"], url)
+ response = GrafanaDataSourceHandler.create_datasource(grafana_config, datasource_config)
+ logger.debug(response)
+ if response.is_success:
+ event.set_results(response.results)
+ return
+ event.fail(response.message)
+
+ def _on_list_datasources_action(self, event: ActionEvent) -> None:
+ """Handler for the list-datasource action event."""
+ grafana_config = self._get_grafana_config()
+ response = GrafanaDataSourceHandler.list_datasources(grafana_config)
+ logger.debug(response)
+ if response.is_success:
+ event.set_results(response.results)
+ return
+ event.fail(response.message)
+
+ def _on_delete_datasource_action(self, event: ActionEvent) -> None:
+ """Handler for the delete-datasource action event."""
+ datasource_name = event.params["name"]
+ grafana_config = self._get_grafana_config()
+ response = GrafanaDataSourceHandler.delete_datasource(grafana_config, datasource_name)
+ logger.debug(response)
+ if not response.is_success:
+ event.fail(response.message)
+
+ def _get_grafana_config(self) -> GrafanaConfig:
+ return GrafanaConfig(
+ self.config.get("grafana-user", ""),
+ self.config.get("grafana-password", ""),
+ self.config.get("grafana-url", ""),
+ )
+
# ---------------------------------------------------------------------------
# Validation and configuration and more
# ---------------------------------------------------------------------------
self.on.vca_data_changed: self._on_config_changed,
self.on.kafka_available: self._on_config_changed,
self.on["kafka"].relation_broken: self._on_required_relation_broken,
+ self.mongodb_client.on.database_created: self._on_config_changed,
+ self.on["mongodb"].relation_broken: self._on_required_relation_broken,
# Action events
self.on.get_debug_mode_information_action: self._on_get_debug_mode_information_action,
+ self.on.create_datasource_action: self._on_create_datasource_action,
+ self.on.list_datasources_action: self._on_list_datasources_action,
+ self.on.delete_datasource_action: self._on_delete_datasource_action,
}
- for relation in [self.on[rel_name] for rel_name in ["mongodb", "prometheus", "keystone"]]:
+
+ for relation in [self.on[rel_name] for rel_name in [PROMETHEUS_RELATION, "keystone"]]:
event_handler_mapping[relation.relation_changed] = self._on_config_changed
event_handler_mapping[relation.relation_broken] = self._on_required_relation_broken
for event, handler in event_handler_mapping.items():
self.framework.observe(event, handler)
+ def _is_database_available(self) -> bool:
+ try:
+ return self.mongodb_client.is_resource_created()
+ except KeyError:
+ return False
+
def _validate_config(self) -> None:
"""Validate charm configuration.
CharmError: if charm configuration is invalid.
"""
logger.debug("validating charm config")
+ self._validate_mandatory_config_is_set()
+ self._validate_urls_in_config()
+
+ def _validate_mandatory_config_is_set(self):
+ missing_configs = []
+ mandatory_configs = ["grafana-url", "grafana-user", "grafana-password", "prometheus-url"]
+ for config in mandatory_configs:
+ if not self.config.get(config):
+ missing_configs.append(config)
+
+ if missing_configs:
+ config_str = ", ".join(missing_configs)
+ error_msg = f"need {config_str} config"
+ logger.warning(error_msg)
+ raise CharmError(error_msg)
+
+ def _validate_urls_in_config(self):
+ urls_to_validate = ["grafana-url", "prometheus-url"]
+ for param in urls_to_validate:
+ url = self.config[param]
+ if not self._is_valid_url(url):
+ raise CharmError(f"Invalid value for {param} config: '{url}'")
+
+ def _is_valid_url(self, url) -> bool:
+ return urlparse(url).hostname is not None
def _check_relations(self) -> None:
"""Validate charm relations.
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 self._is_database_available():
missing_relations.append("mongodb")
- if self.prometheus_client.is_missing_data_in_app():
+ if not self.framework.model.get_relation(PROMETHEUS_RELATION):
missing_relations.append("prometheus")
if self.keystone_client.is_missing_data_in_app():
missing_relations.append("keystone")
"OSMMON_GLOBAL_REQUEST_TIMEOUT": self.config["global-request-timeout"],
"OSMMON_COLLECTOR_INTERVAL": self.config["collector-interval"],
"OSMMON_EVALUATOR_INTERVAL": self.config["evaluator-interval"],
+ "OSMMON_COLLECTOR_VM_INFRA_METRICS": self.config["vm-infra-metrics"],
# Kafka configuration
"OSMMON_MESSAGE_DRIVER": "kafka",
"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_URI": self._get_mongodb_uri(),
"OSMMON_DATABASE_COMMONKEY": self.config["database-commonkey"],
- # Prometheus/grafana configuration
- "OSMMON_PROMETHEUS_URL": f"http://{self.prometheus_client.hostname}:{self.prometheus_client.port}",
- "OSMMON_PROMETHEUS_USER": self.prometheus_client.user,
- "OSMMON_PROMETHEUS_PASSWORD": self.prometheus_client.password,
- "OSMMON_GRAFANA_URL": self.config["grafana-url"],
- "OSMMON_GRAFANA_USER": self.config["grafana-user"],
- "OSMMON_GRAFANA_PASSWORD": self.config["grafana-password"],
+ # Prometheus configuration
+ "OSMMON_PROMETHEUS_URL": self.config.get("prometheus-url", ""),
+ "OSMMON_PROMETHEUS_USER": "",
+ "OSMMON_PROMETHEUS_PASSWORD": "",
+ # Grafana configuration
+ "OSMMON_GRAFANA_URL": self.config.get("grafana-url", ""),
+ "OSMMON_GRAFANA_USER": self.config.get("grafana-user", ""),
+ "OSMMON_GRAFANA_PASSWORD": self.config.get("grafana-password", ""),
"OSMMON_KEYSTONE_ENABLED": self.config["keystone-enabled"],
"OSMMON_KEYSTONE_URL": self.keystone_client.host,
+ # Keystone configuration
"OSMMON_KEYSTONE_DOMAIN_NAME": self.keystone_client.user_domain_name,
"OSMMON_KEYSTONE_SERVICE_PROJECT": self.keystone_client.service,
- "OSMMON_KEYSTONE_SERVICE_USER": self.keystone_client.username ,
+ "OSMMON_KEYSTONE_SERVICE_USER": self.keystone_client.username,
"OSMMON_KEYSTONE_SERVICE_PASSWORD": self.keystone_client.password,
"OSMMON_KEYSTONE_SERVICE_PROJECT_DOMAIN_NAME": self.keystone_client.project_domain_name,
}
},
}
+ def _get_mongodb_uri(self):
+ return list(self.mongodb_client.fetch_relation_data().values())[0]["uris"]
+
def _patch_k8s_service(self) -> None:
port = ServicePort(SERVICE_PORT, name=f"{self.app.name}")
self.service_patcher = KubernetesServicePatch(self, [port])
projects / osm / devops.git / blobdiff