kube_cluster 0.6.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4cfe0887eeac1f4f52fc6f4f9730e5db9dacc66e132765301380d2a16933ebe7
-  data.tar.gz: 9ab9e7350e92274bc4f4ba73f5ffc025d18035a87fee5ed2a1c1d29e1e9dfc5b
+  metadata.gz: 28348c8c7bfb6bb1e1340efeba20451d4b29c11a8e75454e87d805e3b6c4b36f
+  data.tar.gz: c1aa1ee8775553e15026dce80414949bd57da1371dac6bda72766aeba117db1f
 SHA512:
-  metadata.gz: 4d2f96411424735612533763d8e79430bcc52792399732de0b06ab9e9a5f07e3ec3329ffd04a479353d050753e404b6b0d66dbb920a26cc2f985a066dad10751
-  data.tar.gz: aff4fe39dabe60aee449c15e57656c7deaf33e73de8bbbc5a046186bec2fe6c79370e024ae86a4acb8f5b00218515a41bbf5fcf0468a56a8352474a8b6c5885f
+  metadata.gz: 48d13d3cd9b6578d44d2007392f89d3c1a3ab0838e1fcde8825d86b1e8cfe263f538ff3b5f92bf70155273c4e58bc68d2d7212c75a6c16a3bf1c06c56c0d91d8
+  data.tar.gz: 8cba24053f71e5f4d9efd117c7a477b00b5cdba21b57f6a2afa88a53f632e93f26791d532bdde06d8842477d3e40b15a0c9434b4a50245bc94a3db357ffbab72

data/Gemfile.lock

@@ -1,7 +1,8 @@
 PATH
   remote: .
   specs:
-    kube_cluster (0.6.0)
+    kube_cluster (0.8.0)
+      activesupport (~> 8.0)
       kube_kubectl (~> 2.0)
       kube_schema (~> 1.5)
       scampi (~> 0.1)
@@ -9,6 +10,19 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
+    activesupport (8.1.3)
+      base64
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.3.1)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      json
+      logger (>= 1.4.2)
+      minitest (>= 5.1)
+      securerandom (>= 0.3)
+      tzinfo (~> 2.0, >= 2.0.5)
+      uri (>= 0.13.1)
     ast (2.4.3)
     async (2.39.0)
       console (~> 1.29)
@@ -60,12 +74,14 @@ GEM
     bake-releases (0.5.4)
       bake (~> 0.21)
       markly (~> 0.8)
+    base64 (0.3.0)
     bigdecimal (4.1.2)
     build-files (1.10.2)
     colorize (1.1.0)
     colorize-extended (0.1.0)
       colorize (~> 1.1)
     concurrent-ruby (1.3.6)
+    connection_pool (3.0.2)
     console (1.34.3)
       fiber-annotation
       fiber-local (~> 1.1)
@@ -77,6 +93,7 @@ GEM
     decode (0.27.0)
       prism
       rbs
+    drb (2.2.3)
     erb (6.0.4)
     falcon (0.55.3)
       async
@@ -97,6 +114,8 @@ GEM
     fiber-storage (1.0.1)
     hana (1.3.7)
     http-accept (2.2.1)
+    i18n (1.14.8)
+      concurrent-ruby (~> 1.0)
     io-console (0.8.2)
     io-endpoint (0.17.2)
     io-event (1.16.0)
@@ -140,6 +159,9 @@ GEM
       mime-types-data (~> 3.2025, >= 3.2025.0507)
     mime-types-data (3.2026.0414)
     mini_mime (1.1.5)
+    minitest (6.0.6)
+      drb (~> 2.0)
+      prism (~> 1.5)
     msgpack (1.8.0)
     net-imap (0.6.4)
       date
@@ -215,6 +237,7 @@ GEM
       mapping (~> 1.0)
     scampi (0.1.7)
       colorize-extended
