kube_cluster 0.5.4 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f08a431382eaf0cccfb51c9d2bfd46428eef571da2d21bb147fc04168cc12ee
-  data.tar.gz: 98af3d4b4d90aeef68a38b59240a3d966c8ae421e8d73a3e191f957c9c34a42c
+  metadata.gz: 0f1c23db70574ae658780a8fcdcaefa84a23b917f206cce85749c84739ccd8c1
+  data.tar.gz: bd673c8ab74f4a2c6c046d27e40994cd7a819ad6e552b5a98e14fc1974f52bcc
 SHA512:
-  metadata.gz: 9eeeda7bcf98afac44f299b99d14d688b622cbe759725d5a0142c6c19be88cee89900584e2210de87e66acfc521db88d4025f3722fc56ebd362ae0b46ecd648d
-  data.tar.gz: 3c13178ef039b611ecddeded6a9ae35a9e3063299fe850e9d481a4ffe6c9f68fb7aa96b86d5749dd28cd4be32208b3575d9230cc4628840b191406656fd90597
+  metadata.gz: 49d328773bd999a1270386fec416f6a4afa0aa88d8fe6fe51e42af84e134154ac80b0220426c7be1b45e534ab2c164dc5ff22a9c0208f2d623c67aaba1be621e
+  data.tar.gz: fe000f50ed0f0b55a2b4efedc4fbedbf0bfcbf61039b64dd8584384cd0cf317d31e8b8db2d1bb79ae1b46dffcd6165ce27835d57cd5a9b86fbabdf976675dd21

data/.gitignore

@@ -6,3 +6,5 @@
 /tmp/
 /vendor/bundle
 /kubeconfig.yaml
+*.swo
+*.swp

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    kube_cluster (0.5.3)
+    kube_cluster (0.7.0)
       kube_kubectl (~> 2.0)
       kube_schema (~> 1.5)
       scampi (~> 0.1)

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module CloudNativePg
+        module Helm
+          class Operator < Kube::Cluster["HelmChart"]
+            def initialize(&block)
+              super {
+                metadata.name = "cloudnative-pg"
+                metadata.namespace = "kube-system"
+                spec.chart = "cloudnative-pg"
+                spec.version = "0.28.2"
+                spec.repo = "https://cloudnative-pg.github.io/charts"
+                spec.targetNamespace = "cnpg-system"
+                spec.createNamespace = true
+
+                instance_exec(&block) if block
+              }
+            end
+          end
+
+          # You shouldn't really need this... it's a dependency of
+          # the Operator chart...
+          #
+          # class Cluster < Kube::Cluster["HelmChart"]
+          #   def initialize(&block)
+          #     super {
+          #       metadata.name = "cloudnative-pg--cluster"
+          #       metadata.namespace = "kube-system"
+          #       spec.chart = "cluster"
+          #       spec.version = "0.6.1"
+          #       spec.repo = "https://cloudnative-pg.github.io/charts"
+          #       spec.targetNamespace = "cnpg-system"
+          #       spec.createNamespace = true
+
+          #       instance_exec(&block) if block
+          #     }
+          #   end
+          # end
+
+          class Barman < Kube::Cluster["HelmChart"]
+            def initialize(&block)
+              super {
+                metadata.name = "plugin-barman-cloud"
+                metadata.namespace = "kube-system"
+                spec.chart = "plugin-barman-cloud"
+                spec.version = "0.6.0"
+                spec.repo = "https://cloudnative-pg.github.io/charts"
+                spec.targetNamespace = "cnpg-system"
+                spec.createNamespace = true
+
+                instance_exec(&block) if block
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+test do
+  describe "Operator" do
+    it "initializes without error" do
+      Kube::Cluster::Standard::CloudNativePg::Helm::Operator
+        .new()
+        .to_yaml
+        .is_a?(String)
+        .should == true
+    end
+  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
+
+  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/cloud_native_pg.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module CloudNativePg
+      end
+    end
+  end
+end
+
+test do
+  # no op
+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

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/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.5.4"
+    VERSION = "0.7.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kube_cluster
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.7.0
 platform: ruby
 authors:
 - Nathan K
@@ -195,6 +195,13 @@ files:
 - lib/kube/cluster/resource/extensions/custom_resource_definition.rb
 - lib/kube/cluster/resource/persistence.rb
 - lib/kube/cluster/script_command.rb
+- lib/kube/cluster/standard/cloud_native_pg.rb
+- lib/kube/cluster/standard/cloud_native_pg/helm.rb
+- lib/kube/cluster/standard/deployment_with_service.rb
+- lib/kube/cluster/standard/env_processing.rb
+- lib/kube/cluster/standard/secret.rb
+- lib/kube/cluster/standard/service.rb
+- lib/kube/cluster/standard/volume_processing.rb
 - lib/kube/cluster/version.rb
 - lib/kube/cluster/version.rb.erb
 - lib/kube/errors.rb