def __init__(self, *args):
super().__init__(*args)
self.framework.observe(self.on.config_changed, self._on_config_changed)
self.framework.observe(self.on.resume_action, self._on_resume_action)
self.framework.observe(self.on.pause_action, self._on_pause_action)
self.framework.observe(self.on.splunk_pebble_ready,
self._on_pebble_ready)
self.framework.observe(self.on.reveal_admin_password_action,
self._on_reveal_admin_password_action)
self.framework.observe(self.on.accept_license_action,
self._on_accept_license_action)
self.framework.observe(self.on.update_status, self._on_update_status)
self.state.set_default(license_accepted=False)
self.state.set_default(pebble_ready=False)
self.state.set_default(auto_start=True)
self.state.set_default(last_config_password=None)
self.state.set_default(splunk_password=random_password())
self.ingress = IngressRequires(
self,
{
"service-hostname": self.config["external-hostname"],
"service-name": self.app.name,
"service-port": 8000,
},
)
def __init__(self, *args):
super().__init__(*args)
self.framework.observe(self.on.install, self._on_install)
self.framework.observe(self.on.config_changed, self._on_config_changed)
self.framework.observe(self.on.pull_site_action, self._pull_site_action)
self.ingress = IngressRequires(self, {
"service-hostname": self._external_hostname,
"service-name": self.app.name,
"service-port": 8080
})
def __init__(self, *args):
super().__init__(*args)
self._name = "prometheus"
self._port = 9090
self._prometheus_server = Prometheus()
self.service_patch = KubernetesServicePatch(
self, [(f"{self.app.name}", self._port)])
# Relation handler objects
# Allows Grafana to aggregate metrics
self.grafana_source_consumer = GrafanaSourceConsumer(
charm=self,
name="grafana-source",
refresh_event=self.on.prometheus_pebble_ready,
)
# Gathers scrape job information from metrics endpoints
self.metrics_consumer = MetricsEndpointConsumer(self)
# Maintains list of Alertmanagers to which alerts are forwarded
self.alertmanager_consumer = AlertmanagerConsumer(
self, relation_name="alertmanager")
# Manages ingress for this charm
self.ingress = IngressRequires(
self,
{
"service-hostname": self._external_hostname,
"service-name": self.app.name,
"service-port": str(self._port),
},
)
# Event handlers
self.framework.observe(self.on.prometheus_pebble_ready,
self._configure)
self.framework.observe(self.on.config_changed, self._configure)
self.framework.observe(self.on.upgrade_charm, self._configure)
self.framework.observe(self.on.ingress_relation_joined,
self._configure)
self.framework.observe(self.on.ingress_relation_changed,
self._configure)
self.framework.observe(self.on.ingress_relation_broken,
self._configure)
self.framework.observe(self.metrics_consumer.on.targets_changed,
self._configure)
self.framework.observe(self.alertmanager_consumer.on.cluster_changed,
self._configure)
def __init__(self, *args):
super().__init__(*args)
self.framework.observe(self.on.rabbitmq_pebble_ready,
self._on_rabbitmq_pebble_ready)
self.framework.observe(self.on.config_changed, self._on_config_changed)
self.framework.observe(self.on.upgrade_charm, self._on_upgrade_charm)
self.framework.observe(self.on.get_operator_info_action,
self._on_get_operator_info_action)
self.framework.observe(self.on.update_status, self._on_update_status)
# Peers
self.peers = interface_rabbitmq_operator_peers.RabbitMQOperatorPeers(
self, "peers")
self.framework.observe(
self.peers.on.connected,
self._on_peer_relation_connected,
)
# AMQP Provides
self.amqp_provider = AMQPProvides(self, "amqp",
self.create_amqp_credentials)
self.framework.observe(
self.amqp_provider.on.ready_amqp_clients,
self._on_ready_amqp_clients,
)
self._stored.set_default(enabled_plugins=[])
self._stored.set_default(pebble_ready=False)
self._stored.set_default(rmq_started=False)
self._stored.set_default(rabbitmq_version=None)
self.ingress_mgmt = IngressRequires(
self,
{
"service-hostname": "rabbitmq-management.juju",
"service-name": self.app.name,
"service-port": 15672,
},
)
self._enable_plugin("rabbitmq_management")
self._enable_plugin("rabbitmq_peer_discovery_k8s")
# NOTE(jamespage): This should become part of what Juju
# does at some point in time.
self.service_patcher = KubernetesServicePatch(self,
[("amqp", 5672),
("management", 15672)])
def __init__(self, *args):
super().__init__(*args)
self.framework.observe(
self.on.kaniqueue_pebble_ready, self._on_kaniqueue_pebble_ready
)
self.framework.observe(self.on.config_changed, self._on_config_changed)
self.framework.observe(self.on.add_job_action, self._add_job_action)
self.framework.observe(
self.on.build_api_relation_created, self._on_build_api_relation_created
)
self.ingress = IngressRequires(
self,
{
"service-hostname": "kaniqueue.juju",
"service-name": self.app.name,
"service-port": SERVICE_PORT,
},
)
def __init__(self, *args):
super().__init__(*args)
self.framework.observe(self.on.opensearch_pebble_ready, self._on_pebble_ready)
self.framework.observe(self.on.opensearch_pebble_ready, self._on_initial_config)
self.framework.observe(self.on.config_changed, self._on_config_changed)
self.framework.observe(
self.on.reveal_admin_password_action, self._on_reveal_admin_password_action
)
self.framework.observe(
self.on.regenerate_admin_password_action,
self._on_update_admin_password_action,
)
self._state.set_default(admin_password="******", started=False)
self.ingress = IngressRequires(
self,
{
"service-hostname": self.config["node_name"],
"service-name": self.app.name,
"service-port": 9200,
},
)
class SplunkCharm(CharmBase):
"""Charm the service."""
state = StoredState()
def __init__(self, *args):
super().__init__(*args)
self.framework.observe(self.on.config_changed, self._on_config_changed)
self.framework.observe(self.on.resume_action, self._on_resume_action)
self.framework.observe(self.on.pause_action, self._on_pause_action)
self.framework.observe(self.on.splunk_pebble_ready,
self._on_pebble_ready)
self.framework.observe(self.on.reveal_admin_password_action,
self._on_reveal_admin_password_action)
self.framework.observe(self.on.accept_license_action,
self._on_accept_license_action)
self.framework.observe(self.on.update_status, self._on_update_status)
self.state.set_default(license_accepted=False)
self.state.set_default(pebble_ready=False)
self.state.set_default(auto_start=True)
self.state.set_default(last_config_password=None)
self.state.set_default(splunk_password=random_password())
self.ingress = IngressRequires(
self,
{
"service-hostname": self.config["external-hostname"],
"service-name": self.app.name,
"service-port": 8000,
},
)
def _update_password(self):
config_password = self.config["splunk-password"]
last_config_password, self.state.last_config_password = (
self.state.last_config_password,
config_password,
)
updated = last_config_password != config_password
if updated:
if config_password:
# The user is setting a password
self.state.splunk_password = config_password
else:
# the user is clearing the password
self.state.splunk_password = random_password()
logger.info("Splunk Password Updated")
def _on_accept_license_action(self, _):
self.state.license_accepted = True
self._do_config_change()
def _on_resume_action(self, _):
self.state.auto_start = True
self._do_config_change()
def _on_pause_action(self, _):
self.state.auto_start = False
self._do_config_change()
def _on_pebble_ready(self, event):
self.state.pebble_ready = True
self._do_config_change()
def _on_reveal_admin_password_action(self, action_event):
return action_event.set_results(
OrderedDict(username="******", password=self.state.splunk_password))
def _on_update_status(self, _):
container = self.unit.get_container("splunk")
if not self.state.auto_start:
self.unit.status = MaintenanceStatus("splunk service is paused")
elif not container.get_service("splunk").is_running():
self.unit.status = BlockedStatus("splunk service isn't running")
else:
self.unit.status = ActiveStatus("ready")
def _on_config_changed(self, _):
"""Handle the config-changed event"""
self.ingress.update_config(
{"service-hostname": self.config["external-hostname"]})
self._update_password()
self._do_config_change()
def _do_config_change(self):
if not self.state.pebble_ready:
self.unit.status = MaintenanceStatus(
"Awaiting the 'splunk' container")
return
if not self.state.license_accepted:
self.unit.status = BlockedStatus("Run 'accept-license' action")
return
if not minimum_password_requirements(self.state.splunk_password):
self.unit.status = BlockedStatus(
"Password doesn't meet minimum requirements.")
return
# Get the splunk container so we can configure/manipulate it
container = self.unit.get_container("splunk")
# Create a new config layer
layer = self._splunk_layer()
# Get the current config
services = container.get_plan().to_dict().get("services", {})
# Check if there are any changes to services
if services != layer["services"]:
# Changes were made, add the new layer
container.add_layer("splunk", layer, combine=True)
logging.info("Added updated layer 'splunk' to Pebble plan")
# Stop the service if it is already running
if container.get_service("splunk").is_running():
container.stop("splunk")
# Restart it and report a new status to Juju
if self.state.auto_start and not container.get_service(
"splunk").is_running():
container.start("splunk")
logging.info("Restarted splunk service")
# All is well, set an ActiveStatus
self._on_update_status(None)
def _splunk_layer(self):
"""Returns a Pebble configuration layer for nrpe-server"""
environment = {
"SPLUNK_PASSWORD": self.state.splunk_password,
"SPLUNK_START_ARGS": "--accept-license",
}
for env_name, config in SPLUNK_ARGS.items():
cfg = self.config[config]
if cfg:
environment[env_name] = cfg
cmd = "bash -c '/sbin/entrypoint.sh start > /var/log/splunk.log 2>&1'"
return {
"summary": "splunk layer",
"description": "pebble config layer for splunk",
"services": {
"splunk": {
"override": "replace",
"summary": "splunk",
"command": cmd,
"startup":
"enabled" if self.state.auto_start else "disabled",
"environment": environment,
},
},
}