kerbi 0.0.2 → 0.0.4

data/lib/mixins/cm_backend_testing.rb

@@ -20,11 +20,12 @@ module Kerbi
       end
 
       def read_write_ready?
-        namespace_exists? && resource_exists?
+        namespace_exists? && \
+        resource_exists? && \
+        data_readable?
       end
 
       def test_connection(options={})
-        res_name = Kerbi::State::Consts::RESOURCE_NAME
         exceptions = []
 
         schema = [
@@ -42,7 +43,11 @@ module Kerbi
           },
           {
             method: :load_resource,
-            message: "4. Resource #{namespace}/cm/#{res_name} exists"
+            message: "4. Resource #{namespace}/cm/#{cm_name} exists"
+          },
+          {
+            method: :entries,
+            message: "5. Data from resource is readable"
           }
         ]
 
@@ -57,9 +62,12 @@ module Kerbi
         end
 
         if exceptions.any? && options[:verbose]
+          #noinspection RubyResolve
           puts "\n---EXCEPTIONS---\n".colorize(:red).bold
           exceptions.each do |exc|
-            puts "[#{exc[:test]}] #{exc[:exception]}".to_s.colorize(:red).bold
+            base = "[#{exc[:test]}] #{exc[:exception]}"
+            #noinspection RubyResolve
+            puts base.to_s.colorize(:red).bold
             puts exc[:exception].backtrace
             puts "\n\n"
           end
@@ -67,6 +75,7 @@ module Kerbi
       end
 
       def test_list_namespaces
+        #noinspection RubyResolve
         client("v1").get_namespaces.any?
       end
 
@@ -74,6 +83,10 @@ module Kerbi
         client.get_namespace namespace
       end
 
+      def data_readable?
+        entries.is_a?(Array)
+      end
+
       #noinspection RubyResolve
       def puts_outcome(msg, result)
         outcome_str = result.present? ? "Success" : "Failure"
@@ -87,6 +100,7 @@ module Kerbi
           outcome_str = result.present? ? "Already existed" : "Created"
           color = result.present? ? :green : :blue
           outcome_str = outcome_str.colorize(color)
+          #noinspection RubyResolve
           puts "#{msg}: #{outcome_str}".bold
         end
       end

data/lib/state/base_backend.rb

@@ -2,6 +2,8 @@ module Kerbi
   module State
     class BaseBackend
 
+      attr_reader :is_working
+
       def initialize(options={})
       end
 
@@ -30,6 +32,34 @@ module Kerbi
         @_resource = nil
       end
 
+      def delete
+        delete_resource
+      end
+
+      def resource_signature
+        raise NotImplementedError
+      end
+
+      def prime
+        begin
+          resource
+          entries
+          @is_working = true
+        rescue
+          @is_working = false
+        end
+      end
+
+      # @return [TrueClass|FalseClass]
+      def working?
+        prime if @is_working.nil?
+        @is_working
+      end
+
+      def self.type_signature
+        raise NotImplementedError
+      end
+
       protected
 
       def resource
@@ -49,6 +79,10 @@ module Kerbi
         raise NotImplementedError
       end
 
+      def delete_resource
+        raise NotImplementedError
+      end
+
       private
 
       def utils

data/lib/state/config_map_backend.rb

@@ -9,13 +9,15 @@ module Kerbi
       include Kerbi::Mixins::CmBackendTesting
 
       attr_reader :auth_bundle
+      attr_reader :release_name
       attr_reader :namespace
 
       # @param [Hash] auth_bundle generated by Kerbi::Utils::K8sAuth
-      # @param [String] namespace Kubernetes namespace where configmap lives
-      def initialize(auth_bundle, namespace)
+      # @param [String] release_name Kubernetes namespace where configmap lives
+      def initialize(auth_bundle, release_name, namespace)
         @auth_bundle = auth_bundle.freeze
-        @namespace = namespace.freeze
+        @release_name = release_name.freeze
+        @namespace = (namespace || @release_name).freeze
       end
 
       ##
