kube_cluster 0.2.1 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6b2fcc6e1de8c59841b080e8150aa249d84fc064f4eab2e981be9ded9dc2290
-  data.tar.gz: 1a55810edfb5809b44699e2a17984b9f0311257aba52796da6b74e293ce3a9d0
+  metadata.gz: 5659907f3883730ad9d55c7e73bf664d0dd3047a9c9ce38eb15f6ee86e13dc6a
+  data.tar.gz: 4776a870e33f4278bc992f8653ae6b7d22d3c8dcf5d1b0eff99dd54b6407ba46
 SHA512:
-  metadata.gz: b64081cec15ce53b3a80effecba8f2ae3ec43ee58d1dc483196a821f37a4d6aa0aabbdd3d21e5df7eb5208cbd8bdbcf1aefbf82a9911733795b5ad4689c2c62e
-  data.tar.gz: ef610d9b33d6907a92f69c077080a8f26ffd6a1e2f2e391b9f54564187b6799af2e275b2f9f6cb3b056f3f9b3952b964921692a2d4456ee5ee7af229b209ac0c
+  metadata.gz: 7c4c0cb0dd1695a17aa2ef5a2ed32f27f8ae41ab3c00e1232f230cacb5cc253f769446f8019035149b5554eba1aa0a6c5f30d81e9a61a29b46fa954252cf9d13
+  data.tar.gz: b74836f42d1acd37c9e25d9a7fb885910c1f52642615ee8cb29a489f47b04a81e44495e41b244c711c1e7a8ecdc4208e0e4dc23f27ee6994df9e421c073558be

data/Gemfile.lock

@@ -1,17 +1,16 @@
 PATH
   remote: .
   specs:
-    kube_cluster (0.2.0)
+    kube_cluster (0.3.0)
       kube_kit (> 0)
       kube_kubectl (~> 2.0.0)
-      kube_schema (~> 1.2.0)
+      kube_schema (~> 1.3.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.3)
     bigdecimal (4.1.2)
-    black_hole_struct (0.1.3)
     date (3.5.1)
     debug (1.11.1)
       irb (~> 1.10)
@@ -24,23 +23,22 @@ GEM
       prism (>= 1.3.0)
       rdoc (>= 4.0.0)
       reline (>= 0.4.2)
-    json (2.19.3)
+    json (2.19.4)
     json_schemer (2.5.0)
       bigdecimal
       hana (~> 1.3)
       regexp_parser (~> 2.0)
       simpleidn (~> 0.2)
     kube_kit (0.2.0)
-    kube_kubectl (2.0.1)
+    kube_kubectl (2.0.2)
       debug (~> 1.11)
       json_schemer (~> 2.5)
       rubyshell (~> 1.5)
       shellwords (~> 0.2.2)
       string_builder (~> 1.2.0)
-    kube_schema (1.2.1)
-      black_hole_struct (~> 0.1)
-      json_schemer (~> 2.5)
-      rubyshell (~> 1.5)
+    kube_schema (1.3.1)
+      json_schemer (~> 2.5.0)
+      rubyshell (~> 1.5.0)
     language_server-protocol (3.17.0.5)
     lint_roller (1.1.0)
     minitest (5.27.0)
@@ -83,7 +81,7 @@ GEM
     rubyshell (1.5.0)
     shellwords (0.2.2)
     simpleidn (0.2.3)
-    string_builder (1.2.0)
+    string_builder (1.2.1)
     stringio (3.2.0)
     tsort (0.2.0)
     unicode-display_width (3.2.0)

data/examples/01-basic-redis-pod/manifest.rb

@@ -1,9 +1,9 @@
 require "bundler/setup"
-require "kube/schema"
+require "kube/cluster"
 
-class RedisPod < Kube::Schema['Pod']
+class RedisPod < Kube::Cluster['Pod']
   def initialize(container_name: 'my-redis-container', **options, &block)