+    securerandom (0.4.1)
     shellwords (0.2.2)
     simpleidn (0.2.3)
     string-format (0.2.0)
@@ -224,9 +247,12 @@ GEM
     timeout (0.6.1)
     traces (0.18.2)
     tsort (0.2.0)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
     unicode-display_width (3.2.0)
       unicode-emoji (~> 4.1)
     unicode-emoji (4.2.0)
+    uri (1.1.1)
     utopia (2.32.1)
       bake (~> 0.20)
       concurrent-ruby (~> 1.2)

data/kube_cluster.gemspec

@@ -35,4 +35,5 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "kube_schema", "~> 1.5"
   spec.add_dependency "kube_kubectl", "~> 2.0"
+  spec.add_dependency "activesupport", "~> 8.0"
 end

data/lib/kube/cluster/standard/cdi/data_volume.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module CDI
+        #class DataVolume < Kube::Cluster['DataVolume']
+        #  def initialize(name:, &block)
+        #    super() {
+        #      metadata.name = name
+        #      instance_exec(&block) if block
+        #    }
+        #  end
+        #end
+      end
+    end
+  end
+end
+
+test do
+  #describe "CDI::DataVolume" do
+  #  it "initializes without error" do
+  #    Kube::Cluster::Standard::CDI::DataVolume
+  #      .new(
+  #        name: "my-example-volume"
+  #      )
+  #      .to_yaml
+  #      .is_a?(String)
+  #      .should == true
+  #  end
+  #end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module CloudNativePg
+        #class Cluster < Kube::Cluster["Cluster"]
+        #end
+      end
+    end
+  end
+end
+
+test do
+  #describe "CloudNativePg::Cluster" do
+  #  it "initializes without error" do
+  #    Kube::Cluster::Standard::CloudNativePg::Cluster
+  #      .new()
+  #      .to_yaml
+  #      .is_a?(String)
+  #      .should == true
+  #  end
+  #end
+end

