installers/charm/grafana/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 from ipaddress import ip_network
  26 import logging
  27 from pathlib import Path
  28 import secrets
  29 from string import Template
  30 from typing import NoReturn, Optional
  31 from urllib.parse import urlparse
  32
  33 from ops.main import main
  34 from opslib.osm.charm import CharmedOsmBase, RelationsMissing
  35 from opslib.osm.interfaces.grafana import GrafanaCluster
  36 from opslib.osm.interfaces.mysql import MysqlClient
  37 from opslib.osm.interfaces.prometheus import PrometheusClient
  38 from opslib.osm.pod import (
  39     ContainerV3Builder,
  40     FilesV3Builder,
  41     IngressResourceV3Builder,
  42     PodRestartPolicy,
  43     PodSpecV3Builder,
  44 )
  45 from opslib.osm.validator import ModelValidator, validator
  46
  47
  48 logger = logging.getLogger(__name__)
  49
  50
  51 class ConfigModel(ModelValidator):
  52     log_level: str
  53     port: int
  54     admin_user: str
  55     max_file_size: int
  56     osm_dashboards: bool
  57     site_url: Optional[str]
  58     cluster_issuer: Optional[str]
  59     ingress_class: Optional[str]
  60     ingress_whitelist_source_range: Optional[str]
  61     tls_secret_name: Optional[str]
  62     image_pull_policy: str
  63     security_context: bool
  64
  65     @validator("log_level")
  66     def validate_log_level(cls, v):
  67         allowed_values = ("debug", "info", "warn", "error", "critical")
  68         if v not in allowed_values:
  69             separator = '", "'
  70             raise ValueError(
  71                 f'incorrect value. Allowed values are "{separator.join(allowed_values)}"'
  72             )
  73         return v
  74
  75     @validator("max_file_size")
  76     def validate_max_file_size(cls, v):
  77         if v < 0:
  78             raise ValueError("value must be equal or greater than 0")
  79         return v
  80
  81     @validator("site_url")
  82     def validate_site_url(cls, v):
  83         if v:
  84             parsed = urlparse(v)
  85             if not parsed.scheme.startswith("http"):
  86                 raise ValueError("value must start with http")
  87         return v
  88
  89     @validator("ingress_whitelist_source_range")
  90     def validate_ingress_whitelist_source_range(cls, v):
  91         if v:
  92             ip_network(v)
  93         return v
  94
  95     @validator("image_pull_policy")
  96     def validate_image_pull_policy(cls, v):
  97         values = {
  98             "always": "Always",
  99             "ifnotpresent": "IfNotPresent",
 100             "never": "Never",
 101         }
 102         v = v.lower()
 103         if v not in values.keys():
 104             raise ValueError("value must be always, ifnotpresent or never")
 105         return values[v]
 106
 107
 108 class GrafanaCharm(CharmedOsmBase):
 109     """GrafanaCharm Charm."""
 110
 111     def __init__(self, *args) -> NoReturn:
 112         """Prometheus Charm constructor."""
 113         super().__init__(*args, oci_image="image", mysql_uri=True)
 114         # Initialize relation objects
 115         self.prometheus_client = PrometheusClient(self, "prometheus")
 116         self.grafana_cluster = GrafanaCluster(self, "cluster")
 117         self.mysql_client = MysqlClient(self, "db")
 118         # Observe events
 119         event_observer_mapping = {
 120             self.on["prometheus"].relation_changed: self.configure_pod,
 121             self.on["prometheus"].relation_broken: self.configure_pod,
 122             self.on["db"].relation_changed: self.configure_pod,
 123             self.on["db"].relation_broken: self.configure_pod,
 124         }
 125         for event, observer in event_observer_mapping.items():
 126             self.framework.observe(event, observer)
 127
 128     def _build_dashboard_files(self, config: ConfigModel):
 129         files_builder = FilesV3Builder()
 130         files_builder.add_file(
 131             "dashboard_osm.yaml",
 132             Path("templates/default_dashboards.yaml").read_text(),
 133         )
 134         if config.osm_dashboards:
 135             osm_dashboards_mapping = {
 136                 "kafka_exporter_dashboard.json": "templates/kafka_exporter_dashboard.json",
 137                 "mongodb_exporter_dashboard.json": "templates/mongodb_exporter_dashboard.json",
 138                 "mysql_exporter_dashboard.json": "templates/mysql_exporter_dashboard.json",
 139                 "nodes_exporter_dashboard.json": "templates/nodes_exporter_dashboard.json",
 140                 "summary_dashboard.json": "templates/summary_dashboard.json",
 141             }
 142             for file_name, path in osm_dashboards_mapping.items():
 143                 files_builder.add_file(file_name, Path(path).read_text())
 144         return files_builder.build()
 145
 146     def _build_datasources_files(self):
 147         files_builder = FilesV3Builder()
 148         files_builder.add_file(
 149             "datasource_prometheus.yaml",
 150             Template(Path("templates/default_datasources.yaml").read_text()).substitute(
 151                 prometheus_host=self.prometheus_client.hostname,
 152                 prometheus_port=self.prometheus_client.port,
 153             ),
 154         )
 155         return files_builder.build()
 156
 157     def _check_missing_dependencies(self, config: ConfigModel, external_db: bool):
 158         missing_relations = []
 159
 160         if self.prometheus_client.is_missing_data_in_app():
 161             missing_relations.append("prometheus")
 162
 163         if not external_db and self.mysql_client.is_missing_data_in_unit():
 164             missing_relations.append("db")
 165
 166         if missing_relations:
 167             raise RelationsMissing(missing_relations)
 168
 169     def build_pod_spec(self, image_info, **kwargs):
 170         # Validate config
 171         config = ConfigModel(**dict(self.config))
 172         mysql_config = kwargs["mysql_config"]
 173         if mysql_config.mysql_uri and not self.mysql_client.is_missing_data_in_unit():
 174             raise Exception("Mysql data cannot be provided via config and relation")
 175
 176         # Check relations
 177         external_db = True if mysql_config.mysql_uri else False
 178         self._check_missing_dependencies(config, external_db)
 179
 180         # Get initial password
 181         admin_initial_password = self.grafana_cluster.admin_initial_password
 182         if not admin_initial_password:
 183             admin_initial_password = _generate_random_password()
 184             self.grafana_cluster.set_initial_password(admin_initial_password)
 185
 186         # Create Builder for the PodSpec
 187         pod_spec_builder = PodSpecV3Builder(
 188             enable_security_context=config.security_context
 189         )
 190
 191         # Add secrets to the pod
 192         grafana_secret_name = f"{self.app.name}-admin-secret"
 193         pod_spec_builder.add_secret(
 194             grafana_secret_name,
 195             {
 196                 "admin-password": admin_initial_password,
 197                 "mysql-url": mysql_config.mysql_uri or self.mysql_client.get_uri(),
 198             },
 199         )
 200
 201         # Build Container
 202         container_builder = ContainerV3Builder(
 203             self.app.name,
 204             image_info,
 205             config.image_pull_policy,
 206             run_as_non_root=config.security_context,
 207         )
 208         container_builder.add_port(name=self.app.name, port=config.port)
 209         container_builder.add_http_readiness_probe(
 210             "/api/health",
 211             config.port,
 212             initial_delay_seconds=10,
 213             period_seconds=10,
 214             timeout_seconds=5,
 215             failure_threshold=3,
 216         )
 217         container_builder.add_http_liveness_probe(
 218             "/api/health",
 219             config.port,
 220             initial_delay_seconds=60,
 221             timeout_seconds=30,
 222             failure_threshold=10,
 223         )
 224         container_builder.add_volume_config(
 225             "dashboards",
 226             "/etc/grafana/provisioning/dashboards/",
 227             self._build_dashboard_files(config),
 228         )
 229         container_builder.add_volume_config(
 230             "datasources",
 231             "/etc/grafana/provisioning/datasources/",
 232             self._build_datasources_files(),
 233         )
 234
 235         container_builder.add_envs(
 236             {
 237                 "GF_SERVER_HTTP_PORT": config.port,
 238                 "GF_LOG_LEVEL": config.log_level,
 239                 "GF_SECURITY_ADMIN_USER": config.admin_user,
 240             }
 241         )
 242         container_builder.add_secret_envs(
 243             secret_name=grafana_secret_name,
 244             envs={
 245                 "GF_SECURITY_ADMIN_PASSWORD": "admin-password",
 246                 "GF_DATABASE_URL": "mysql-url",
 247             },
 248         )
 249         container = container_builder.build()
 250         pod_spec_builder.add_container(container)
 251
 252         # Add Pod restart policy
 253         restart_policy = PodRestartPolicy()
 254         restart_policy.add_secrets(secret_names=(grafana_secret_name,))
 255         pod_spec_builder.set_restart_policy(restart_policy)
 256
 257         # Add ingress resources to pod spec if site url exists
 258         if config.site_url:
 259             parsed = urlparse(config.site_url)
 260             annotations = {
 261                 "nginx.ingress.kubernetes.io/proxy-body-size": "{}".format(
 262                     str(config.max_file_size) + "m"
 263                     if config.max_file_size > 0
 264                     else config.max_file_size
 265                 )
 266             }
 267             if config.ingress_class:
 268                 annotations["kubernetes.io/ingress.class"] = config.ingress_class
 269             ingress_resource_builder = IngressResourceV3Builder(
 270                 f"{self.app.name}-ingress", annotations
 271             )
 272
 273             if config.ingress_whitelist_source_range:
 274                 annotations[
 275                     "nginx.ingress.kubernetes.io/whitelist-source-range"
 276                 ] = config.ingress_whitelist_source_range
 277
 278             if config.cluster_issuer:
 279                 annotations["cert-manager.io/cluster-issuer"] = config.cluster_issuer
 280
 281             if parsed.scheme == "https":
 282                 ingress_resource_builder.add_tls(
 283                     [parsed.hostname], config.tls_secret_name
 284                 )
 285             else:
 286                 annotations["nginx.ingress.kubernetes.io/ssl-redirect"] = "false"
 287
 288             ingress_resource_builder.add_rule(
 289                 parsed.hostname, self.app.name, config.port
 290             )
 291             ingress_resource = ingress_resource_builder.build()
 292             pod_spec_builder.add_ingress_resource(ingress_resource)
 293         return pod_spec_builder.build()
 294
 295
 296 def _generate_random_password():
 297     return secrets.token_hex(16)
 298
 299
 300 if __name__ == "__main__":
 301     main(GrafanaCharm)