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
33 from charms
.data_platform_libs
.v0
.data_interfaces
import DatabaseRequires
34 from charms
.kafka_k8s
.v0
.kafka
import KafkaEvents
, KafkaRequires
35 from charms
.nginx_ingress_integrator
.v0
.ingress
import IngressRequires
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_nbi
.v0
.nbi
import NbiProvides
45 from charms
.osm_temporal
.v0
.temporal
import TemporalRequires
46 from lightkube
.models
.core_v1
import ServicePort
47 from ops
.charm
import ActionEvent
, CharmBase
, RelationJoinedEvent
48 from ops
.framework
import StoredState
49 from ops
.main
import main
50 from ops
.model
import ActiveStatus
, Container
52 from legacy_interfaces
import KeystoneClient
, PrometheusClient
56 config
="nbi-hostpath",
57 container_path
="/usr/lib/python3/dist-packages/osm_nbi",
60 config
="common-hostpath",
61 container_path
="/usr/lib/python3/dist-packages/osm_common",
66 logger
= logging
.getLogger(__name__
)
69 class OsmNbiCharm(CharmBase
):
70 """OSM NBI Kubernetes sidecar charm."""
73 _stored
= StoredState()
75 def __init__(self
, *args
):
76 super().__init
__(*args
)
77 self
.ingress
= IngressRequires(
80 "service-hostname": self
.external_hostname
,
81 "service-name": self
.app
.name
,
82 "service-port": SERVICE_PORT
,
85 self
.kafka
= KafkaRequires(self
)
86 self
.nbi
= NbiProvides(self
)
87 self
.temporal
= TemporalRequires(self
)
88 self
.mongodb_client
= DatabaseRequires(
89 self
, "mongodb", database_name
="osm", extra_user_roles
="admin"
91 self
.prometheus_client
= PrometheusClient(self
, "prometheus")
92 self
.keystone_client
= KeystoneClient(self
, "keystone")
93 self
._observe
_charm
_events
()
94 self
.container
: Container
= self
.unit
.get_container("nbi")
95 self
.debug_mode
= DebugMode(self
, self
._stored
, self
.container
, HOSTPATHS
)
96 self
._patch
_k
8s
_service
()
99 def external_hostname(self
) -> str:
100 """External hostname property.
103 str: the external hostname from config.
104 If not set, return the ClusterIP service name.
106 return self
.config
.get("external-hostname") or self
.app
.name
108 # ---------------------------------------------------------------------------
109 # Handlers for Charm Events
110 # ---------------------------------------------------------------------------
112 def _on_config_changed(self
, _
) -> None:
113 """Handler for the config-changed event."""
115 self
._validate
_config
()
116 self
._check
_relations
()
117 # Check if the container is ready.
118 # Eventually it will become ready after the first pebble-ready event.
119 check_container_ready(self
.container
)
121 if not self
.debug_mode
.started
:
122 self
._configure
_service
(self
.container
)
123 self
._update
_ingress
_config
()
124 self
._update
_nbi
_relation
()
125 # Update charm status
126 self
._on
_update
_status
()
127 except CharmError
as e
:
128 logger
.debug(e
.message
)
129 self
.unit
.status
= e
.status
131 def _on_update_status(self
, _
=None) -> None:
132 """Handler for the update-status event."""
134 self
._check
_relations
()
135 if self
.debug_mode
.started
:
137 check_container_ready(self
.container
)
138 check_service_active(self
.container
, "nbi")
139 self
.unit
.status
= ActiveStatus()
140 except CharmError
as e
:
141 logger
.debug(e
.message
)
142 self
.unit
.status
= e
.status
144 def _on_required_relation_broken(self
, _
) -> None:
145 """Handler for the kafka-broken event."""
146 # Check Pebble has started in the container
148 check_container_ready(self
.container
)
149 check_service_active(self
.container
, "nbi")
150 self
.container
.stop("nbi")
154 self
._on
_update
_status
()
156 def _update_nbi_relation(self
, event
: RelationJoinedEvent
= None) -> None:
157 """Handler for the nbi-relation-joined event."""
158 if self
.unit
.is_leader():
159 self
.nbi
.set_host_info(self
.app
.name
, SERVICE_PORT
, event
.relation
if event
else None)
161 def _on_get_debug_mode_information_action(self
, event
: ActionEvent
) -> None:
162 """Handler for the get-debug-mode-information action event."""
163 if not self
.debug_mode
.started
:
164 event
.fail("debug-mode has not started. Hint: juju config nbi debug-mode=true")
167 debug_info
= {"command": self
.debug_mode
.command
, "password": self
.debug_mode
.password
}
168 event
.set_results(debug_info
)
170 # ---------------------------------------------------------------------------
171 # Validation and configuration and more
172 # ---------------------------------------------------------------------------
174 def _patch_k8s_service(self
) -> None:
175 port
= ServicePort(SERVICE_PORT
, name
=f
"{self.app.name}")
176 self
.service_patcher
= KubernetesServicePatch(self
, [port
])
178 def _observe_charm_events(self
) -> None:
179 event_handler_mapping
= {
180 # Core lifecycle events
181 self
.on
.nbi_pebble_ready
: self
._on
_config
_changed
,
182 self
.on
.config_changed
: self
._on
_config
_changed
,
183 self
.on
.update_status
: self
._on
_update
_status
,
185 self
.on
.kafka_available
: self
._on
_config
_changed
,
186 self
.on
["kafka"].relation_broken
: self
._on
_required
_relation
_broken
,
187 self
.mongodb_client
.on
.database_created
: self
._on
_config
_changed
,
188 self
.on
["mongodb"].relation_broken
: self
._on
_required
_relation
_broken
,
190 self
.on
.get_debug_mode_information_action
: self
._on
_get
_debug
_mode
_information
_action
,
191 self
.on
.nbi_relation_joined
: self
._update
_nbi
_relation
,
192 self
.on
["temporal"].relation_changed
: self
._on
_config
_changed
,
193 self
.on
["temporal"].relation_broken
: self
._on
_required
_relation
_broken
,
195 for relation
in [self
.on
[rel_name
] for rel_name
in ["prometheus", "keystone"]]:
196 event_handler_mapping
[relation
.relation_changed
] = self
._on
_config
_changed
197 event_handler_mapping
[relation
.relation_broken
] = self
._on
_required
_relation
_broken
199 for event
, handler
in event_handler_mapping
.items():
200 self
.framework
.observe(event
, handler
)
202 def _is_database_available(self
) -> bool:
204 return self
.mongodb_client
.is_resource_created()
208 def _validate_config(self
) -> None:
209 """Validate charm configuration.
212 CharmError: if charm configuration is invalid.
214 logger
.debug("validating charm config")
216 def _check_relations(self
) -> None:
217 """Validate charm relations.
220 CharmError: if charm configuration is invalid.
222 logger
.debug("check for missing relations")
223 missing_relations
= []
225 if not self
.kafka
.host
or not self
.kafka
.port
:
226 missing_relations
.append("kafka")
227 if not self
._is
_database
_available
():
228 missing_relations
.append("mongodb")
229 if self
.prometheus_client
.is_missing_data_in_app():
230 missing_relations
.append("prometheus")
231 if self
.keystone_client
.is_missing_data_in_app():
232 missing_relations
.append("keystone")
233 if not self
.temporal
.host
or not self
.temporal
.port
:
234 missing_relations
.append("temporal")
236 if missing_relations
:
237 relations_str
= ", ".join(missing_relations
)
238 one_relation_missing
= len(missing_relations
) == 1
239 error_msg
= f
'need {relations_str} relation{"" if one_relation_missing else "s"}'
240 logger
.warning(error_msg
)
241 raise CharmError(error_msg
)
243 def _update_ingress_config(self
) -> None:
244 """Update ingress config in relation."""
246 "service-hostname": self
.external_hostname
,
247 "max-body-size": self
.config
["max-body-size"],
249 if "tls-secret-name" in self
.config
:
250 ingress_config
["tls-secret-name"] = self
.config
["tls-secret-name"]
251 logger
.debug(f
"updating ingress-config: {ingress_config}")
252 self
.ingress
.update_config(ingress_config
)
254 def _configure_service(self
, container
: Container
) -> None:
255 """Add Pebble layer with the nbi service."""
256 logger
.debug(f
"configuring {self.app.name} service")
257 container
.add_layer("nbi", self
._get
_layer
(), combine
=True)
260 def _get_layer(self
) -> Dict
[str, Any
]:
261 """Get layer for Pebble."""
263 "summary": "nbi layer",
264 "description": "pebble config layer for nbi",
267 "override": "replace",
268 "summary": "nbi service",
269 "command": "python3 -m osm_nbi.nbi",
270 "startup": "enabled",
274 # General configuration
275 "OSMNBI_SERVER_ENABLE_TEST": False,
276 "OSMNBI_STATIC_DIR": "/app/osm_nbi/html_public",
277 # Kafka configuration
278 "OSMNBI_MESSAGE_HOST": self
.kafka
.host
,
279 "OSMNBI_MESSAGE_PORT": self
.kafka
.port
,
280 "OSMNBI_MESSAGE_DRIVER": "kafka",
281 # Database configuration
282 "OSMNBI_DATABASE_DRIVER": "mongo",
283 "OSMNBI_DATABASE_URI": self
._get
_mongodb
_uri
(),
284 "OSMNBI_DATABASE_COMMONKEY": self
.config
["database-commonkey"],
285 # Storage configuration
286 "OSMNBI_STORAGE_DRIVER": "mongo",
287 "OSMNBI_STORAGE_PATH": "/app/storage",
288 "OSMNBI_STORAGE_COLLECTION": "files",
289 "OSMNBI_STORAGE_URI": self
._get
_mongodb
_uri
(),
290 # Prometheus configuration
291 "OSMNBI_PROMETHEUS_HOST": self
.prometheus_client
.hostname
,
292 "OSMNBI_PROMETHEUS_PORT": self
.prometheus_client
.port
,
294 "OSMNBI_LOG_LEVEL": self
.config
["log-level"],
295 # Authentication environments
296 "OSMNBI_AUTHENTICATION_BACKEND": "keystone",
297 "OSMNBI_AUTHENTICATION_AUTH_URL": self
.keystone_client
.host
,
298 "OSMNBI_AUTHENTICATION_AUTH_PORT": self
.keystone_client
.port
,
299 "OSMNBI_AUTHENTICATION_USER_DOMAIN_NAME": self
.keystone_client
.user_domain_name
,
300 "OSMNBI_AUTHENTICATION_PROJECT_DOMAIN_NAME": self
.keystone_client
.project_domain_name
,
301 "OSMNBI_AUTHENTICATION_SERVICE_USERNAME": self
.keystone_client
.username
,
302 "OSMNBI_AUTHENTICATION_SERVICE_PASSWORD": self
.keystone_client
.password
,
303 "OSMNBI_AUTHENTICATION_SERVICE_PROJECT": self
.keystone_client
.service
,
304 # DISABLING INTERNAL SSL SERVER
305 "OSMNBI_SERVER_SSL_MODULE": "",
306 "OSMNBI_SERVER_SSL_CERTIFICATE": "",
307 "OSMNBI_SERVER_SSL_PRIVATE_KEY": "",
308 "OSMNBI_SERVER_SSL_PASS_PHRASE": "",
309 # Temporal configuration
310 "OSMNBI_TEMPORAL_HOST": self
.temporal
.host
,
311 "OSMNBI_TEMPORAL_PORT": self
.temporal
.port
,
317 def _get_mongodb_uri(self
):
318 return list(self
.mongodb_client
.fetch_relation_data().values())[0]["uris"]
321 if __name__
== "__main__": # pragma: no cover