data/lib/kube/cluster/standard/cloud_native_pg/database_with_external_secret.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module CloudNativePg
+        class DatabaseWithExternalSecret < Kube::Cluster::Manifest
+          def initialize(name:, cluster: "postgres", owner: "app", &block)
+            database = Kube::Cluster["Database"].new {
+              metadata.name = name
+              spec.cluster = { name: cluster }
+              spec.databaseReclaimPolicy = "retain"
+              spec.ensure = "present"
+              spec.name = name
+              spec.owner = owner
+            }
+
+            external_secret = CloudNativePg::ExternalSecret.new(name: name)
+
+            super(database, external_secret)
+            instance_exec(&block) if block
+          end
+        end
+      end
+    end
+  end
+end
+
+test do
+  describe "CloudNativePg::DatabaseWithExternalSecret" do
+    it "initializes without error" do
+      Kube::Cluster::Standard::CloudNativePg::DatabaseWithExternalSecret
+        .new(
+          name: "my-example-cluster"
+        )
+        .to_yaml
+        .is_a?(String)
+        .should == true
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module CloudNativePg
+        class ExternalSecret < Kube::Cluster["ExternalSecret"]
+
+          DB_HOST = "postgres-rw.cloudnative-pg.svc.cluster.local"
+
+          def initialize(name:, env_prefix: "DB", db_host: DB_HOST, &block)
+            super() {
+              metadata.name = "#{name}-db"
+              spec.refreshInterval = "1h"
+              spec.secretStoreRef = { kind: "ClusterSecretStore", name: "cnpg-credentials" }
+              spec.target = {
+                name: "#{name}-db",
+                creationPolicy: "Owner",
+                deletionPolicy: "Retain",
+                template: {
+                  data: {
+                    "#{env_prefix}_URL"      => "jdbc:postgresql://#{db_host}:5432/#{name}",
+                    "#{env_prefix}_USER"     => "{{ .username }}",
+                    "#{env_prefix}_PASSWORD" => "{{ .password }}",
+                  },
+                },
+              }
+              spec.data = [
+                { secretKey: "username", remoteRef: { key: "postgres-app", property: "username" } },
+                { secretKey: "password", remoteRef: { key: "postgres-app", property: "password" } },
+              ]
+
+              instance_exec(&block) if block_given?
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+test do
+  describe "CloudNativePg::ExternalSecret" do
+    it "initializes without error" do
+      Kube::Cluster::Standard::CloudNativePg::ExternalSecret
+        .new(
+          name: "my-external-secret"
+        )
+        .to_yaml
+        .is_a?(String)
+        .should == true
+    end
+  end
+end

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

@@ -30,7 +30,7 @@ module Kube
           # class Cluster < Kube::Cluster["HelmChart"]
           #   def initialize(&block)
           #     super {
-          #       metadata.name = "cloudnative-pg"
+          #       metadata.name = "cloudnative-pg--cluster"
           #       metadata.namespace = "kube-system"
           #       spec.chart = "cluster"
           #       spec.version = "0.6.1"
@@ -46,7 +46,7 @@ module Kube
           class Barman < Kube::Cluster["HelmChart"]
             def initialize(&block)
               super {
-                metadata.name = "cloudnative-pg"
+                metadata.name = "plugin-barman-cloud"
                 metadata.namespace = "kube-system"
                 spec.chart = "plugin-barman-cloud"
                 spec.version = "0.6.0"
@@ -65,27 +65,33 @@ module Kube
 end
 
 test do
-  it "Operator initializes without error" do
-    Kube::Cluster::Standard::CloudNativePg::Helm::Operator
-      .new()
-      .to_yaml
-      .is_a?(String)
-      .should == true
+  describe "Operator" do
+    it "initializes without error" do
+      Kube::Cluster::Standard::CloudNativePg::Helm::Operator
+        .new()
+        .to_yaml
+        .is_a?(String)
+        .should == true
+    end
   end
 
-  # it "Cluster initializes without error" do
-  #   Kube::Cluster::Standard::CloudNativePg::Helm::Cluster
-  #     .new()
-  #     .to_yaml
-  #     .is_a?(String)
-  #     .should == true
-  # end
+  #describe "Cluster" do
+  #  it "initializes without error" do
+  #    Kube::Cluster::Standard::CloudNativePg::Helm::Cluster
+  #      .new()
+  #      .to_yaml
+  #      .is_a?(String)
+  #      .should == true
+  #  end
+  #end
 
-  it "Barman initializes without error" do
-    Kube::Cluster::Standard::CloudNativePg::Helm::Barman
-      .new()
-      .to_yaml
-      .is_a?(String)
-      .should == true
+  describe "Barman" do
+    it "initializes without error" do
+      Kube::Cluster::Standard::CloudNativePg::Helm::Barman
+        .new()
+        .to_yaml
+        .is_a?(String)
+        .should == true
+    end
   end
 end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      class ConfigMap < Kube::Cluster['ConfigMap']
+
+        # wtf is this????? I hate it... claude made it and it needs to dead...
+        KeyRef = Struct.new(:config_map, :key_name)
+
+        def initialize(name: 'config', **options, &block)
+          super(**options) do
+            metadata.name = name
+            instance_exec(&block) if block
+          end
+        end
+
+        def config_map_name
+          to_h.dig(:metadata, :name)
+        end
+
+        def key(key_name)
+          KeyRef.new(self, key_name)
+        end
+      end
+    end
+  end
+end
+
+test do
+  describe "ConfigMap" do
+    it "initializes without error" do
+      Kube::Cluster::Standard::ConfigMap
+        .new(
+          #name: "example-config"
+        )
+        .to_yaml
+        .is_a?(String)
+        .should == true
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      class CustomResourceDefinition < Kube::Cluster['CustomResourceDefinition']
+        def initialize(
+          kind:, group:, version: 'v1', scope: 'Namespaced',
+          short_names: [], categories: [], schema: nil, &block
+        )
+
+          plural   = kind.downcase.pluralize
+          singular = kind.downcase
+
+          schema ||= {
+            type: 'object',
+            'x-kubernetes-preserve-unknown-fields': true
+          }
+
+          super() {
+            metadata.name = "#{plural}.#{group}"
+
+            spec.group          = group
+            spec.names.kind     = kind
+            spec.names.listKind = "#{kind}List"
+            spec.names.plural   = plural
+            spec.names.singular = singular
+            spec.names.shortNames = short_names unless short_names.empty?
+            spec.names.categories = categories  unless categories.empty?
+            spec.scope          = scope
+            spec.versions = [{
+              name:         version,
+              served:       true,
+              storage:      true,
+              subresources: { status: {} },
+              schema: {
+                openAPIV3Schema: schema
+              }
+            }]
+
+            instance_exec(&block) if block
+          }
+
+          api_version = "#{group}/#{version}"
+          Kube::Schema.register(
+            kind,
+            schema:      {
+              'type' => 'object',
+              'properties' => {
+                'apiVersion' => { 'type' => 'string' },
+                'kind'       => { 'type' => 'string' },
+                'metadata'   => { 'type' => 'object' },
+                'spec'       => { 'type' => 'object', 'x-kubernetes-preserve-unknown-fields' => true },
+                'status'     => { 'type' => 'object', 'x-kubernetes-preserve-unknown-fields' => true }
+              },
+              'x-kubernetes-preserve-unknown-fields' => true
+            },
+            api_version: api_version
+          )
+        end
+      end
+    end
+  end
+end
+
+test do
+  describe "CustomResourceDefinition" do
+    it "initializes without error" do
+      Kube::Cluster::Standard::CustomResourceDefinition
+        .new(
+          kind: "Widget",
+          group: "example.com",
+        )
+        .to_yaml
+        .is_a?(String)
+        .should == true
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'kube/cluster'
+require 'kube/cluster/standard/env_processing'
+require 'kube/cluster/standard/volume_processing'
+
+module Kube
+  module Cluster
+    module Standard
+      class DaemonSet < Kube::Cluster['DaemonSet']
+        def initialize(
+          name:,
+          image:,
+          env: {},
+          volume_mounts: {},
+          command: nil,
+          service_account: nil,
+          node_selector: nil,
+          tolerations: nil,
+          host_pid: false,
+          &block
+        )
+          processed_env     = EnvProcessing.process(env)
+          processed_volumes = VolumeProcessing.process(volume_mounts)
+
+          super() {
+            metadata.name   = name
+            metadata.labels = { 'app' => name }
+
+            spec.selector.matchLabels = { 'app' => name }
+
+            spec.template.metadata.labels        = { 'app' => name }
+            spec.template.spec.serviceAccountName = service_account || name
+
+            container = {
+              name:  name,
+              image: image,
+              env:   processed_env
+            }
+            container[:command] = command if command
+            container[:volumeMounts] = processed_volumes[:volume_mounts] unless processed_volumes[:volume_mounts].empty?
+
+            spec.template.spec.containers = [container]
+            spec.template.spec.volumes = processed_volumes[:volumes] unless processed_volumes[:volumes].empty?
+            spec.template.spec.hostPID = true if host_pid
+            spec.template.spec.nodeSelector = node_selector if node_selector
+            spec.template.spec.tolerations = tolerations if tolerations
+
+            instance_exec(&block) if block
+          }
+        end
+      end
+    end
+  end
+end
+
+test do
+  describe "DaemonSet" do
+    it "initializes without error" do
+      Kube::Cluster::Standard::DaemonSet
+        .new(
+          name: "my-daemon",
+          image: "busybox",
+        )
+        .to_yaml
+        .is_a?(String)
+        .should == true
+    end
+  end
+end

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

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      class DeploymentWithService < Kube::Cluster::Manifest
+        def initialize(
+          name:,
+          image:,
+          port:,
+          namespace: 'default',
+          env: {},
+          security_context: nil,
+          pod_security_context: nil,
+          volume_mounts: {},
+          service_port: nil,
+          &block
+        )
+          @_limits = {}
+          @_probes = {}
+
+          processed_env     = EnvProcessing.process(env)
+          processed_volumes = VolumeProcessing.process(volume_mounts)
+
+          service_ports = Array(service_port || port)
+
+          service = Kube::Cluster::Standard::Service.new(
+            name: name,
+            namespace: namespace,
+            ports: service_ports
+          )
+
+          deployment = Kube::Cluster['Deployment'].new do
+            metadata.name = name
+            metadata.namespace = namespace
+            metadata.labels = { 'app' => name }
+
+            spec.replicas = 1
+            spec.selector.matchLabels = { 'app' => name }
+
+            spec.template.metadata.labels = { 'app' => name }
+            spec.template.spec.securityContext = pod_security_context if pod_security_context
+
+            container = {
+              name: name,
+              image: image,
+              ports: [{ name: 'http', containerPort: port, protocol: 'TCP' }],
+              env: processed_env
+            }
+            container[:securityContext] = security_context if security_context
+            container[:volumeMounts] = processed_volumes[:volume_mounts] unless processed_volumes[:volume_mounts].empty?
+
+            spec.template.spec.containers = [container]
+            spec.template.spec.volumes = processed_volumes[:volumes] unless processed_volumes[:volumes].empty?
+          end
+
+          super(deployment, service)
+
+          instance_exec(&block) if block
+
+          _apply_limits(deployment)
+          _apply_probes(deployment)
+        end
+
+        def limits
+          @_limits
+        end
+
+        def probes
+          @_probes
+        end
+
+        private
+
+        def _apply_limits(deployment)
+          return if @_limits.empty?
+
+          container = deployment.to_h[:spec][:template][:spec][:containers][0]
+          resources = {}
+
+          @_limits.each do |resource_type, mapping|
+            mapping.each do |request, limit|
+              resources[:requests] ||= {}
+              resources[:requests][resource_type] = request.to_s
+
+              if limit != Float::INFINITY
+                resources[:limits] ||= {}
+                resources[:limits][resource_type] = limit.to_s
+              end
+            end
+          end
+
+          container[:resources] = resources
+          h = deployment.to_h
+          h[:spec][:template][:spec][:containers][0] = container
+          deployment.rebuild(h)
+        end
+
+        def _apply_probes(deployment)
+          return if @_probes.empty?
+          return unless @_probes[:url]
+
+          container = deployment.to_h[:spec][:template][:spec][:containers][0]
+          url = @_probes[:url]
+
+          if @_probes[:liveness]
+            delay, period = @_probes[:liveness].first
+            container[:livenessProbe] = {
+              httpGet: url,
+              initialDelaySeconds: delay,
+              periodSeconds: period,
+              timeoutSeconds: 5
+            }
+          end
+
+          if @_probes[:readiness]
+            delay, period = @_probes[:readiness].first
+            container[:readinessProbe] = {
+              httpGet: url,
+              initialDelaySeconds: delay,
+              periodSeconds: period,
+              timeoutSeconds: 5
+            }
+          end
+
+          h = deployment.to_h
+          h[:spec][:template][:spec][:containers][0] = container
+          deployment.rebuild(h)
+        end
+      end
+    end
+  end
+end
+
+test do
+  describe "DeploymentWithService" do
+    it "initializes without error" do
+      Kube::Cluster::Standard::DeploymentWithService
+        .new(
+          name: "pointless-ruby-container",
+          image: "ruby/ruby",
+          port: 3000,
+        )
+        .to_yaml
+        .is_a?(String)
+        .should == true
+    end
+  end
+end