local image = "gcr.io/cadvisor/cadvisor:latest";

local labels = {
  app: "cadvisor",
};

local name = std.extVar("NAME");

local node_ip = std.extVar("NODE_IP");

local port = 8080;

local deployment = {
  apiVersion: "apps/v1",
  kind: "Deployment",
  metadata: {
    name: name,
    labels: labels,
  },
  spec: {
    replicas: 1,
    selector: {
      matchLabels: labels,
    },
    template: {
      metadata: {
        labels: labels,
      },
      spec: {
        containers: [
          {
            name: name,
            image: image,
            ports: [
              {
                name: "http",
                containerPort: 8080,
                protocol: "TCP",
              },
            ],
            resources: {
              limits: {
                memory: "500Mi",
              },
              requests: {
                cpu: "250m",
                memory: "250Mi",
              },
            },
            securityContext: {
              allowPrivilegeEscalation: false,
              privileged: false,
              readOnlyRootFilesystem: true,
              runAsGroup: 1000,
              runAsNonRoot: true,
              runAsUser: 1000,
            },
          },
        ],
      },
    },
  },
};


local ingresses = [
  {
    // Tailscale Ingress TLS (non-public)
    apiVersion: "networking.k8s.io/v1",
    kind: "Ingress",
    metadata: {
      name: "tailscale",
      labels: labels,
    },
    spec: {
      ingressClassName: "tailscale",
      defaultBackend: {
        service: {
          name: name,
          port: {
            number: port,
          },
        },
      },
      tls: [
        {
          hosts: [
            name,
          ],
        },
      ],
    },
  },
  {
    // Traefik Ingress non-TLS (non-public)
    apiVersion: "networking.k8s.io/v1",
    kind: "Ingress",
    metadata: {
      name: "traefik",
      labels: labels,
    },
    spec: {
      ingressClassName: "traefik",
      rules: [
        {
          host: std.format(
              "%(name)s.%(node_ip)s.nip.io", {
                name: name,
                node_ip: node_ip,
              },
            ),
          http: {
            paths: [
              {
                path: "/",
                pathType: "Prefix",
                backend: {
                  service: {
                    name: name,
                    port: {
                      number: port,
                    },
                  },
                },
              },
            ],
          },
        },
      ],
    },
  },
];

local prometheusrule = {
  // Alternatively parameterize the duration
  local duration = 10,

  apiVersion: "monitoring.coreos.com/v1",
  kind: "PrometheusRule",
  metadata: {
    name: name,
    labels: labels,
  },
  spec: {
    groups: [
      {
        name: name,
        rules: [
          {
            alert: "TestcAdvsiorDown",
            annotations: {
              summary: "Test cAdvisor instance is down or not scraping metrics.",
              description: std.format(
                "The cAdvisor instance {{ $labels.instance }} has not been scraping metrics for more than %(duration)s minutes.", {
                  duration: duration,
                },
              ),
            },
            expr: "absent(cadvisor_version_info{namespace=\"k3s-test\"}) or (cadvisor_version_info{namespace=\"k3s-test\"}!=1)",
            "for": std.format(
              "%(duration)sm", {
                duration: duration,
              },
            ),
            labels: labels {
              severity: "warning",
            },
          },
        ],
      },
    ],
  },
};

local service = {
  apiVersion: "v1",
  kind: "Service",
  metadata: {
    name: name,
    labels: labels,
  },
  spec: {
    selector: labels,
    ports: [
      {
        name: "http",
        port: port,
        targetPort: port,
        protocol: "TCP",
      },
    ],
  },
};

local serviceaccount = {
  apiVersion: "v1",
  kind: "ServiceAccount",
  metadata: {
    name: name,
    labels: labels,
  },
};

local servicemonitor = {
  apiVersion: "monitoring.coreos.com/v1",
  kind: "ServiceMonitor",
  metadata: {
    name: name,
    labels: labels,
  },
  spec: {
    selector: {
      matchLabels: labels,
    },
    endpoints: [
      {
        interval: "120s",
        path: "/metrics",
        port: "http",
        scrapeTimeout: "30s",
      },
    ],
  },
};

// Output
{
  apiVersion: "v1",
  kind: "List",
  items: [
    deployment,
    prometheusrule,
    service,
    serviceaccount,
    servicemonitor,
  ] + ingresses,
}

syntax = "proto3";

import "google/api/annotations.proto";
import "google/api/field_behavior.proto";

import "protoc-gen-openapiv2/options/annotations.proto";

// Was not defined in the question.
service Foo {
    rpc FetchResource(GetResourceRequest) returns (ResourceResponse) {
        option (google.api.http) = {get: "/v1/resource/{resource_id}/group"};
        option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
            summary: "Get Resource from group"
            description: "Retrieve resource info"
        };
    }
};

// Should be named FetchResourceRequest to match the RPC method name.
message GetResourceRequest {
  string resource_id = 1 [
    (google.api.field_behavior) = REQUIRED,
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "Resource UUID v4."
      example: "\"81042622-4f02-4e85-a896-172edd5381b6\""
    }
  ];

  ResourceFilter resource_filter = 2 [
    (google.api.field_behavior) = OPTIONAL,
    (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      description: "\"RESOURCE_FILTER_FIRST\""
    }
  ];
}

// Empty response for demonstration purposes.
// Was not defined in the question.
// Should be named FetchResourceResponse to match the RPC method name.
message ResourceResponse {}

enum ResourceFilter {
  option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_enum) = {
    title: "Resource Filter"
    example: "\"RESOURCE_FILTER_FIRST\""
  };
  RESOURCE_FILTER_UNSPECIFIED = 0;
  RESOURCE_FILTER_FIRST = 1;
}

{
  "theme": "Default",
  "mcpServers": {
    "ackal-mcp-server": {
      "httpUrl": "http://localhost:7777/mcp",
      "timeout": 5000
    },
    "prometheus-mcp-server": {
      "httpUrl": "https://prometheus.{tailnet}/mcp",
      "timeout": 5000
    }
  },
  "selectedAuthType": "gemini-api-key"
}