@@ -41,9 +43,16 @@ module Kerbi
       # of its contents. This method doesn't actually get used outside
       # of rspec, but it's super useful there so keeping for time being.
       # @param [Hash] resource_desc
-      def apply_resource(resource_desc)
-        #noinspection RubyResolve
-        client("v1").create_config_map(resource_desc)
+      def apply_resource(resource_desc, mode: 'create')
+        if mode == 'create'
+          #noinspection RubyResolve
+          client("v1").create_config_map(resource_desc)
+        elsif mode == 'update'
+          #noinspection RubyResolve
+          client("v1").update_config_map(resource_desc)
+        else
+          raise "What kind of sick mode is #{mode}?"
+        end
       end
 
       ##
@@ -52,21 +61,32 @@ module Kerbi
       # @param [Array<Kerbi::State::Entry>] entries
       # @return [Hash]
       def template_resource(entries)
-        values = { consts::ENTRIES_ATTR => entries.map(&:to_h) }
-        opts = { release_name: namespace }
-        Kerbi::State::ConfigMapMixer.new(values, **opts).run.first
+        values = {
+          consts::ENTRIES_ATTR => entries.map(&:to_h),
+          namespace: namespace,
+          cm_name: cm_name
+        }
+        Kerbi::State::ConfigMapMixer.new(values).run.first
       end
 
       ##
       # Creates the required namespace resource for this configmap
       # in the cluster.
       def create_namespace
-        opts = { release_name: namespace }
-        dict = Kerbi::State::NamespaceMixer.new({}, **opts).run.first
+        values = { namespace: namespace }
+        dict = Kerbi::State::NamespaceMixer.new(values).run.first
         #noinspection RubyResolve
         client("v1").create_namespace(dict)
       end
 
+      def resource_name
+        cm_name
+      end
+
+      def resource_signature
+        "configmaps/#{namespace}/#{resource_name}"
+      end
+
       protected
 
       ##
@@ -76,6 +96,13 @@ module Kerbi
         client("v1").get_config_map(cm_name, namespace).to_h
       end
 
+      ##
+      # Reads the configmap from Kubernetes, returns its dict representation.
+      def delete_resource
+        #noinspection RubyResolve
+        client("v1").delete_config_map(cm_name, namespace)
+      end
+
       ##
       # Templates the updated version of the configmap given the entries
       # in memory, and uses the new dict to overwrite the last configmap
@@ -91,7 +118,7 @@ module Kerbi
       # #resources, which is memoized, so may trigger a cluster read.
       # @return [Array<Hash>] entries
       def read_entries
-        str_entries = resource[:data][:entries]
+        str_entries = resource[:data][consts::ENTRIES_ATTR]
         JSON.parse(str_entries)
       end
 
@@ -100,6 +127,36 @@ module Kerbi
       # like appsV1 (defaults to "v1" if not passed).
       # @return [Kubeclient::Client]
       def client(api_name="v1")
+        self.class.make_client(auth_bundle, api_name)
+      end
+
+      def consts
+        Kerbi::State::Consts
+      end
+
+      def cm_name
+        self.class.mk_cm_name(release_name)
+      end
+
+      def self.releases(auth_bundle)
+        client = make_client(auth_bundle, "v1")
+        res_dicts = client.get_config_maps.map(&:to_h).select do |res_dict|
+          name = res_dict.dig(:metadata, :name)
+          name =~ Kerbi::State::Consts::CM_REGEX
+        end
+
+        res_dicts.map do |res_dict|
+          name, namespace = res_dict[:metadata].values_at(:name, :namespace)
+          release = name.match(Kerbi::State::Consts::CM_REGEX)[1]
+          self.new(auth_bundle, release, namespace)
+        end
+      end
+
+      def self.mk_cm_name(release_name)
+        "kerbi-#{release_name}-state-tracker"
+      end
+
+      def self.make_client(auth_bundle, api_name)
         Kubeclient::Client.new(
           auth_bundle[:endpoint],
           api_name,
@@ -107,13 +164,10 @@ module Kerbi
         )
       end
 
