2 # Copyright 2022 Canonical Ltd.
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
8 # http://www.apache.org/licenses/LICENSE-2.0
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
16 # For those usages not covered by the Apache License, Version 2.0 please
17 # contact: legal@canonical.com
19 # To get in touch with the maintainers, please contact:
20 # osm-charmers@lists.launchpad.net
23 # Learn more at: https://juju.is/docs/sdk
27 See more: https://charmhub.io/osm
31 from typing
import Any
, Dict
32 from urllib
.parse
import urlparse
34 from charms
.data_platform_libs
.v0
.data_interfaces
import DatabaseRequires
35 from charms
.kafka_k8s
.v0
.kafka
import KafkaRequires
, _KafkaAvailableEvent
36 from charms
.observability_libs
.v1
.kubernetes_service_patch
import KubernetesServicePatch
37 from charms
.osm_libs
.v0
.utils
import (
41 check_container_ready
,
44 from charms
.osm_vca_integrator
.v0
.vca
import VcaDataChangedEvent
, VcaRequires
45 from charms
.prometheus_k8s
.v0
.prometheus_scrape
import MetricsEndpointProvider
46 from lightkube
.models
.core_v1
import ServicePort
47 from ops
.charm
import ActionEvent
, CharmBase
, CharmEvents
48 from ops
.framework
import EventSource
, StoredState
49 from ops
.main
import main
50 from ops
.model
import ActiveStatus
, Container
52 from grafana_datasource_handler
import (
55 GrafanaDataSourceHandler
,
57 from legacy_interfaces
import KeystoneClient
61 config
="mon-hostpath",
62 container_path
="/usr/lib/python3/dist-packages/osm_mon",
65 config
="common-hostpath",
66 container_path
="/usr/lib/python3/dist-packages/osm_common",
69 config
="n2vc-hostpath",
70 container_path
="/usr/lib/python3/dist-packages/n2vc",
74 PROMETHEUS_RELATION
= "metrics-endpoint"
76 logger
= logging
.getLogger(__name__
)
79 class MonEvents(CharmEvents
):
82 vca_data_changed
= EventSource(VcaDataChangedEvent
)
83 kafka_available
= EventSource(_KafkaAvailableEvent
)
86 class OsmMonCharm(CharmBase
):
87 """OSM MON Kubernetes sidecar charm."""
90 _stored
= StoredState()
91 container_name
= "mon"
94 def __init__(self
, *args
):
95 super().__init
__(*args
)
96 self
.kafka
= KafkaRequires(self
)
97 self
.mongodb_client
= DatabaseRequires(self
, "mongodb", database_name
="osm")
98 self
._set
_metrics
_endpoint
_provider
()
99 self
.keystone_client
= KeystoneClient(self
, "keystone")
100 self
.vca
= VcaRequires(self
)
101 self
._observe
_charm
_events
()
102 self
.container
: Container
= self
.unit
.get_container(self
.container_name
)
103 self
.debug_mode
= DebugMode(self
, self
._stored
, self
.container
, HOSTPATHS
)
104 self
._patch
_k
8s
_service
()
106 def _set_metrics_endpoint_provider(self
):
109 "job_name": "mon_exporter",
110 "static_configs": [{"targets": ["*:{}".format(SERVICE_PORT
)]}],
114 self
.on
.mon_pebble_ready
,
115 self
.on
.update_status
,
117 self
.prometheus_metrics_endpoint
= MetricsEndpointProvider(
118 self
, jobs
=prometheus_jobs
, refresh_event
=refresh_events
122 def external_hostname(self
) -> str:
123 """External hostname property.
126 str: the external hostname from config.
127 If not set, return the ClusterIP service name.
129 return self
.config
.get("external-hostname") or self
.app
.name
131 # ---------------------------------------------------------------------------
132 # Handlers for Charm Events
133 # ---------------------------------------------------------------------------
135 def _on_config_changed(self
, _
) -> None:
136 """Handler for the config-changed event."""
138 self
._validate
_config
()
139 self
._check
_relations
()
140 # Check if the container is ready.
141 # Eventually it will become ready after the first pebble-ready event.
142 check_container_ready(self
.container
)
143 if not self
.debug_mode
.started
:
144 self
._configure
_service
(self
.container
)
145 # Update charm status
146 self
._on
_update
_status
()
147 except CharmError
as e
:
148 logger
.debug(e
.message
)
149 self
.unit
.status
= e
.status
151 def _on_update_status(self
, _
=None) -> None:
152 """Handler for the update-status event."""
154 self
._validate
_config
()
155 self
._check
_relations
()
156 check_container_ready(self
.container
)
157 if self
.debug_mode
.started
:
159 check_service_active(self
.container
, self
.service_name
)
160 self
.unit
.status
= ActiveStatus()
161 except CharmError
as e
:
162 logger
.debug(e
.message
)
163 self
.unit
.status
= e
.status
165 def _on_required_relation_broken(self
, _
) -> None:
166 """Handler for the relation-broken event."""
168 check_container_ready(self
.container
)
169 check_service_active(self
.container
, self
.service_name
)
170 self
.container
.stop(self
.container_name
)
173 self
._on
_update
_status
()
175 def _on_get_debug_mode_information_action(self
, event
: ActionEvent
) -> None:
176 """Handler for the get-debug-mode-information action event."""
177 if not self
.debug_mode
.started
:
178 event
.fail("debug-mode has not started. Hint: juju config mon debug-mode=true")
182 "command": self
.debug_mode
.command
,
183 "password": self
.debug_mode
.password
,
185 event
.set_results(debug_info
)
187 def _on_create_datasource_action(self
, event
: ActionEvent
) -> None:
188 """Handler for the create-datasource action event."""
189 url
= event
.params
["url"]
190 if not self
._is
_valid
_url
(url
):
191 event
.fail(f
"Invalid datasource url '{url}'")
193 grafana_config
= self
._get
_grafana
_config
()
194 datasource_config
= DatasourceConfig(event
.params
["name"], url
)
195 response
= GrafanaDataSourceHandler
.create_datasource(grafana_config
, datasource_config
)
196 logger
.debug(response
)
197 if response
.is_success
:
198 event
.set_results(response
.results
)
200 event
.fail(response
.message
)
202 def _on_list_datasources_action(self
, event
: ActionEvent
) -> None:
203 """Handler for the list-datasource action event."""
204 grafana_config
= self
._get
_grafana
_config
()
205 response
= GrafanaDataSourceHandler
.list_datasources(grafana_config
)
206 logger
.debug(response
)
207 if response
.is_success
:
208 event
.set_results(response
.results
)
210 event
.fail(response
.message
)
212 def _on_delete_datasource_action(self
, event
: ActionEvent
) -> None:
213 """Handler for the delete-datasource action event."""
214 datasource_name
= event
.params
["name"]
215 grafana_config
= self
._get
_grafana
_config
()
216 response
= GrafanaDataSourceHandler
.delete_datasource(grafana_config
, datasource_name
)
217 logger
.debug(response
)
218 if not response
.is_success
:
219 event
.fail(response
.message
)
221 def _get_grafana_config(self
) -> GrafanaConfig
:
222 return GrafanaConfig(
223 self
.config
.get("grafana-user", ""),
224 self
.config
.get("grafana-password", ""),
225 self
.config
.get("grafana-url", ""),
228 # ---------------------------------------------------------------------------
229 # Validation and configuration and more
230 # ---------------------------------------------------------------------------
232 def _observe_charm_events(self
) -> None:
233 event_handler_mapping
= {
234 # Core lifecycle events
235 self
.on
.mon_pebble_ready
: self
._on
_config
_changed
,
236 self
.on
.config_changed
: self
._on
_config
_changed
,
237 self
.on
.update_status
: self
._on
_update
_status
,
239 self
.on
.vca_data_changed
: self
._on
_config
_changed
,
240 self
.on
.kafka_available
: self
._on
_config
_changed
,
241 self
.on
["kafka"].relation_broken
: self
._on
_required
_relation
_broken
,
242 self
.mongodb_client
.on
.database_created
: self
._on
_config
_changed
,
243 self
.on
["mongodb"].relation_broken
: self
._on
_required
_relation
_broken
,
245 self
.on
.get_debug_mode_information_action
: self
._on
_get
_debug
_mode
_information
_action
,
246 self
.on
.create_datasource_action
: self
._on
_create
_datasource
_action
,
247 self
.on
.list_datasources_action
: self
._on
_list
_datasources
_action
,
248 self
.on
.delete_datasource_action
: self
._on
_delete
_datasource
_action
,
251 for relation
in [self
.on
[rel_name
] for rel_name
in [PROMETHEUS_RELATION
, "keystone"]]:
252 event_handler_mapping
[relation
.relation_changed
] = self
._on
_config
_changed
253 event_handler_mapping
[relation
.relation_broken
] = self
._on
_required
_relation
_broken
255 for event
, handler
in event_handler_mapping
.items():
256 self
.framework
.observe(event
, handler
)
258 def _is_database_available(self
) -> bool:
260 return self
.mongodb_client
.is_resource_created()
264 def _validate_config(self
) -> None:
265 """Validate charm configuration.
268 CharmError: if charm configuration is invalid.
270 logger
.debug("validating charm config")
271 self
._validate
_mandatory
_config
_is
_set
()
272 self
._validate
_urls
_in
_config
()
274 def _validate_mandatory_config_is_set(self
):
276 mandatory_configs
= ["grafana-url", "grafana-user", "grafana-password", "prometheus-url"]
277 for config
in mandatory_configs
:
278 if not self
.config
.get(config
):
279 missing_configs
.append(config
)
282 config_str
= ", ".join(missing_configs
)
283 error_msg
= f
"need {config_str} config"
284 logger
.warning(error_msg
)
285 raise CharmError(error_msg
)
287 def _validate_urls_in_config(self
):
288 urls_to_validate
= ["grafana-url", "prometheus-url"]
289 for param
in urls_to_validate
:
290 url
= self
.config
[param
]
291 if not self
._is
_valid
_url
(url
):
292 raise CharmError(f
"Invalid value for {param} config: '{url}'")
294 def _is_valid_url(self
, url
) -> bool:
295 return urlparse(url
).hostname
is not None
297 def _check_relations(self
) -> None:
298 """Validate charm relations.
301 CharmError: if charm configuration is invalid.
303 logger
.debug("check for missing relations")
304 missing_relations
= []
306 if not self
.kafka
.host
or not self
.kafka
.port
:
307 missing_relations
.append("kafka")
308 if not self
._is
_database
_available
():
309 missing_relations
.append("mongodb")
310 if not self
.framework
.model
.get_relation(PROMETHEUS_RELATION
):
311 missing_relations
.append("prometheus")
312 if self
.keystone_client
.is_missing_data_in_app():
313 missing_relations
.append("keystone")
315 if missing_relations
:
316 relations_str
= ", ".join(missing_relations
)
317 one_relation_missing
= len(missing_relations
) == 1
318 error_msg
= f
'need {relations_str} relation{"" if one_relation_missing else "s"}'
319 logger
.warning(error_msg
)
320 raise CharmError(error_msg
)
322 def _configure_service(self
, container
: Container
) -> None:
323 """Add Pebble layer with the mon service."""
324 logger
.debug(f
"configuring {self.app.name} service")
325 container
.add_layer("mon", self
._get
_layer
(), combine
=True)
328 def _get_layer(self
) -> Dict
[str, Any
]:
329 """Get layer for Pebble."""
331 # General configuration
332 "OSMMON_GLOBAL_LOGLEVEL": self
.config
["log-level"],
333 "OSMMON_OPENSTACK_DEFAULT_GRANULARITY": self
.config
["openstack-default-granularity"],
334 "OSMMON_GLOBAL_REQUEST_TIMEOUT": self
.config
["global-request-timeout"],
335 "OSMMON_COLLECTOR_INTERVAL": self
.config
["collector-interval"],
336 "OSMMON_EVALUATOR_INTERVAL": self
.config
["evaluator-interval"],
337 "OSMMON_COLLECTOR_VM_INFRA_METRICS": self
.config
["vm-infra-metrics"],
338 # Kafka configuration
339 "OSMMON_MESSAGE_DRIVER": "kafka",
340 "OSMMON_MESSAGE_HOST": self
.kafka
.host
,
341 "OSMMON_MESSAGE_PORT": self
.kafka
.port
,
342 # Database configuration
343 "OSMMON_DATABASE_DRIVER": "mongo",
344 "OSMMON_DATABASE_URI": self
._get
_mongodb
_uri
(),
345 "OSMMON_DATABASE_COMMONKEY": self
.config
["database-commonkey"],
346 # Prometheus configuration
347 "OSMMON_PROMETHEUS_URL": self
.config
.get("prometheus-url", ""),
348 "OSMMON_PROMETHEUS_USER": "",
349 "OSMMON_PROMETHEUS_PASSWORD": "",
350 # Grafana configuration
351 "OSMMON_GRAFANA_URL": self
.config
.get("grafana-url", ""),
352 "OSMMON_GRAFANA_USER": self
.config
.get("grafana-user", ""),
353 "OSMMON_GRAFANA_PASSWORD": self
.config
.get("grafana-password", ""),
354 "OSMMON_KEYSTONE_ENABLED": self
.config
["keystone-enabled"],
355 "OSMMON_KEYSTONE_URL": self
.keystone_client
.host
,
356 # Keystone configuration
357 "OSMMON_KEYSTONE_DOMAIN_NAME": self
.keystone_client
.user_domain_name
,
358 "OSMMON_KEYSTONE_SERVICE_PROJECT": self
.keystone_client
.service
,
359 "OSMMON_KEYSTONE_SERVICE_USER": self
.keystone_client
.username
,
360 "OSMMON_KEYSTONE_SERVICE_PASSWORD": self
.keystone_client
.password
,
361 "OSMMON_KEYSTONE_SERVICE_PROJECT_DOMAIN_NAME": self
.keystone_client
.project_domain_name
,
363 logger
.info(f
"{environment}")
365 environment
["OSMMON_VCA_HOST"] = self
.vca
.data
.endpoints
366 environment
["OSMMON_VCA_SECRET"] = self
.vca
.data
.secret
367 environment
["OSMMON_VCA_USER"] = self
.vca
.data
.user
368 environment
["OSMMON_VCA_CACERT"] = self
.vca
.data
.cacert
370 "summary": "mon layer",
371 "description": "pebble config layer for mon",
374 "override": "replace",
375 "summary": "mon service",
376 "command": "/bin/bash -c 'cd /app/osm_mon/ && /bin/bash start.sh'",
377 "startup": "enabled",
380 "working-dir": "/app/osm_mon", # This parameter has no effect in Juju 2.9.x
381 "environment": environment
,
386 def _get_mongodb_uri(self
):
387 return list(self
.mongodb_client
.fetch_relation_data().values())[0]["uris"]
389 def _patch_k8s_service(self
) -> None:
390 port
= ServicePort(SERVICE_PORT
, name
=f
"{self.app.name}")
391 self
.service_patcher
= KubernetesServicePatch(self
, [port
])
394 if __name__
== "__main__": # pragma: no cover