kube_cluster 0.2.0 → 0.2.1

data/lib/kube/cluster/manifest.rb

@@ -0,0 +1,76 @@
+# 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.
+    #
+    #   class MyApp < Kube::Cluster::Manifest
+    #     stack do
+    #       use Middleware::Namespace, "production"
+    #       use Middleware::Labels, app: "web-app"
+    #       use Middleware::ResourcePreset
+    #     end
+    #   end
+    #
+    #   app = MyApp.new
+    #   app << Kube::Schema["Deployment"].new { ... }
+    #   app.to_yaml  # resources have been transformed by the stack
+    #
+    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
+    end
+  end
+end

data/lib/kube/cluster/resource/dirty_tracking.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Kube
+  module Cluster
+    class Resource < Kube::Schema::Resource
+      module DirtyTracking
+        def changed?
+          to_h != @clean
+        end
+
+        def changed
+          diff_keys(to_h, @clean)
+        end
+
+        def changes
+          build_changes(to_h, @clean)
+        end
+
+        def changes_applied
+          snapshot!
+        end
+
+        # Data suitable for a strategic-merge patch: only the
+        # keys/sub-trees that differ from the clean snapshot.
+        def patch_data
+          deep_diff(to_h, @clean)
+        end
+
+        def respond_to_missing?(name, include_private = false)
+          if name.end_with?("_changed?")
+            true
+          else
+            super
+          end
+        end
+
+        def method_missing(name, *args, &block)
+          if name.end_with?("_changed?")
+            attr = name.to_s.delete_suffix("_changed?").to_sym
+            old_val = @clean[attr]
+            new_val = to_h[attr]
+            old_val != new_val
+          else
+            super
+          end
+        end
+
+        private
+
+          def snapshot!
+            @clean = deep_dup(to_h)
+          end
+
+          def deep_diff(current, original)
+            Hash.new.tap do |result|
+              merged_keys = current.keys | original.keys
+            
+              merged_keys.each do |key|
+                cur_val  = current[key]
+                orig_val = original[key]
+            
+                if cur_val.is_a?(Hash) && orig_val.is_a?(Hash)
+                  nested = deep_diff(cur_val, orig_val)
+
+                  if nested.empty?
+                    next
+                  else
+                    result[key] = nested 
+                  end
+                elsif cur_val != orig_val
+                  result[key] = [orig_val, cur_val]
+                end
+              end
+            end
+          end
+
+          def diff_keys(current, original)
+            Set.new.tap do |keys|
+              merged_keys = (current.keys | original.keys)
+
+              merged_keys.each do |key|
+                if current[key] != original[key]
+                  keys << key 
+                end
+              end
+            end.to_a
+          end
+
+          def build_changes(current, original)
+            Hash.new.tap do |hash|
+              merged_keys = current.keys | original.keys
+
+              merged_keys.each do |key|
+                if current[key] == original[key]
+                  next
+                else
+                  hash[key] = [original[key], current[key]]
+                end
+              end
+            end
+          end
+
+          def deep_dup(obj)
+            case obj
+            when Hash  then obj.each_with_object({}) { |(k, v), h| h[k] = deep_dup(v) }
+            when Array then obj.map { |v| deep_dup(v) }
+            else obj
+            end
+          end
+      end
+    end
+  end
+end

data/lib/kube/cluster/resource/persistence.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+
+module Kube
+  module Cluster
+    class Resource < Kube::Schema::Resource
+      module Persistence
+        def apply
+          JSON.generate(deep_stringify_keys(to_h)).then do |json|
+            kubectl("apply", "-f", "-", stdin: json)
+            reload
+            true
+          end
+        end
+
+        def patch(type: "strategic")
+          if persisted?
+            diff = patch_data
+
+            if diff.empty?
+              false
+            else
+              json = JSON.generate(deep_stringify_keys(diff))
+              kubectl("patch", resource_type, name, *ns_flags, "--type", type, "-p", json)
+              reload
+              true
+            end
+          else
+            raise Kube::CommandError, "cannot patch a resource without a name"
+          end
+        end
+
+        def delete
+          if persisted?
+            kubectl("delete", resource_type, name, *ns_flags)
+            true
+          else
+            raise Kube::CommandError, "cannot delete a resource without a name"
+          end
+        end
+
+        def reload
+          if persisted?
+            tap do
+              kubectl("get", resource_type, name, *ns_flags, "-o", "json").then do |json|
+                JSON.parse(json).then do |hash|
+                  @data = BlackHoleStruct.new(hash)
+                  snapshot!
+                end
+              end
+            end
+          else
+            raise Kube::CommandError, "cannot reload a resource without a name"
+          end
+        end
+
+        private
+
+          def kubectl(*args)
+            @cluster.connection.ctl.run(args.join(" "))
+          end
+      end
+    end
+  end
+end

data/lib/kube/cluster/resource.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "resource/dirty_tracking"
+require_relative "resource/persistence"
+
+module Kube
+  module Cluster
+    class Resource < Kube::Schema::Resource
+      include DirtyTracking
+      include Persistence
+
+      attr_accessor :cluster
+
+      def initialize(hash = {}, &block)
+        @cluster = hash.delete(:cluster)
+        super
+        snapshot!
+      end
+    end
+  end
+end

data/lib/kube/cluster/version.rb

@@ -2,6 +2,6 @@
 
 module Kube
   module Cluster
-    VERSION = "0.2.0"
+    VERSION = "0.2.1"
   end
 end

data/lib/kube/cluster.rb

@@ -1,16 +1,22 @@
 # frozen_string_literal: true
 