-    super {
+    super(**options) {
       spec.containers = [
         {
           name: container_name,

data/examples/02-manifest-with-middleware/manifest.rb

@@ -0,0 +1,37 @@
+require "bundler/setup"
+require "kube/cluster"
+
+APP_NAME        = "my-app"
+FULLNAME        = "my-app"
+IMAGE           = "my-app:latest"
+MATCH_LABELS    = { app: APP_NAME }
+STANDARD_LABELS = { app: APP_NAME, version: "1.0" }
+RESOURCES       = { requests: { cpu: "100m", memory: "128Mi" }, limits: { cpu: "500m", memory: "256Mi" } }
+
+require_relative 'templates/config_map'
+require_relative 'templates/deployment'
+require_relative 'templates/ingress'
+require_relative 'templates/service'
+require_relative 'templates/horizontal_pod_autoscaler'
+
+require_relative 'middleware/labels'
+require_relative 'middleware/namespace'
+
+namespace = APP_NAME
+
+manifest = Kube::Cluster::Manifest.new(
+  ConfigMap.new(namespace: namespace),
+  Deployment.new(namespace: namespace),
+  Ingress.new(namespace: namespace),
+  Service.new(namespace: namespace),
+  HorizontalPodAutoscaler.new(namespace: namespace),
+)
+
+stack = Kube::Cluster::Middleware::Stack.new do
+  use Middleware::Namespace
+  use Middleware::Labels
+end
+
+stack.call(manifest)
+
+puts manifest.to_yaml

data/examples/02-manifest-with-middleware/middleware/labels.rb

@@ -0,0 +1,4 @@
+module Middleware
+  class Labels < Kube::Cluster::Middleware
+  end
+end

data/examples/02-manifest-with-middleware/middleware/namespace.rb

@@ -0,0 +1,4 @@
+module Middleware
+  class Namespace < Kube::Cluster::Middleware
+  end
+end

data/examples/02-manifest-with-middleware/templates/config_map.rb

@@ -0,0 +1,13 @@
+class ConfigMap < Kube::Cluster["ConfigMap"]
+  def initialize(namespace:)
+    super {
+      metadata.name = "#{namespace}-config"
+      spec.data = {
+        "RAILS_ENV": "production",
+        "LOG_LEVEL": "info",
+        "WORKERS":   "4",
+        "PORT":      "3000",
+      }
+    }
+  end
+end

data/examples/02-manifest-with-middleware/templates/deployment.rb

@@ -0,0 +1,59 @@
+class Deployment < Kube::Cluster["Deployment"]
+  def initialize(namespace:)
+    super {
+      metadata.name = namespace
+
+      spec.replicas = 3
+      spec.selector.matchLabels = MATCH_LABELS
+
+      spec.template.metadata.labels = STANDARD_LABELS
+      spec.template.metadata.annotations = {
+        # Checksum pattern from _utils.tpl -- triggers rolling restart on config change
+        "checksum/config": "{{ sha256sum of configmap data }}",
+      }
+
+      spec.template.spec.containers = [
+        {
+          name:  APP_NAME,
+          image: IMAGE,
+          ports: [{ name: "http", containerPort: 3000, protocol: "TCP" }],
+          resources: RESOURCES,
+          env: [
+            { name: "PORT", value: "3000" },
+          ],
+          envFrom: [
+            { configMapRef: { name: "#{FULLNAME}-config" } },
+          ],
+          livenessProbe: {
+            httpGet: { path: "/healthz", port: "http" },
+            initialDelaySeconds: 15,
+            periodSeconds: 10,
+          },
+          readinessProbe: {
+            httpGet: { path: "/readyz", port: "http" },
+            initialDelaySeconds: 5,
+            periodSeconds: 5,
+          },
+        },
+      ]
+
+      # Pod anti-affinity (from _affinities.tpl)
+      # Soft anti-affinity: prefer spreading pods across nodes but don't enforce it
+      spec.template.spec.affinity = {
+        podAntiAffinity: {
+          preferredDuringSchedulingIgnoredDuringExecution: [
+            {
+              weight: 1,
+              podAffinityTerm: {
+                labelSelector: {
+                  matchLabels: MATCH_LABELS,
+                },
+                topologyKey: "kubernetes.io/hostname",
+              },
+            },
+          ],
+        },
+      }
+    }
+  end
+end

data/examples/02-manifest-with-middleware/templates/horizontal_pod_autoscaler.rb

@@ -0,0 +1,30 @@
+class HorizontalPodAutoscaler < Kube::Cluster["HorizontalPodAutoscaler"]
+  def initialize(namespace:)
+    super {
+      metadata.name = namespace
+
+      spec.scaleTargetRef.apiVersion = "apps/v1"
+      spec.scaleTargetRef.kind = "Deployment"
+      spec.scaleTargetRef.name = namespace
+
+      spec.minReplicas = 3
+      spec.maxReplicas = 10
+      spec.metrics = [
+        {
+          type: "Resource",
+          resource: {
+            name: "cpu",
+            target: { type: "Utilization", averageUtilization: 75 },
+          },
+        },
+        {
+          type: "Resource",
+          resource: {
+            name: "memory",
+            target: { type: "Utilization", averageUtilization: 80 },
+          },
+        },
+      ]
+    }
+  end
+end

data/examples/02-manifest-with-middleware/templates/ingress.rb

@@ -0,0 +1,38 @@
+class Ingress < Kube::Cluster["Ingress"]
+  def initialize(namespace:)
+    super {
+      metadata.name = namespace
+      metadata.annotations = {
+        "cert-manager.io/cluster-issuer": "letsencrypt-prod",
+        "nginx.ingress.kubernetes.io/ssl-redirect": "true",
+      }
+
+      spec.ingressClassName = "nginx"
+      spec.tls = [
+        {
+          hosts: ["app.example.com"],
+          secretName: "#{namespace}-tls",
+        },
+      ]
+      spec.rules = [
+        {
+          host: "app.example.com",
+          http: {
+            paths: [
+              {
+                path: "/",
+                pathType: "Prefix",
+                backend: {
+                  service: {
+                    name: FULLNAME,
+                    port: { name: "http" },
+                  },
+                },
+              },
+            ],
+          },
+        },
+      ]
+    }
+  end
+end

data/examples/02-manifest-with-middleware/templates/service.rb

@@ -0,0 +1,12 @@
+class Service < Kube::Cluster["Service"]
+  def initialize(namespace:)
+    super {
+      metadata.name = namespace
+
+      spec.selector = MATCH_LABELS
+      spec.ports = [
+        { name: "http", port: 80, targetPort: "http", protocol: "TCP" },
+      ]
+    }
+  end
+end

data/examples/{version2 → 03-app-with-database}/demo.rb

@@ -44,12 +44,12 @@ app = MyApp.new("example.com", size: :small) do |m|
   # Middleware injects:   resource limits, security context, anti-affinity, labels
 
   [
-    Kube::Schema["Namespace"].new {
+    Kube::Cluster["Namespace"].new {
       metadata.name   = ns
       metadata.labels = labels
     },
 
-    Kube::Schema["ConfigMap"].new {
+    Kube::Cluster["ConfigMap"].new {
       metadata.name      = "#{name}-config"
       metadata.namespace = ns
       metadata.labels    = labels

data/examples/{version2 → 03-app-with-database}/postgresql.rb

@@ -10,7 +10,7 @@ class Postgresql < Kube::Cluster::Manifest
     self << Secret.new
   end
 
-  class StatefulSet < Kube::Schema["StatefulSet"]
+  class StatefulSet < Kube::Cluster["StatefulSet"]
     metadata.name      = db_name
     metadata.namespace = db_ns
     metadata.labels    = db_labels
@@ -55,12 +55,12 @@ class Postgresql < Kube::Cluster::Manifest
     ]
   end
 
-  class Namespace < Kube::Schema["Namespace"]
+  class Namespace < Kube::Cluster["Namespace"]
     metadata.name   = db_ns
     metadata.labels = db_labels.reject { |k, _| k == :"app.kubernetes.io/component" }
   end
 
-  class Secret < Kube::Schema["Secret"]
+  class Secret < Kube::Cluster["Secret"]
     metadata.name      = db_name
     metadata.namespace = db_ns
     metadata.labels    = db_labels
@@ -70,7 +70,7 @@ class Postgresql < Kube::Cluster::Manifest
 
   # Headless service for StatefulSet DNS — explicit because the
   # middleware-generated Service is a regular ClusterIP service.
-  class Service < Kube::Schema["Service"]
+  class Service < Kube::Cluster["Service"]
     metadata.name      = "#{db_name}-headless"
     metadata.namespace = db_ns
     metadata.labels    = db_labels

data/examples/{version2 → 03-app-with-database}/ruby_on_rails.rb

@@ -1,4 +1,4 @@
-class RubyOnRails < Kube::Schema["Deployment"]
+class RubyOnRails < Kube::Cluster["Deployment"]
   default do
     metadata.name      = name
     metadata.namespace = ns

data/kube_cluster.gemspec

@@ -32,7 +32,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rubocop", "~> 1.21"
 
-  spec.add_dependency "kube_schema", "~> 1.2.0"
+  spec.add_dependency "kube_schema", "~> 1.3.0"
   spec.add_dependency "kube_kit", "> 0"
   spec.add_dependency "kube_kubectl", "~> 2.0.0"
 end

data/lib/kube/cluster/manifest.rb

@@ -1,76 +1,25 @@
 # frozen_string_literal: true
 
-require_relative "manifest/stack"
-require_relative "manifest/middleware"
-require_relative "manifest/middleware/namespace"
-require_relative "manifest/middleware/labels"
-require_relative "manifest/middleware/annotations"
-require_relative "manifest/middleware/resource_preset"
-require_relative "manifest/middleware/security_context"
-require_relative "manifest/middleware/pod_anti_affinity"
-require_relative "manifest/middleware/service_for_deployment"
-require_relative "manifest/middleware/ingress_for_service"
-require_relative "manifest/middleware/hpa_for_deployment"
-
 module Kube
   module Cluster
-    # A Manifest subclass that runs resources through a middleware stack
-    # on enumeration. Manifests represent files — resources pass through
-    # middleware before rendering or saving.
+    # A flat, ordered collection of Kubernetes resources.
+    #
+    # Manifest is a pure resource collection. Middleware is applied
+    # separately via Kube::Cluster::Middleware::Stack.
     #
-    #   class MyApp < Kube::Cluster::Manifest
-    #     stack do
-    #       use Middleware::Namespace, "production"
-    #       use Middleware::Labels, app: "web-app"
-    #       use Middleware::ResourcePreset
-    #     end
+    #   manifest = Kube::Cluster::Manifest.new
+    #   manifest << Kube::Cluster["Deployment"].new { ... }
+    #
+    #   stack = Kube::Cluster::Middleware::Stack.new do
+    #     use Middleware::Namespace, "production"
+    #     use Middleware::Labels, app: "web-app"
     #   end
     #
-    #   app = MyApp.new
-    #   app << Kube::Schema["Deployment"].new { ... }
-    #   app.to_yaml  # resources have been transformed by the stack
+    #   stack.call(manifest)
+    #   manifest.to_yaml
     #
     class Manifest < Kube::Schema::Manifest
-      # Declare a middleware stack at the class level.
-      #
-      #   stack do
-      #     use Middleware::ResourcePreset
-      #     use Middleware::SecurityContext
-      #   end
-      #
-      def self.stack(&block)
-        @stack = Stack.new(&block)
-      end
-
-      # Enumerate resources after passing them through the middleware
-      # stack. The entire manifest is passed to the stack so that
-      # generative middleware can introduce new resources that
-      # subsequent stages will see and process.
-      #
-      # Every method that reads the manifest (to_yaml, to_a, map,
-      # select, etc.) goes through here.
-      def each(&block)
-        return enum_for(:each) unless block
-
-        stack = self.class.instance_variable_get(:@stack)
-        if stack
-          stack.call(@resources).each(&block)
-        else
-          @resources.each(&block)
-        end
-      end
-
-      # Override to_yaml so it renders through the middleware stack.
-      # The parent class accesses @resources directly, bypassing each.
-      def to_yaml
-        map { |r| r.to_yaml }.join("")
-      end
-
-      # Override to_a so it returns middleware-processed resources.
-      # The parent class returns @resources.dup directly.
-      def to_a
-        map(&:itself)
-      end
+      attr_reader :resources
     end
   end
 end

data/lib/kube/cluster/middleware/annotations.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Kube
+  module Cluster
+    class Middleware
+      # Merges annotations into +metadata.annotations+ on every resource.
+      # Existing annotations are preserved; the supplied annotations act
+      # as defaults that can be overridden per-resource.
+      #
+      #   stack do
+      #     use Middleware::Annotations,
+      #       "prometheus.io/scrape": "true",
+      #       "prometheus.io/port":   "9090"
+      #   end
+      #
+      class Annotations < Middleware
+        def initialize(**annotations)
+          @annotations = annotations.transform_keys(&:to_sym).transform_values(&:to_s)
+        end
+
+        def call(manifest)
+          manifest.resources.map! do |resource|
+            h = resource.to_h
+            h[:metadata] ||= {}
+            h[:metadata][:annotations] = @annotations.merge(h[:metadata][:annotations] || {})
+            resource.rebuild(h)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kube/cluster/middleware/hpa_for_deployment.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Kube
+  module Cluster
+    class Middleware
+      # Generates a HorizontalPodAutoscaler for every pod-bearing
+      # resource that carries the +app.kubernetes.io/autoscale+ label.
+      #
+      # The label value encodes the min and max replicas as "min-max":
+      #
+      #   metadata.labels = { "app.kubernetes.io/autoscale": "1-5" }
+      #
+      # Options:
+      #   cpu:    — target CPU utilization percentage (default: 75)
+      #   memory: — target memory utilization percentage (default: 80)
+      #
+      #   stack do
+      #     use Middleware::HPAForDeployment
+      #     use Middleware::HPAForDeployment, cpu: 60, memory: 70
+      #   end
+      #
+      class HPAForDeployment < Middleware
+        LABEL = :"app.kubernetes.io/autoscale"
+
+        def initialize(cpu: 75, memory: 80)
+          @cpu = cpu
+          @memory = memory
+        end
+
+        def call(manifest)
+          generated = []
+
+          manifest.resources.each do |resource|
+            next unless resource.pod_bearing?
+
+            value = resource.label(LABEL)
+            next unless value
+
+            min, max = parse_range(value)
+
+            h = resource.to_h
+            name      = h.dig(:metadata, :name)
+            namespace = h.dig(:metadata, :namespace)
+            labels    = h.dig(:metadata, :labels) || {}
+            api_version = h[:apiVersion] || "apps/v1"
+            resource_kind = resource.kind
+
+            # Capture ivars as locals — the block runs via instance_exec
+            # on a BlackHoleStruct, so @ivars would resolve on the BHS.
+            cpu_target    = @cpu
+            memory_target = @memory
+
+            generated << Kube::Cluster["HorizontalPodAutoscaler"].new {
+              metadata.name      = name
+              metadata.namespace = namespace if namespace
+              metadata.labels    = labels.reject { |k, _| k == LABEL }
+
+              spec.scaleTargetRef = {
+                apiVersion: api_version,
+                kind:       resource_kind,
+                name:       name,
+              }
+              spec.minReplicas = min
+              spec.maxReplicas = max
+              spec.metrics = [
+                {
+                  type: "Resource",
+                  resource: {
+                    name: "cpu",
+                    target: { type: "Utilization", averageUtilization: cpu_target },
+                  },
+                },
+                {
+                  type: "Resource",
+                  resource: {
+                    name: "memory",
+                    target: { type: "Utilization", averageUtilization: memory_target },
+                  },
+                },
+              ]
+            }
+          end
+
+          manifest.resources.concat(generated)
+        end
+
+        private
+
+          def parse_range(value)
+            parts = value.to_s.split("-", 2)
+
+            unless parts.length == 2
+              raise ArgumentError,
+                "Invalid autoscale label: #{value.inspect}. Expected format: \"min-max\" (e.g. \"1-5\")"
+            end
+
+            min = Integer(parts[0])
+            max = Integer(parts[1])
+
+            unless min > 0 && max >= min
+              raise ArgumentError,
+                "Invalid autoscale range: min=#{min}, max=#{max}. " \
+                "min must be > 0 and max must be >= min."
+            end
+
+            [min, max]
+          end
+      end
+    end
+  end
+end