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 from string import Template
  29 from typing import NoReturn, Optional
  30 from urllib.parse import urlparse
  31
  32 from ops.main import main
  33 from opslib.osm.charm import CharmedOsmBase, RelationsMissing
  34 from opslib.osm.interfaces.prometheus import PrometheusClient
  35 from opslib.osm.pod import (
  36     ContainerV3Builder,
  37     FilesV3Builder,
  38     IngressResourceV3Builder,
  39     PodSpecV3Builder,
  40 )
  41 from opslib.osm.validator import ModelValidator, validator
  42
  43
  44 logger = logging.getLogger(__name__)
  45
  46 PORT = 3000
  47
  48
  49 class ConfigModel(ModelValidator):
  50     max_file_size: int
  51     osm_dashboards: bool
  52     site_url: Optional[str]
  53     cluster_issuer: Optional[str]
  54     ingress_class: Optional[str]
  55     ingress_whitelist_source_range: Optional[str]
  56     tls_secret_name: Optional[str]
  57
  58     @validator("max_file_size")
  59     def validate_max_file_size(cls, v):
  60         if v < 0:
  61             raise ValueError("value must be equal or greater than 0")
  62         return v
  63
  64     @validator("site_url")
  65     def validate_site_url(cls, v):
  66         if v:
  67             parsed = urlparse(v)
  68             if not parsed.scheme.startswith("http"):
  69                 raise ValueError("value must start with http")
  70         return v
  71
  72     @validator("ingress_whitelist_source_range")
  73     def validate_ingress_whitelist_source_range(cls, v):
  74         if v:
  75             ip_network(v)
  76         return v
  77
  78
  79 class GrafanaCharm(CharmedOsmBase):
  80     """GrafanaCharm Charm."""
  81
  82     def __init__(self, *args) -> NoReturn:
  83         """Prometheus Charm constructor."""
  84         super().__init__(*args, oci_image="image")
  85
  86         self.prometheus_client = PrometheusClient(self, "prometheus")
  87         self.framework.observe(
  88             self.on["prometheus"].relation_changed, self.configure_pod
  89         )
  90         self.framework.observe(
  91             self.on["prometheus"].relation_broken, self.configure_pod
  92         )
  93
  94     def _build_dashboard_files(self, config: ConfigModel):
  95         files_builder = FilesV3Builder()
  96         files_builder.add_file(
  97             "dashboard_osm.yaml",
  98             Path("files/default_dashboards.yaml").read_text(),
  99         )
 100         if config.osm_dashboards:
 101             osm_dashboards_mapping = {
 102                 "kafka_exporter_dashboard.json": "files/kafka_exporter_dashboard.json",
 103                 "mongodb_exporter_dashboard.json": "files/mongodb_exporter_dashboard.json",
 104                 "mysql_exporter_dashboard.json": "files/mysql_exporter_dashboard.json",
 105                 "nodes_exporter_dashboard.json": "files/nodes_exporter_dashboard.json",
 106                 "summary_dashboard.json": "files/summary_dashboard.json",
 107             }
 108             for file_name, path in osm_dashboards_mapping.items():
 109                 files_builder.add_file(file_name, Path(path).read_text())
 110         return files_builder.build()
 111
 112     def _build_datasources_files(self):
 113         files_builder = FilesV3Builder()
 114         files_builder.add_file(
 115             "datasource_prometheus.yaml",
 116             Template(Path("files/default_datasources.yaml").read_text()).substitute(
 117                 prometheus_host=self.prometheus_client.hostname,
 118                 prometheus_port=self.prometheus_client.port,
 119             ),
 120         )
 121         return files_builder.build()
 122
 123     def _check_missing_dependencies(self):
 124         missing_relations = []
 125
 126         if self.prometheus_client.is_missing_data_in_app():
 127             missing_relations.append("prometheus")
 128
 129         if missing_relations:
 130             raise RelationsMissing(missing_relations)
 131
 132     def build_pod_spec(self, image_info):
 133         # Validate config
 134         config = ConfigModel(**dict(self.config))
 135         # Check relations
 136         self._check_missing_dependencies()
 137         # Create Builder for the PodSpec
 138         pod_spec_builder = PodSpecV3Builder()
 139         # Build Container
 140         container_builder = ContainerV3Builder(self.app.name, image_info)
 141         container_builder.add_port(name=self.app.name, port=PORT)
 142         container_builder.add_http_readiness_probe(
 143             "/api/health",
 144             PORT,
 145             initial_delay_seconds=10,
 146             period_seconds=10,
 147             timeout_seconds=5,
 148             failure_threshold=3,
 149         )
 150         container_builder.add_http_liveness_probe(
 151             "/api/health",
 152             PORT,
 153             initial_delay_seconds=60,
 154             timeout_seconds=30,
 155             failure_threshold=10,
 156         )
 157         container_builder.add_volume_config(
 158             "dashboards",
 159             "/etc/grafana/provisioning/dashboards/",
 160             self._build_dashboard_files(config),
 161         )
 162         container_builder.add_volume_config(
 163             "datasources",
 164             "/etc/grafana/provisioning/datasources/",
 165             self._build_datasources_files(),
 166         )
 167         container = container_builder.build()
 168         # Add container to pod spec
 169         pod_spec_builder.add_container(container)
 170         # Add ingress resources to pod spec if site url exists
 171         if config.site_url:
 172             parsed = urlparse(config.site_url)
 173             annotations = {
 174                 "nginx.ingress.kubernetes.io/proxy-body-size": "{}".format(
 175                     str(config.max_file_size) + "m"
 176                     if config.max_file_size > 0
 177                     else config.max_file_size
 178                 )
 179             }
 180             if config.ingress_class:
 181                 annotations["kubernetes.io/ingress.class"] = config.ingress_class
 182             ingress_resource_builder = IngressResourceV3Builder(
 183                 f"{self.app.name}-ingress", annotations
 184             )
 185
 186             if config.ingress_whitelist_source_range:
 187                 annotations[
 188                     "nginx.ingress.kubernetes.io/whitelist-source-range"
 189                 ] = config.ingress_whitelist_source_range
 190
 191             if config.cluster_issuer:
 192                 annotations["cert-manager.io/cluster-issuer"] = config.cluster_issuer
 193
 194             if parsed.scheme == "https":
 195                 ingress_resource_builder.add_tls(
 196                     [parsed.hostname], config.tls_secret_name
 197                 )
 198             else:
 199                 annotations["nginx.ingress.kubernetes.io/ssl-redirect"] = "false"
 200
 201             ingress_resource_builder.add_rule(parsed.hostname, self.app.name, PORT)
 202             ingress_resource = ingress_resource_builder.build()
 203             pod_spec_builder.add_ingress_resource(ingress_resource)
 204         return pod_spec_builder.build()
 205
 206
 207 if __name__ == "__main__":
 208     main(GrafanaCharm)