+require "kube/schema"
+require_relative "../kube/errors"
 require_relative "cluster/version"
-require_relative "cluster/tree_node"
-require_relative "cluster/resource_selector"
-require_relative "cluster/query_builder"
-require_relative "cluster/command_node"
-require_relative "cluster/ctl"
+require_relative "cluster/connection"
+require_relative "cluster/instance"
+require_relative "cluster/resource"
+require_relative "cluster/manifest"
+require 'kube/ctl'
 
 module Kube
+  def self.cluster
+    Cluster
+  end
+
   module Cluster
-    def self.ctl
-      Ctl.new
+    def self.connect(kubeconfig:)
+      Instance.new(kubeconfig: kubeconfig)
     end
   end
 end

data/lib/kube/errors.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# This file defines cluster-specific errors in the Kube namespace.
+
+module Kube
+  # Base error class for the Kube namespace.
+  class Error < StandardError; end
+  # Raised when a kubectl command fails.
+  #
+  #   begin
+  #     resource.patch
+  #   rescue Kube::CommandError => e
+  #     e.subcommand  # => "patch"
+  #     e.stderr      # => "Error from server (NotFound): ..."
+  #     e.exit_code   # => 1
+  #     e.reason      # => "NotFound"  (parsed from stderr, or nil)
+  #   end
+  #
+  class CommandError < Error
+    attr_reader :subcommand, :stderr, :exit_code, :reason
+
+    def initialize(message = nil, subcommand: nil, stderr: nil, exit_code: nil, reason: nil)
+      @subcommand = subcommand
+      @stderr     = stderr
+      @exit_code  = exit_code
+      @reason     = reason || parse_reason(stderr)
+      super(message || build_message)
+    end
+
+    def self.from_kubectl(subcommand:, stderr:, exit_code:)
+      new(
+        subcommand: subcommand,
+        stderr: stderr,
+        exit_code: exit_code
+      )
+    end
+
+    private
+
+      def build_message
+        "kubectl #{@subcommand} failed (exit #{@exit_code}): #{@stderr}"
+      end
+
+      # Attempts to extract the reason from kubectl stderr.
+      # kubectl errors typically look like:
+      #   Error from server (NotFound): deployments.apps "foo" not found
+      #   Error from server (Forbidden): ...
+      #   error: the server doesn't have a resource type "foo"
+      def parse_reason(stderr)
+        return nil if stderr.nil? || stderr.empty?
+
+        if stderr =~ /\((\w+)\)/
+          $1
+        end
+      end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kube_cluster
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Nathan K
@@ -57,56 +57,102 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 1.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: kube_kit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: kube_kubectl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
 description: 'OOP abstraction that allows you to deploy and manage kubernetes resources
   using Ruby.
 
   '
 email:
 - nathankidd@hey.com
-executables:
-- kube_cluster
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - ".envrc"
+- ".github/workflows/release.yml"
+- ".github/workflows/tag-gem-version-bump.yml"
 - ".gitignore"
 - ".rubocop.yml"
 - Gemfile
 - Gemfile.lock
 - LICENSE
 - README.md
-- Rakefile
-- TREE_PLAN.md
 - bin/console
-- bin/generate-command-schema-v1
+- bin/dev
 - bin/increment-version
 - bin/release-gem
 - bin/setup
 - bin/tag-version
 - bin/test
-- data/kubectl-command-tree-v1-minimal.json
-- data/kubectl-command-tree-v1.json
-- examples/quick-repl/docker-compose.yml
-- exe/kube_cluster
+- docker-compose.yml
+- examples/01-basic-redis-pod/manifest.rb
+- examples/database/manifest.rb
+- examples/version2/demo.rb
+- examples/version2/helpers.rb
+- examples/version2/my_app.rb
+- examples/version2/postgresql.rb
+- examples/version2/ruby_on_rails.rb
+- examples/web-app/manifest.rb
 - flake.lock
 - flake.nix
 - kube_cluster.gemspec
+- lib/kube/cli/cluster.rb
 - lib/kube/cluster.rb
-- lib/kube/cluster/command_node.rb
-- lib/kube/cluster/ctl.rb
-- lib/kube/cluster/query_builder.rb
-- lib/kube/cluster/resource_selector.rb
-- lib/kube/cluster/tree_node.rb
+- lib/kube/cluster/connection.rb
+- lib/kube/cluster/instance.rb
+- lib/kube/cluster/manifest.rb
+- lib/kube/cluster/manifest/middleware.rb
+- lib/kube/cluster/manifest/middleware/annotations.rb
+- lib/kube/cluster/manifest/middleware/hpa_for_deployment.rb
+- lib/kube/cluster/manifest/middleware/ingress_for_service.rb
+- lib/kube/cluster/manifest/middleware/labels.rb
+- lib/kube/cluster/manifest/middleware/namespace.rb
+- lib/kube/cluster/manifest/middleware/pod_anti_affinity.rb
+- lib/kube/cluster/manifest/middleware/resource_preset.rb
+- lib/kube/cluster/manifest/middleware/security_context.rb
+- lib/kube/cluster/manifest/middleware/service_for_deployment.rb
+- lib/kube/cluster/manifest/stack.rb
+- lib/kube/cluster/resource.rb
+- lib/kube/cluster/resource/dirty_tracking.rb
+- lib/kube/cluster/resource/persistence.rb
 - lib/kube/cluster/version.rb
 - lib/kube/cluster/version.rb.erb
+- lib/kube/errors.rb
 homepage: https://github.com/general-intelligence-systems/kube_cluster
 licenses:
 - Apache-2.0

data/Rakefile

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require "rake/testtask"
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"]
-end
-
-task default: :test