kube_cluster 0.3.7 → 0.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de5958c26954185923d57f941d9ecea6972b30a7df0a2014e691621c62f731f9
-  data.tar.gz: f593ad383f34c30cf5a3665f32fceee285fd4eb7dc1302bd7189e36b3680f5ed
+  metadata.gz: abe22aedfb5ac2ca4451e036aaa97364c551cdb6ff795bd05057f47311cd801b
+  data.tar.gz: 77300dffe8e8189dc95996ed080283e94ba316ae894fa36e4a94bc9a18045e68
 SHA512:
-  metadata.gz: 3610b3f4b74e0c547746bf155f0b717d0cc5a4f7229b04defd35d3baacf5151ddfdda0ba9ac389764a7dc5335d80042062ce178adb04c4485126e68a0cceda60
-  data.tar.gz: a1a31a19a6bd3995b924250f55fe91ddd9397cb20d3dd5d1b243bd01abda5cc6e44aa062e9b4b4b4def02a766f6857be654a959861695c508a5612a443a02d06
+  metadata.gz: 5d2b36b773ada5eb5ec794125f825155c6910cf737e67bcbcd9c6f40ec0508e5752fb9744a78d94344ad7f42b7acf19c38ab2ac55c6c148a9eac57fcac0499fe
+  data.tar.gz: 668b0c45f7b9229eb4476f0d536545afa1e060e8b970f8ae968dc9dfef39fda93df5786b9f804e7a31d284fb7e4d2adbeeb8f7d7ff5c9199233e0e6a6c08588d

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    kube_cluster (0.3.7)
-      kube_kubectl (~> 2.0.0)
+    kube_cluster (0.3.8)
+      kube_kubectl (~> 2.0.9)
       kube_schema (~> 1.3.0)
 
 GEM
@@ -28,12 +28,12 @@ GEM
       hana (~> 1.3)
       regexp_parser (~> 2.0)
       simpleidn (~> 0.2)
-    kube_kubectl (2.0.8)
+    kube_kubectl (2.0.9)
       debug (~> 1.11)
       json_schemer (~> 2.5)
       rubyshell (~> 1.5)
       shellwords (~> 0.2.2)
-      string_builder (~> 1.2.0)
+      string_builder (~> 1.2.2)
     kube_schema (1.3.4)
       json_schemer (~> 2.5.0)
       rubyshell (~> 1.5.0)
@@ -79,7 +79,7 @@ GEM
     rubyshell (1.5.0)
     shellwords (0.2.2)
     simpleidn (0.2.3)
-    string_builder (1.2.1)
+    string_builder (1.2.2)
     stringio (3.2.0)
     tsort (0.2.0)
     unicode-display_width (3.2.0)

data/README.md

@@ -1,15 +1,138 @@
 # kube_cluster
 
-A template for creating Ruby gems.
+Ruby-native Kubernetes. Define, transform, and deploy cluster resources with pure Ruby.
 
-## Usage
+## Install
 