-      def consts
-        Kerbi::State::Consts
+      def self.type_signature
+        "ConfigMap"
       end
 
-      def cm_name
-        consts::RESOURCE_NAME
-      end
     end
   end
 end

data/lib/state/resources.yaml.erb

@@ -5,8 +5,8 @@
 apiVersion: v1
 kind: ConfigMap
 metadata:
-  name: <%= consts::RESOURCE_NAME %>
-  namespace: <%= release_name %>
+  name: <%= values[:cm_name] %>
+  namespace: <%= values[:namespace] %>
 data: <%= embed({consts::ENTRIES_ATTR => entries_json}) %>
 
 ---
@@ -14,4 +14,4 @@ data: <%= embed({consts::ENTRIES_ATTR => entries_json}) %>
 apiVersion: v1
 kind: Namespace
 metadata:
-  name: <%= release_name %>
+  name: <%= values[:namespace] %>

data/lib/utils/cli.rb

@@ -105,6 +105,38 @@ module Kerbi
         load(abs_path)
       end
 
+      ##
+      # Given the various Kubernetes authentication options and
+      # configs, generates a Hash with the necessary data/schema
+      # to pass onto the internal k8s authentication logic.
+      #
+      # This method only delegates. Actual work done is done here at:
+      # Kerbi::Utils::K8sAuth.
+      # @return [Hash] auth bundle for the k8s authentication logic.
+      # @param [Kerbi::RunOpts] run_opts
+      def self.make_k8s_auth_bundle(run_opts)
+        case run_opts.k8s_auth_type
+        when "kube-config"
+          Kerbi::Utils::K8sAuth.kube_config_bundle(
+            path: run_opts.kube_config_path,
+            name: run_opts.kube_context_name
+          )
+        when "basic"
+          Kerbi::Utils::K8sAuth.basic_auth_bundle(
+            username: run_opts.k8s_auth_username,
+            password: run_opts.k8s_auth_password
+          )
+        when "token"
+          Kerbi::Utils::K8sAuth.token_auth_bundle(
+            bearer_token: run_opts.k8s_auth_token,
+            )
+        when "in-cluster"
+          Kerbi::Utils::K8sAuth.in_cluster_auth_bundle
+        else
+          raise "Bad k8s connect type '#{run_opts.k8s_auth_type}'"
+        end
+      end
+
       LIST_TABLE_STYLE = {
         border_left: false,
         border_right: false,

data/spec/cli/config_handler_spec.rb

@@ -2,37 +2,37 @@ require_relative './../spec_helper'
 
 RSpec.describe "$ kerbi config [COMMAND]" do
 
-  before(:each) { Kerbi::ConfigFile.reset }
-
-  describe "$ kerbi config show" do
-    it "outputs the expected text" do
-      exp_cli_eq_file("config show", "config", "show-default", "yaml")
-    end
-  end
-
-  describe "$ kerbi config set [ATTR] [VALUE]" do
-    let(:cmd) { "config set namespace kerbi-spec" }
-    context "for a legal assignment" do
-      it "outputs the expected text and changes the value" do
-        exp_cli_eq_file(cmd, "config", "set", "txt")
-        new_value = Kerbi::ConfigFile.read["namespace"]
-        expect(new_value).to eq("kerbi-spec")
-      end
-    end
-    context "for an illegal assignment" do
-      let(:cmd){ "config set bad-key fail" }
-      it "outputs the expected error message" do
-        exp_cli_eq_file(cmd, "config", "bad-set", "txt")
-      end
-    end
-  end
-
-  describe "$ kerbi config get [ATTR]" do
-    let(:cmd) { "config get namespace" }
-    it "outputs the expected text and changes the value" do
-      cli("config set namespace kerbi-spec")
-      expect(cli(cmd).gsub(/\s+/, "")).to eq("kerbi-spec")
-    end
-  end
+  # before(:each) { Kerbi::ConfigFile.reset }
+  #
+  # describe "$ kerbi config show" do
+  #   it "outputs the expected text" do
+  #     exp_cli_eq_file("config show", "config", "show-default", "yaml")
+  #   end
+  # end
+  #
+  # describe "$ kerbi config set [ATTR] [VALUE]" do
+  #   let(:cmd) { "config set namespace kerbi-spec" }
+  #   context "for a legal assignment" do
+  #     it "outputs the expected text and changes the value" do
+  #       exp_cli_eq_file(cmd, "config", "set", "txt")
+  #       new_value = Kerbi::ConfigFile.read["namespace"]
+  #       expect(new_value).to eq("kerbi-spec")
+  #     end
+  #   end
+  #   context "for an illegal assignment" do
+  #     let(:cmd){ "config set bad-key fail" }
+  #     it "outputs the expected error message" do
+  #       exp_cli_eq_file(cmd, "config", "bad-set", "txt")
+  #     end
+  #   end
+  # end
+  #
+  # describe "$ kerbi config get [ATTR]" do
+  #   let(:cmd) { "config get namespace" }
+  #   it "outputs the expected text and changes the value" do
+  #     cli("config set namespace kerbi-spec")
+  #     expect(cli(cmd).gsub(/\s+/, "")).to eq("kerbi-spec")
+  #   end
+  # end
 
 end

data/spec/cli/release_handler_spec.rb

@@ -0,0 +1,127 @@
+require_relative './../spec_helper'
+
+RSpec.describe "$ kerbi release [COMMAND]" do
+
+  let(:namespace) { "kerbi-spec" }
+  let(:release_name) { "kerbi-spec" }
+  let(:cm_name) { Kerbi::State::ConfigMapBackend.mk_cm_name(release_name) }
+  let(:exps_dir) { "release" }
+
+  let(:set) do
+    new_state_set(
+      one: { values: {x: "x"}, created_at: Time.new(2000).to_s },
+      two: { message: "message", created_at: Time.new(2001).to_s },
+      "[cand]-three".to_sym => { created_at: Time.new(2002).to_s },
+      "[cand]-four".to_sym => { created_at: Time.new(2003).to_s }
+    )
+  end
+
+  before :each do
+    create_ns(release_name)
+    delete_cm(cm_name, namespace)
+    backend = make_backend(release_name, namespace)
+    configmap_dict = backend.template_resource(set.entries)
+    backend.apply_resource(configmap_dict)
+  end
+
+  describe "$ kerbi release init [RELEASE_NAME]" do
+    let(:cmd) { "release init #{release_name}" }
+    context "when resources already existed" do
+      it "echoes the correct text" do
+        exp_cli_eq_file(cmd, exps_dir, "init-already-existed")
+      end
+    end
+
+    context "when the resources did not exist" do
+      it "echoes the correct text" do
+        delete_ns(namespace)
+        exp_cli_eq_file(cmd, exps_dir, "init-both-created")
+      end
+    end
+  end
+
+  describe "$ kerbi release delete [RELEASE_NAME]" do
+    before :each do
+      backend = make_backend(release_name, namespace)
+      backend.provision_missing_resources
+    end
+
+    let(:cmd) { "release delete #{release_name} " \
+                "--namespace #{namespace} " \
+                "--confirm"
+    }
+
+    it "deletes the resource" do
+      backend = make_backend(release_name, namespace)
+      expect(backend.read_write_ready?).to eq(true)
+      backend = make_backend(release_name, namespace)
+      exp_cli_eq_file(cmd, exps_dir, "delete")
+      expect(backend.read_write_ready?).to eq(false)
+    end
+  end
+
+  describe "$ kerbi release status [RELEASE_NAME]" do
+    let(:cmd) { "release status #{release_name}" }
+    context "when resources are provisioned" do
+      context "when the data is readable" do
+        it "echoes the correct text" do
+          exp_cli_eq_file(cmd, exps_dir, "status-all-working")
+        end
+      end
+      context "when the data is not readable" do
+        it "echoes the correct text" do
+          backend = make_backend(release_name, namespace)
+          corrupt_cm(backend)
+          exp_cli_eq_file(cmd, exps_dir, "status-data-unreadable")
+        end
+      end
+    end
+
+    context "when connected but resources not provisioned" do
+      it "echoes the correct text" do
+        delete_ns(namespace)
+        exp_cli_eq_file(cmd, exps_dir, "status-not-provisioned")
+      end
+    end
+  end
+
+  describe "$ kerbi release list" do
+
+    before(:each) { delete_ns("kerbi-spec") }
+
+    def provision(release_name, namespace, entry_count)
+      backend = make_backend(release_name, namespace)
+      backend.provision_missing_resources(quiet: true)
+      expect(backend.read_write_ready?).to eq(true)
+
+      if entry_count >= 0
+        entries = []
+        entry_count.times do |i|
+          entries << new_state("#{i + 1}.0.0")
+        end
+        new_dict = backend.template_resource(entries)
+        backend.apply_resource(new_dict, mode: "update")
+      else
+        corrupt_cm(backend)
+      end
+    end
+
+    before :all do
+      delete_ns("tuna")
+      delete_ns("macron")
+
+      provision("tuna", "tuna", 2)
+      provision("dirt", "tuna", -1)
+      provision("tuna", "macron", 0)
+    end
+
+    after :all do
+      delete_ns("tuna")
+      delete_ns("macron")
+    end
+
+    it "works" do
+      exp_cli_eq_file("release list", exps_dir, "list")
+    end
+  end
+end

data/spec/cli/root_handler_spec.rb

@@ -3,7 +3,7 @@ require 'io/console'
 
 RSpec.describe "$ kerbi [COMMAND]" do
   let(:namespace) { "kerbi-spec" }
-  let(:cm_name) { Kerbi::State::Consts::RESOURCE_NAME }
+  let(:release_name) { "kerbi-spec" }
   let(:exps_dir) { "root" }
   let(:root_dir) { "#{__dir__}/../../examples/hello-kerbi" }
 
@@ -26,14 +26,13 @@ RSpec.describe "$ kerbi [COMMAND]" do
       end
     end
 
-    context "with with state" do
+    context "with state" do
 
-      let(:backend){ make_backend(namespace) }
+      let(:backend){ make_backend(release_name, namespace) }
 
       before :each do
-        kmd("create ns #{namespace}")
-        kmd("delete cm #{cm_name} -n #{namespace}")
-        backend = make_backend(namespace)
+        create_ns(namespace)
+        delete_cm(backend.resource_name, namespace)
         backend.provision_missing_resources(quiet: true)
       end
 
@@ -43,8 +42,10 @@ RSpec.describe "$ kerbi [COMMAND]" do
       end
 
       def template_write_cmd(pod_image)
-        base_cmd = "template foo --set pod.image=#{pod_image} --write-state foo"
-        hello_kerbi(base_cmd, namespace)
+        base_cmd = "template #{release_name} " \
+                    "--set pod.image=#{pod_image}" \
+                    " --write-state foo"
+        hello_kerbi(base_cmd)
       end
 
       context "with writing" do
@@ -81,15 +82,15 @@ RSpec.describe "$ kerbi [COMMAND]" do
 
         context "without inline overrides" do
           it "echos the expected text" do
-            cmd = hello_kerbi("template foo --read-state foo", namespace)
+            cmd = hello_kerbi("template #{release_name} --read-state foo")
             exp_cli_eq_file(cmd, "root", "template-read", "yaml")
           end
         end
 
         context "with inline overrides" do
           it "echos the expected text, preferring the inline over the state" do
-            base = "template foo --read-state foo --set pod.image=busybox"
-            cmd = hello_kerbi(base, namespace)
+            base = "template #{release_name} --read-state foo --set pod.image=busybox"
+            cmd = hello_kerbi(base)
             exp_cli_eq_file(cmd, "root", "template-read-inlines", "yaml")
           end
         end