health_checks:
  interval: 2          # seconds between checks
  config:
    - url: "http://my-service/health"
      verify_url: true          # SSL certificate verification (default: true)
      exit_on_failure: false    # exit with code 3 if endpoint goes down (default: false)

    - url: "https://api.example.com/status"
      bearer_token: "your-token"   # Authorization: Bearer <token>
      exit_on_failure: true

    - url: "http://internal-service"
      auth: "username,password"    # HTTP basic auth
      verify_url: false

kubevirt_checks:
  interval: 5
  config:
    namespace: "my-namespace"
    node_name: "worker-1"        # optional: filter VMIs by node
    exit_on_failure: false
    disconnected_mode: false     # track VMs that become unreachable
    only_failures: true          # only record failed checks in telemetry
    batch_size: 10               # VMIs to check concurrently (0 = no limit)
    ssh_port: 22
    ssh_user: "cloud-user"
    ssh_private_key: "/path/to/key"

import logging
import queue
import time
from typing import Any

from krkn.health_checks.abstract_health_check_plugin import AbstractHealthCheckPlugin


class MyServiceHealthCheckPlugin(AbstractHealthCheckPlugin):
    """
    Health check plugin that monitors MyService during chaos experiments.
    """

    def __init__(
        self,
        health_check_type: str = "my_service_health_check",
        iterations: int = 1,
        **kwargs
    ):
        super().__init__(health_check_type)
        self.iterations = iterations
        self.current_iterations = 0

    def get_health_check_types(self) -> list[str]:
        """
        Returns the internal type identifiers for this plugin.
        One plugin can handle multiple type strings, but they must be
        unique across all plugins.
        """
        return ["my_service_health_check"]

    def get_config_key(self) -> str:
        """
        Returns the top-level config.yaml key this plugin reads from.
        The factory maps this key to the plugin so run_kraken.py discovers
        and starts it automatically — no code changes needed there.
        Must be unique across all plugins.
        """
        return "my_service_checks"

    def increment_iterations(self) -> None:
        """
        Called by the main run loop after each chaos iteration.
        Increment your counter so the plugin knows when to stop.
        """
        self.current_iterations += 1

    def run_health_check(
        self,
        config: dict[str, Any],
        telemetry_queue: queue.Queue,
    ) -> None:
        """
        Main health check loop. Runs in a background thread.

        - Check `self._stop_event.is_set()` to support cooperative shutdown
        - Check `self.current_iterations < self.iterations` to stop after the run
        - Put telemetry results into `telemetry_queue`
        - Set `self.ret_value = 3` to signal health check failure
        """
        if not config or not config.get("config"):
            logging.info("my_service_health_check config not defined, skipping")
            return

        interval = config.get("interval", 5)
        exit_on_failure = config.get("config", {}).get("exit_on_failure", False)
        endpoint = config.get("config", {}).get("endpoint")

        telemetry_results = []

        while self.current_iterations < self.iterations and not self._stop_event.is_set():
            healthy = self._check_my_service(endpoint)

            if not healthy:
                logging.warning(f"MyService at {endpoint} is unhealthy")
                if exit_on_failure and self.ret_value == 0:
                    self.ret_value = 3

            # Collect telemetry (structure depends on your needs)
            telemetry_results.append({
                "endpoint": endpoint,
                "status": healthy,
            })

            time.sleep(interval)

        # Always put results into the queue when done
        telemetry_queue.put(telemetry_results)

    def _check_my_service(self, endpoint: str) -> bool:
        """Check if the service is healthy. Returns True if healthy."""
        try:
            # Your service-specific health check logic here
            return True
        except Exception as e:
            logging.error(f"Health check failed: {e}")
            return False

my_service_checks:
  interval: 5
  config:
    endpoint: "http://my-service:8080"
    exit_on_failure: true

health_checks:          # read by HttpHealthCheckPlugin
  interval: 2
  config:
    - url: "http://frontend/health"

my_service_checks:      # read by MyServiceHealthCheckPlugin
  interval: 5
  config:
    endpoint: "http://my-service:8080"

from krkn.health_checks.health_check_factory import HealthCheckFactory

factory = HealthCheckFactory()
print(factory.loaded_plugins.keys())
# dict_keys(['http_health_check', 'virt_health_check', 'my_service_health_check'])