kube_cluster 0.6.0 → 0.8.0

data/lib/kube/cluster/standard/env_processing.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module EnvProcessing
+        # Convert an env hash into a Kubernetes env array.
+        #
+        # String/numeric values become plain env vars:
+        #   "FOO" => "bar"  =>  { name: "FOO", value: "bar" }
+        #
+        # ExternalSecret::TemplateRef values become secretKeyRef env vars
+        # and register the template entry on the ExternalSecret:
+        #   "FOO" => secret.template("{{ .bar }}")
+        #     =>  { name: "FOO", valueFrom: { secretKeyRef: { name: "secret-name", key: "FOO" } } }
+        #
+        def self.process(env)
+          return env if env.is_a?(Array)
+          return [] if env.nil?
+
+          env.map do |key, value|
+            key = key.to_s
+
+            if value.is_a?(ExternalSecret::TemplateRef)
+              value.secret.register_template!(key, value.template_value)
+              { name: key, valueFrom: { secretKeyRef: { name: value.secret.secret_name, key: key } } }
+            else
+              { name: key, value: value.to_s }
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+test do
+  # no op
+end

data/lib/kube/cluster/standard/eso/external_secret.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module ESO
+        class ExternalSecret < Kube::Cluster['ExternalSecret']
+          # Returned by .template — carries the secret ref and template value.
+          # When the env hash is processed, the key becomes both the env var name
+          # and the secret template data key.
+          TemplateRef = Struct.new(:secret, :template_value)
+
+          # Returned by .key — carries the secret ref and key name.
+          # When the volume_mounts hash is processed, this tells the volume
+          # processing layer to mount a single key from the secret as a file.
+          KeyRef = Struct.new(:secret, :key_name)
+
+          attr_reader :secret_name
+
+          def initialize(name:, store:, remote_key:, keys: nil, deletion_policy: nil, &block)
+            @secret_name = name
+            @remote_key = remote_key
+            @_template_data = {}
+            @_remote_properties = {}
+            @_keys = keys
+            @_deletion_policy = deletion_policy
+
+            super() do
+              metadata.name = name
+              spec.refreshInterval = '1h'
+              spec.secretStoreRef = { kind: 'ClusterSecretStore', name: store }
+
+              target = { name: name, creationPolicy: 'Owner' }
+              target[:deletionPolicy] = deletion_policy if deletion_policy
+              spec.target = target
+
+              if keys
+                spec.data = keys.map do |secret_key, property|
+                  { secretKey: secret_key, remoteRef: { key: remote_key, property: property } }
+                end
+              end
+
+              instance_exec(&block) if block
+            end
+          end
+
+          # Returns a TemplateRef. The env hash processor calls .register!
+          # on the ref to wire up the template data and remote properties.
+          def template(template_string)
+            TemplateRef.new(self, template_string)
+          end
+          alias with_template template
+
+          # Returns a KeyRef for mounting a single key from this secret as a file.
+          # The volume processing layer uses this to generate the volume and mount.
+          def key(key_name)
+            KeyRef.new(self, key_name)
+          end
+
+          # Called by env processing to register a template entry.
+          def register_template!(env_key, template_string)
+            @_template_data[env_key] = template_string
+
+            template_string.scan(/\{\{\s*\.(\w+)\s*\}\}/) do |match|
+              @_remote_properties[match[0]] = true
+            end
+
+            @data.spec.target.template = { data: @_template_data }
+            @data.spec.data = @_remote_properties.keys.map do |prop|
+              { secretKey: prop, remoteRef: { key: @remote_key, property: prop } }
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+test do
+  describe "ESO::ExternalSecret" do
+    it "initializes without error" do
+      Kube::Cluster::Standard::ESO::ExternalSecret
+        .new(
+          name: "my-external-secret",
+          store: "my-cluster-store",
+          remote_key: "secret/data/my-app",
+        )
+        .to_yaml
+        .is_a?(String)
+        .should == true
+    end
+  end
+end