-```bash
-git clone https://github.com/n-at-han-k/kube_cluster
-cd kube_cluster
-bin/rename-gem my-new-gem
-bin/update-spec
-bin/choose-license
-bin/increment-version patch
-bin/release-gem
+```ruby
+gem "kube_cluster", "~> 0.3"
 ```
+
+## Examples
+
+### Define a resource
+
+```ruby
+pod = Kube::Cluster["Pod"].new {
+  metadata.name = "redis"
+  spec.containers = [{ name: "redis", image: "redis:8" }]
+}
+
+puts pod.to_yaml
+```
+
+### Subclass for reuse
+
+```ruby
+class RedisPod < Kube::Cluster["Pod"]
+  def initialize(&block)
+    super {
+      metadata.name = "redis"
+      spec.containers = [{ name: "redis", image: "redis:8", ports: [{ containerPort: 6379 }] }]
+    }
+    instance_exec(&block) if block_given?
+  end
+end
+
+puts RedisPod.new { metadata.namespace = "production" }.to_yaml
+```
+
+### Manifest + middleware
+
+One Deployment declaration becomes a fully-configured stack:
+
+```ruby
+manifest = Kube::Cluster::Manifest.new(
+  Kube::Cluster["Deployment"].new {
+    metadata.name = "web"
+    metadata.labels = {
+      "app.kubernetes.io/expose": "app.example.com",
+      "app.kubernetes.io/autoscale": "2-10",
+      "app.kubernetes.io/size": "small"
+    }
+    spec.selector.matchLabels = { app: "web" }
+    spec.template.spec.containers = [
+      { name: "web", image: "nginx", ports: [{ name: "http", containerPort: 8080 }] }
+    ]
+  }
+)
+
+Kube::Cluster::Middleware::Stack.new {
+  use Middleware::ServiceForDeployment
+  use Middleware::IngressForService
+  use Middleware::HPAForDeployment
+  use Middleware::Namespace, "production"
+  use Middleware::Labels, managed_by: "kube_cluster"
+  use Middleware::ResourcePreset
+  use Middleware::SecurityContext
+  use Middleware::PodAntiAffinity
+}.call(manifest)
+
+puts manifest.to_yaml  # => Deployment, Service, Ingress, HPA — all configured
+```
+
+### Dirty tracking + patching
+
+```ruby
+cluster = Kube::Cluster.connect(kubeconfig: "~/.kube/config")
+
+config = Kube::Cluster["ConfigMap"].new(cluster:) {
+  metadata.name = "app-config"
+  self.data = { version: "1" }
+}
+
+config.apply           # creates on cluster
+config.data.version = "2"
+config.changed?        # => true
+config.patch           # sends only { data: { version: "2" } }
+```
+
+### Helm charts as manifests
+
+```ruby
+manifest = Kube::Helm::Repo
+  .new("bitnami", url: "https://charts.bitnami.com/bitnami")
+  .fetch("nginx", version: "18.1.0")
+  .apply_values("replicaCount" => 3)
+
+puts manifest.to_yaml
+```
+
+### Register CRDs as first-class resources
+
+```ruby
+chart = Kube::Helm::Repo.new("jetstack", url: "https://charts.jetstack.io")
+  .fetch("cert-manager", version: "1.17.2")
+
+chart.crds.each { |crd|
+  s = crd.to_json_schema
+  Kube::Schema.register(s[:kind], schema: s[:schema], api_version: s[:api_version])
+}
+
+issuer = Kube::Cluster["ClusterIssuer"].new {
+  metadata.name = "letsencrypt"
+  spec.acme.server = "https://acme-v02.api.letsencrypt.org/directory"
+}
+```
+
+## Middleware
+
+| Middleware | Effect |
+|---|---|
+| `Namespace` | Sets `metadata.namespace` on all resources |
+| `Labels` | Merges standard Kubernetes labels |
+| `Annotations` | Merges annotations |
+| `ResourcePreset` | Injects CPU/memory from `app.kubernetes.io/size` (nano → 2xlarge) |
+| `SecurityContext` | Injects restricted/baseline security contexts |
+| `PodAntiAffinity` | Spreads pods across nodes |
+| `ServiceForDeployment` | Generates Service from named container ports |
+| `IngressForService` | Generates Ingress from `app.kubernetes.io/expose` label |
+| `HPAForDeployment` | Generates HPA from `app.kubernetes.io/autoscale` label |
+
+## More examples
+
+See the [`examples/`](examples/) directory for complete runnable projects.
+
+## License
+
+Apache-2.0

data/Rakefile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+task :test do
+  Dir["lib/**/*.rb"].each { |f| sh "ruby", f }
+end
+
+task default: :test

data/bin/test

@@ -1,14 +1,16 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-$LOAD_PATH.unshift File.expand_path("../test", __dir__)
-
-require "bundler/setup"
-
 Dir.chdir(File.expand_path("..", __dir__))
 
 if ARGV.empty?
-  Dir.glob("test/**/*_test.rb").sort.each { |f| require_relative "../#{f}" }
+  files = Dir.glob("lib/**/*.rb").sort.select { |f|
+    File.read(f).include?("if __FILE__ == $0")
+  }
 else
-  ARGV.each { |f| require_relative "../#{f}" }
+  files = ARGV
+end
+
+files.each do |f|
+  system("bundle", "exec", "ruby", f, exception: true)
 end

data/kube_cluster.gemspec

@@ -33,5 +33,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rubocop", "~> 1.21"
 
   spec.add_dependency "kube_schema", "~> 1.3.0"
-  spec.add_dependency "kube_kubectl", "~> 2.0.0"
+  spec.add_dependency "kube_kubectl", "~> 2.0.9"
 end

data/lib/kube/cluster/manifest.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+if __FILE__ == $0
+  require "bundler/setup"
+  require "kube/cluster"
+end
+
 module Kube
   module Cluster
     # A flat, ordered collection of Kubernetes resources.
@@ -23,3 +28,236 @@ module Kube
     end
   end
 end
+
+if __FILE__ == $0
+  require "minitest/autorun"
+
+  class ManifestTest < Minitest::Test
+    Middleware = Kube::Cluster::Middleware
+
+    # ── Bare manifest ────────────────────────────────────────────────────────
+
+    def test_bare_manifest_enumerates_resources_unchanged
+      m = Kube::Cluster::Manifest.new
+      m << Kube::Cluster["ConfigMap"].new {
+        metadata.name = "test"
+        self.data = { key: "value" }
+      }
+
+      resources = m.to_a
+      assert_equal 1, resources.size
+      assert_equal "ConfigMap", resources.first.to_h[:kind]
+      assert_equal "test", resources.first.to_h.dig(:metadata, :name)
+    end
+
+    # ── Stack transforms resources ───────────────────────────────────────────
+
+    def test_stack_transforms_resources
+      m = Kube::Cluster::Manifest.new
+      m << Kube::Cluster["ConfigMap"].new {
+        metadata.name = "test"
+      }
+
+      stack = Middleware::Stack.new do
+        use Middleware::Namespace, "production"
+      end
+      stack.call(m)
+
+      resources = m.to_a
+      assert_equal "production", resources.first.to_h.dig(:metadata, :namespace)
+    end
+
+    def test_to_yaml_reflects_middleware
+      m = Kube::Cluster::Manifest.new
+      m << Kube::Cluster["ConfigMap"].new {
+        metadata.name = "test"
+      }
+
+      Middleware::Namespace.new("production").call(m)
+
+      yaml = m.to_yaml
+      assert_includes yaml, "namespace: production"
+    end
+
+    def test_enumerable_methods_work
+      m = Kube::Cluster::Manifest.new
+      m << Kube::Cluster["ConfigMap"].new { metadata.name = "a" }
+      m << Kube::Cluster["ConfigMap"].new { metadata.name = "b" }
+
+      Middleware::Namespace.new("production").call(m)
+
+      names = m.map { |r| r.to_h.dig(:metadata, :name) }
+      assert_equal %w[a b], names
+
+      all_namespaced = m.all? { |r| r.to_h.dig(:metadata, :namespace) == "production" }
+      assert all_namespaced
+    end
+
+    # ── Multi-middleware stack ──────────────────────────────────────────────
+
+    def test_multiple_middleware_compose_in_order
+      m = Kube::Cluster::Manifest.new
+      m << Kube::Cluster["ConfigMap"].new {
+        metadata.name = "test"
+      }
+
+      stack = Middleware::Stack.new do
+        use Middleware::Namespace, "staging"
+        use Middleware::Labels, app: "myapp", managed_by: "kube_cluster"
+      end
+      stack.call(m)
+
+      r = m.first
+      h = r.to_h
+
+      assert_equal "staging", h.dig(:metadata, :namespace)
+      assert_equal "myapp", h.dig(:metadata, :labels, :"app.kubernetes.io/name")
+      assert_equal "kube_cluster", h.dig(:metadata, :labels, :"app.kubernetes.io/managed-by")
+    end
+
+    # ── size reflects resource count ─────────────────────────────────────────
+
+    def test_size_reflects_resource_count
+      m = Kube::Cluster::Manifest.new
+      m << Kube::Cluster["ConfigMap"].new { metadata.name = "a" }
+      m << Kube::Cluster["ConfigMap"].new { metadata.name = "b" }
+
+      assert_equal 2, m.size
+      assert_equal 2, m.length
+    end
+
+    # ── each without block ──────────────────────────────────────────────────
+
+    def test_each_without_block_returns_enumerator
+      m = Kube::Cluster::Manifest.new
+      m << Kube::Cluster["ConfigMap"].new { metadata.name = "test" }
+
+      Middleware::Namespace.new("production").call(m)
+
+      enum = m.each
+      assert_instance_of Enumerator, enum
+
+      r = enum.first
+      assert_equal "production", r.to_h.dig(:metadata, :namespace)
+    end
+
+    # ── Generative middleware produces new resources ─────────────────────────
+
+    def test_generative_middleware_adds_service
+      m = Kube::Cluster::Manifest.new
+      m << Kube::Cluster["Deployment"].new {
+        metadata.name = "web"
+        metadata.namespace = "default"
+        spec.selector.matchLabels = { app: "web" }
+        spec.template.metadata.labels = { app: "web" }
+        spec.template.spec.containers = [
+          { name: "web", image: "nginx", ports: [{ name: "http", containerPort: 8080 }] },
+        ]
+      }
+
+      Middleware::ServiceForDeployment.new.call(m)
+
+      kinds = m.map { |r| r.to_h[:kind] }
+      assert_equal %w[Deployment Service], kinds
+    end
+
+    def test_generative_middleware_does_not_affect_non_matching_resources
+      m = Kube::Cluster::Manifest.new
+      m << Kube::Cluster["ConfigMap"].new {
+        metadata.name = "config"
+      }
+
+      Middleware::ServiceForDeployment.new.call(m)
+
+      resources = m.to_a
+      assert_equal 1, resources.size
+      assert_equal "ConfigMap", resources.first.to_h[:kind]
+    end
+
+    # ── Generated resources flow through subsequent middleware stages ────────
+
+    def test_generated_resources_flow_through_subsequent_stages
+      m = Kube::Cluster::Manifest.new
+      m << Kube::Cluster["Deployment"].new {
+        metadata.name = "web"
+        spec.selector.matchLabels = { app: "web" }
+        spec.template.metadata.labels = { app: "web" }
+        spec.template.spec.containers = [
+          { name: "web", image: "nginx", ports: [{ name: "http", containerPort: 8080 }] },
+        ]
+      }
+
+      stack = Middleware::Stack.new do
+        use Middleware::ServiceForDeployment           # generates Service
+        use Middleware::Namespace, "production"         # namespaces everything
+        use Middleware::Labels, managed_by: "middleware" # labels everything
+      end
+      stack.call(m)
+
+      resources = m.to_a
+      assert_equal 2, resources.size
+
+      # Both the Deployment and the generated Service got namespaced and labeled
+      resources.each do |r|
+        h = r.to_h
+        assert_equal "production", h.dig(:metadata, :namespace),
+          "Expected #{h[:kind]} to be namespaced"
+        assert_equal "middleware", h.dig(:metadata, :labels, :"app.kubernetes.io/managed-by"),
+          "Expected #{h[:kind]} to be labeled"
+      end
+    end
+
+    # ── YAML serializes integers correctly ──────────────────────────────────
+
+    def test_to_yaml_serializes_integers_as_plain_values
+      m = Kube::Cluster::Manifest.new
+      m << Kube::Cluster["Deployment"].new {
+        metadata.name = "web"
+        spec.selector.matchLabels = { app: "web" }
+        spec.template.metadata.labels = { app: "web" }
+        spec.template.spec.containers = [
+          { name: "web", image: "nginx", ports: [{ name: "http", containerPort: 8080 }] },
+        ]
+      }
+
+      yaml = m.to_yaml
+      refute_includes yaml, "!ruby/object:Integer",
+        "Integer values must serialize as plain YAML numbers, not !ruby/object:Integer"
+      assert_includes yaml, "containerPort: 8080"
+    end
+
+    # ── Multi-generative: chained generation ────────────────────────────────
+
+    def test_chained_generative_middleware
+      m = Kube::Cluster::Manifest.new
+      m << Kube::Cluster["Deployment"].new {
+        metadata.name = "web"
+        metadata.namespace = "default"
+        metadata.labels = {
+          "app.kubernetes.io/expose":    "app.example.com",
+          "app.kubernetes.io/autoscale": "2-10",
+        }
+        spec.selector.matchLabels = { app: "web" }
+        spec.template.metadata.labels = { app: "web" }
+        spec.template.spec.containers = [
+          { name: "web", image: "nginx", ports: [{ name: "http", containerPort: 8080 }] },
+        ]
+      }
+
+      stack = Middleware::Stack.new do
+        use Middleware::ServiceForDeployment   # Deployment → +Service
+        use Middleware::IngressForService       # Service with expose label → +Ingress
+        use Middleware::HPAForDeployment        # Deployment with autoscale label → +HPA
+      end
+      stack.call(m)
+
+      kinds = m.map { |r| r.to_h[:kind] }
+
+      assert_includes kinds, "Deployment"
+      assert_includes kinds, "Service"
+      assert_includes kinds, "Ingress"
+      assert_includes kinds, "HorizontalPodAutoscaler"
+      assert_equal 4, m.to_a.size
+    end
+  end
+end

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

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+if __FILE__ == $0
+  require "bundler/setup"
+  require "kube/cluster"
+end
+
 module Kube
   module Cluster
     class Middleware
@@ -30,3 +35,67 @@ module Kube
     end
   end
 end
+
+if __FILE__ == $0
+  require "minitest/autorun"
+
+  class AnnotationsMiddlewareTest < Minitest::Test
+    Middleware = Kube::Cluster::Middleware
+
+    def test_adds_annotations
+      m = manifest(Kube::Cluster["ConfigMap"].new { metadata.name = "test" })
+
+      Middleware::Annotations.new(
+        "prometheus.io/scrape": "true",
+        "prometheus.io/port": "9090",
+      ).call(m)
+
+      annotations = m.resources.first.to_h.dig(:metadata, :annotations)
+
+      assert_equal "true", annotations[:"prometheus.io/scrape"]
+      assert_equal "9090", annotations[:"prometheus.io/port"]
+    end
+
+    def test_resource_annotations_override_middleware_defaults
+      m = manifest(Kube::Cluster["ConfigMap"].new {
+        metadata.name = "test"
+        metadata.annotations = { "prometheus.io/port": "8080" }
+      })
+
+      Middleware::Annotations.new("prometheus.io/port": "9090").call(m)
+      annotations = m.resources.first.to_h.dig(:metadata, :annotations)
+
+      assert_equal "8080", annotations[:"prometheus.io/port"]
+    end
+
+    def test_preserves_existing_annotations
+      m = manifest(Kube::Cluster["ConfigMap"].new {
+        metadata.name = "test"
+        metadata.annotations = { "custom/annotation": "keep" }
+      })
+
+      Middleware::Annotations.new("prometheus.io/scrape": "true").call(m)
+      annotations = m.resources.first.to_h.dig(:metadata, :annotations)
+
+      assert_equal "keep", annotations[:"custom/annotation"]
+      assert_equal "true", annotations[:"prometheus.io/scrape"]
+    end
+
+    def test_converts_values_to_strings
+      m = manifest(Kube::Cluster["ConfigMap"].new { metadata.name = "test" })
+
+      Middleware::Annotations.new("prometheus.io/port": 9090).call(m)
+      annotations = m.resources.first.to_h.dig(:metadata, :annotations)
+
+      assert_equal "9090", annotations[:"prometheus.io/port"]
+    end
+
+    private
+
+      def manifest(*resources)
+        m = Kube::Cluster::Manifest.new
+        resources.each { |r| m << r }
+        m
+      end
+  end
+end