data/lib/kube/cluster/standard/forgejo/helm.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module Forgejo
+        class Helm < Kube::Cluster["HelmChart"]
+
+          CHART_VERSION = "16.2.1"
+
+          def initialize(
+            domain:,
+            chart_version: CHART_VERSION,
+            target_namespace: "default",
+            storage_size: "200Gi",
+            storage_class: "local-path",
+            node_selector: nil,
+            &block
+          )
+            super {
+              metadata.name = "forgejo"
+              metadata.namespace = "kube-system"
+              spec.version = chart_version
+              spec.chart = "oci://codeberg.org/forgejo-contrib/forgejo"
+              spec.targetNamespace = target_namespace
+              spec.valuesContent = <<~YAML
+                gitea:
+                  config:
+                    server:
+                      ROOT_URL: https://#{domain}/
+                      DOMAIN: #{domain}
+                      SSH_DOMAIN: #{domain}
+                persistence:
+                  enabled: true
+                  size: #{storage_size}
+                  storageClass: #{storage_class}
+                #{node_selector ? "nodeSelector:\n  kubernetes.io/hostname: #{node_selector}" : ""}
+              YAML
+
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+test do
+  describe "Forgejo::Helm" do
+    it "initializes without error" do
+      Kube::Cluster::Standard::Forgejo::Helm
+        .new(
+          domain: "git.facebook.com"
+        )
+        .to_yaml
+        .is_a?(String)
+        .should == true
+    end
+  end
+end

data/lib/kube/cluster/standard/gateway_api/http_route.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster   
+    module Standard
+      module GatewayApi
+        #class HTTPRoute < Kube::Cluster::Manifest
+        #end
+      end
+    end
+  end
+end
+
+test do
+  #describe "GatewayApi::HTTPRoute" do
+  #  it "initializes without error" do
+  #    Kube::Cluster::Standard::GatewayApi::HTTPRoute
+  #      .new(
+  #        name: nil,
+  #        hostname: nil,
+  #        service: nil,
+  #        namespace: nil,
+  #        port: nil,
+  #      )
+  #      .to_yaml
+  #      .is_a?(String)
+  #      .should == true
+  #  end
+  #end
+end

data/lib/kube/cluster/standard/job.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      class Job < Kube::Cluster["Secret"]
+        def initialize(name:, image:, env: {}, command: nil, backoff_limit: 3, ttl: 300, &block)
+          processed_env = EnvProcessing.process(env)
+
+          super() do
+            metadata.name = name
+
+            spec.backoffLimit = backoff_limit
+            spec.ttlSecondsAfterFinished = ttl
+            spec.template.spec.restartPolicy = 'OnFailure'
+
+            container = {
+              name: name,
+              image: image,
+              env: processed_env
+            }
+            container[:command] = command if command
+
+            spec.template.spec.containers = [container]
+
+            instance_exec(&block) if block
+          end
+        end
+      end
+    end
+  end
+end
+
+test do
+  describe "Job" do
+    it "initializes without error" do
+      Kube::Cluster::Standard::Job
+        .new(
+          name: "my-job",
+          image: "nixery.dev/cowsay", # nixery.dev is pretty sick, mate!
+        )
+        .to_yaml
+        .is_a?(String)
+        .should == true
+    end
+  end
+end

data/lib/kube/cluster/standard/kube_virt/virtual_machine.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module KubeVirt
+        class VirtualMachine < Kube::Cluster['VirtualMachine']
+          def initialize(name:, &block)
+            super() {
+              metadata.name = name
+              spec.template.metadata.labels = { 'kubevirt.io/domain' => name }
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+test do
+  describe "KubeVirt::VirtualMachine" do
+    it "initializes without error" do
+      Kube::Cluster::Standard::KubeVirt::VirtualMachine
+        .new(
+          name: "my-virtual-machine"
+        )
+        .to_yaml
+        .is_a?(String)
+        .should == true
+    end
+  end
+end

data/lib/kube/cluster/standard/meta_controller/composite_controller.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+# TEMPORARILY DISABLED: metacontroller.k8s.io CRDs (CompositeController) are not
+# registered in kube_schema, so subclassing the kind raises at load time and
+# aborts `require "kube/cluster"`. Commented out until the schema is registered.
+=begin
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster   
+    module Standard
+      module MetaController
+        class CompositeController < Kube::Cluster['CompositeController'] 
+          def initialize(
+            name:, webhook_url:,
+            resync_period: 30, parent_resource:, child_resources: {}, &block
+          )
+
+            resolved_parent   = resolve_ref(parent_resource)
+            resolved_children = resolve_hash(child_resources)
+    
+            super() {
+              metadata.name = "#{name}-composite-controller"
+              
+              spec.generateSelector    = true
+              spec.resyncPeriodSeconds = resync_period
+              spec.hooks.sync.webhook  = { url: webhook_url }
+              spec.parentResource      = resolved_parent
+              spec.childResources      = resolved_children
+              
+              instance_exec(&block) if block
+            } 
+          end
+          
+          private
+          
+            def resolve_ref(ref)
+              if ref.is_a?(Hash)
+                ref
+              else
+                if ref.is_a?(Class)
+                  klass = ref
+                else
+                  klass = ref.class
+                end
+
+                {
+                  apiVersion: klass.defaults['apiVersion'],
+                  resource:   klass.defaults['kind'].downcase.pluralize
+                } 
+              end 
+            end
+            
+            def resolve_hash(hash)
+              hash.map do |klass, options|
+                resolve_ref(klass).merge(options || {})
+              end
+            end
+        end 
+      end
+    end
+  end
+end
+
+test do
+  describe "MetaController::CompositeController" do
+    it "initializes without error" do
+      Kube::Cluster::Standard::MetaController::CompositeController
+        .new(
+          name: nil,
+          webhook_url: nil,
+        )
+        .to_yaml
+        .is_a?(String)
+        .should == true
+    end
+  end
+end
+=end

data/lib/kube/cluster/standard/meta_controller/decorator_controller.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# TEMPORARILY DISABLED: metacontroller.k8s.io CRDs (DecoratorController) are not
+# registered in kube_schema, so subclassing the kind raises at load time and
+# aborts `require "kube/cluster"`. Commented out until the schema is registered.
+=begin
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster   
+    module Standard
+      module MetaController
+        class DecoratorController < Kube::Cluster['DecoratorController'] 
+          def initialize(
+            name:, webhook_url:,
+            resync_period: 30, resources: {}, attachments: {}, &block
+          )
+
+            resolved_resources   = resolve_hash(resources)
+            resolved_attachments = resolve_hash(attachments)
+
+            super() {
+              metadata.name = name
+
+              spec.resources           = resolved_resources
+              spec.attachments         = resolved_attachments
+              spec.resyncPeriodSeconds = resync_period
+              spec.hooks.sync.webhook  = { url: webhook_url }
+
+              instance_exec(&block) if block
+            }
+          end
+
+          private
+
+            def resolve_ref(ref)
+              if ref.is_a?(Hash)
+                ref
+              else
+                if ref.is_a?(Class)
+                  klass = ref
+                else
+                  klass = ref.class
+                end
+
+                {
+                  apiVersion: klass.defaults['apiVersion'],
+                  resource:   klass.defaults['kind'].downcase.pluralize
+                }
+              end 
+            end
+
+            def resolve_hash(hash)
+              hash.map do |klass, options|
+                resolve_ref(klass).merge(options || {})
+              end
+            end
+        end
+      end
+    end
+  end
+end
+
+test do
+  describe "MetaController::DecoratorController" do
+    it "initializes without error" do
+      Kube::Cluster::Standard::MetaController::DecoratorController
+        .new(
+          name: nil,
+          webhook_url: nil,
+        )
+        .to_yaml
+        .is_a?(String)
+        .should == true
+    end
+  end
+end
+=end

data/lib/kube/cluster/standard/persistent_volume_claim.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      class PersistentVolumeClaim < Kube::Cluster["PersistentVolumeClaim"]
+        def initialize(name:, storage:, access_modes: ["ReadWriteOnce"], storage_class: nil, &block)
+          super() {
+            metadata.name = name
+            spec.accessModes = access_modes
+            spec.storageClassName = storage_class if storage_class
+            spec.resources = { requests: { storage: storage } }
+            instance_exec(&block) if block_given?
+          }
+        end
+      end
+    end
+  end
+end
+
+test do
+  describe "PersistentVolumeClaim" do
+    it "initializes without error" do
+      Kube::Cluster::Standard::PersistentVolumeClaim
+        .new(
+          name: "my-volume",
+          storage: "25Gi",
+        )
+        .to_yaml
+        .is_a?(String)
+        .should == true
+    end
+  end
+end

data/lib/kube/cluster/standard/secret.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      class Secret < Kube::Cluster["Secret"]
+        def initialize(name:, **data, &block)
+          super() {
+            metadata.name = name
+            data.each { |k, v| stringData[k.to_s] = v }
+            instance_exec(&block) if block_given?
+          }
+        end
+      end
+    end
+  end
+end
+
+test do
+  describe "Secret" do
+    it "initializes without error" do
+      Kube::Cluster::Standard::Secret
+        .new(
+          name: "my-secret"
+        )
+        .to_yaml
+        .is_a?(String)
+        .should == true
+    end
+  end
+end

data/lib/kube/cluster/standard/service.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      class Service < Kube::Cluster["Service"]
+        def initialize(name:, ports:, namespace: "default", **options, &block)
+          super() {
+            metadata.name = name
+            metadata.namespace = namespace
+            metadata.labels = { "app" => name }
+            spec.selector = { "app" => name }
+            spec.ports = ports.map do |port|
+              { name: "http-#{port}", port: port, targetPort: port, protocol: "TCP" }
+            end
+
+            instance_exec(&block) if block_given?
+          }
+        end
+      end
+    end
+  end
+end
+
+test do
+  describe "Service" do
+    it "initializes without error" do
+      Kube::Cluster::Standard::Service
+        .new(
+          name: "my-secret",
+          ports: [],
+        )
+        .to_yaml
+        .is_a?(String)
+        .should == true
+    end
+  end
+end

data/lib/kube/cluster/standard/volume_processing.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VolumeProcessing
+        # Convert a volume_mounts hash into Kubernetes volumes and volumeMounts arrays.
+        #
+        # Hash values (mount path => source ref):
+        #   ExternalSecret::KeyRef  => secret volume with items, mount with subPath + readOnly
+        #   ExternalSecret          => secret volume, directory mount
+        #   PersistentVolumeClaim   => persistentVolumeClaim volume, plain mount
+        #
+        # Legacy: if input is an Array, it is returned as-is for backwards compat.
+        #
+        def self.process(input)
+          return { volumes: [], volume_mounts: input } if input.is_a?(Array)
+          return { volumes: [], volume_mounts: [] } if input.nil? || input.empty?
+
+          volumes = []
+          mounts = []
+
+          input.each do |mount_path, source|
+            case source
+            when ExternalSecret::KeyRef
+              name = source.secret.secret_name
+              key  = source.key_name
+              volumes << {
+                name: name,
+                secret: {
+                  secretName: name,
+                  items: [{ key: key, path: key }]
+                }
+              }
+              mounts << {
+                name: name,
+                mountPath: mount_path,
+                subPath: key,
+                readOnly: true
+              }
+
+            when ExternalSecret
+              name = source.secret_name
+              volumes << { name: name, secret: { secretName: name } }
+              mounts  << { name: name, mountPath: mount_path }
+
+            when PersistentVolumeClaim
+              name = source.to_h.dig(:metadata, :name)
+              volumes << { name: name, persistentVolumeClaim: { claimName: name } }
+              mounts  << { name: name, mountPath: mount_path }
+
+            when ConfigMap::KeyRef
+              name = source.config_map.config_map_name
+              key  = source.key_name
+              volumes << {
+                name: name,
+                configMap: {
+                  name: name,
+                  items: [{ key: key, path: key }]
+                }
+              }
+              mounts << {
+                name: name,
+                mountPath: mount_path,
+                subPath: key,
+                readOnly: true
+              }
+
+            when ConfigMap
+              name = source.to_h.dig(:metadata, :name)
+              volumes << { name: name, configMap: { name: name } }
+              mounts  << { name: name, mountPath: mount_path, readOnly: true }
+            end
+          end
+
+          { volumes: volumes, volume_mounts: mounts }
+        end
+      end
+    end
+  end
+end
+
+test do
+  # no op
+end

data/lib/kube/cluster/version.rb

@@ -2,6 +2,6 @@
 
 module Kube
   module Cluster
-    VERSION = "0.6.0"
+    VERSION = "0.8.0"
   end
 end