kerbi 0.0.1 → 0.0.5

data/lib/state/entry_set.rb

@@ -0,0 +1,137 @@
+module Kerbi
+  module State
+
+    ##
+    # Baby version of ActiveRecord::Relation. Holds an array of
+    # entries (i.e Kerbi::State::Entry) and exposes useful group-level
+    # operations, like sorting, find maximums, etc...
+    class EntrySet
+
+      include Kerbi::Mixins::EntryTagLogic
+
+      attr_reader :entries
+
+      # @param [Array<Hash>] dicts
+      def initialize(dicts)
+        @entries = dicts.map { |h| Entry.from_dict(self, h) }
+        sort_by_created_at
+      end
+
+      def validate!
+        entries.each(&:validate)
+        if (bad_entries = entries.reject(&:valid?)).any?
+          errors = Hash[bad_entries.map do |entry|
+            [entry.tag, entry.validation_errors.deep_dup]
+          end]
+          raise Kerbi::EntryValidationError.new(errors)
+        end
+      end
+
+      ##
+      # Filters entries by candidate status, returning only the
+      # ones that are NOT candidates.
+      # @return [Array<Kerbi::State::Entry>]
+      def committed
+        entries.select(&:committed?)
+      end
+
+      ##
+      # Filters entries by candidate status, returning only the
+      # ones that ARE candidates.
+      # @return [Array<Kerbi::State::Entry>]
+      def candidates
+        entries.reject(&:committed?)
+      end
+
+      ##
+      # Finds the most recently created/updated entry in the list
+      # that is not a candidate.
+      # @return [?Kerbi::State::Entry]
+      def latest
+        committed.first
+      end
+
+      ##
+      # Finds the least recently created/updated entry in the list
+      # that is not a candidate.
+      # @return [?Kerbi::State::Entry]
+      def oldest
+        committed.last
+      end
+
+      ##
+      # Finds the most recently created/updated entry in the list
+      # that is a candidate.
+      # @return [?Kerbi::State::Entry]
+      def latest_candidate
+        candidates.first
+      end
+
+      ##
+      # Given a target entry tag expression, searches underlying array
+      # for the corresponding entry.
+      #
+      # Assumes the tag expression contains special interpolatable words,
+      # and thus resolves the tag expression into a literal tag first.
+      #
+      # Invokes tag resolution logic specific to reading entries, which
+      # is different than for writing entries (see #resolve_read_tag_expr).
+      # @param [String] tag_expr
+      # @return [Kerbi::State::Entry]
+      def find_entry_for_read(tag_expr)
+        resolved_tag = resolve_read_tag_expr(tag_expr)
+        entry = find_by_literal_tag(resolved_tag)
+        raise Kerbi::StateNotFoundError.new(tag_expr) unless entry
+        entry
+      end
+
+      ##
+      # Given a target entry tag expression, searches underlying array
+      # for the corresponding entry.
+      #
+      # Assumes the tag expression contains special interpolatable words,
+      # and thus resolves the tag expression into a literal tag first.
+      #
+      # Invokes tag resolution logic specific to writing entries, which
+      # is different than for reading entries (see #resolve_write_tag_expr).
+      #
+      # If an entry is not found, initializes a new empty entry with the
+      # given resolved tag, and adds it to the set's underlying array.
+      # @param [String] tag_expr
+      # @return [?Kerbi::State::Entry]
+      def find_or_init_entry_for_write(tag_expr)
+        resolved_tag = resolve_write_tag_expr(tag_expr)
+        if(existing_entry = find_by_literal_tag(resolved_tag))
+          existing_entry
+        else
+          entry = Kerbi::State::Entry.new(self, tag: resolved_tag)
+          entries.unshift(entry)
+          entry
+        end
+      end
+
+      ##
+      # Performs simple linear search for an entry whose tags matches
+      # exactly tag_expr.
+      # @param [String] tag_expr
+      # @return [?Kerbi::State::Entry]
+      def find_by_literal_tag(tag_expr)
+        return nil unless tag_expr.present?
+        entries.find { |e| e.tag == tag_expr }
+      end
+      alias_method :get, :find_by_literal_tag
+
+
+      def prune_candidates
+        entries.select!(&:committed?)
+      end
+
+      def sort_by_created_at
+        entries.sort! do |a, b|
+          both_defined = a.created_at && b.created_at
+          both_defined ? b.created_at <=> a.created_at : 0
+        end
+      end
+    end
+  end
+end

data/lib/state/metadata.yaml.erb

@@ -0,0 +1,11 @@
+<% consts = Kerbi::State::Consts %>
+
+metadata:
+  labels: <%= embed({
+    consts::CREATOR_ATTR => consts::CREATOR_VAL
+  }) %>
+
+  annotations: <%= embed({
+    consts::CREATOR_ATTR => consts::CREATOR_VAL,
+    description: "used by kerbi to keep records of previously applied values"
+  }) %>

data/lib/state/mixers.rb

@@ -0,0 +1,23 @@
+module Kerbi
+  module State
+    class ConfigMapMixer < Kerbi::Mixer
+      locate_self __dir__
+
+      def mix
+        patched_with file("metadata") do
+          push file("resources", only: [{kind: "ConfigMap"}])
+        end
+      end
+    end
+
+    class NamespaceMixer < Kerbi::Mixer
+      locate_self __dir__
+
+      def mix
+        patched_with file("metadata") do
+          push file("resources", only: [{kind: "Namespace"}])
+        end
+      end
+    end
+  end
+end

data/lib/state/resources.yaml.erb

@@ -0,0 +1,17 @@
+<% consts = Kerbi::State::Consts %>
+
+<% entries_json = JSON.dump(values[consts::ENTRIES_ATTR]) %>
+
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: <%= values[:cm_name] %>
+  namespace: <%= values[:namespace] %>
+data: <%= embed({consts::ENTRIES_ATTR => entries_json}) %>
+
+---
+
+apiVersion: v1
+kind: Namespace
+metadata:
+  name: <%= values[:namespace] %>

data/lib/utils/cli.rb

@@ -1,7 +1,6 @@
 module Kerbi
   module Utils
     module Cli
-
       ##
       # Convenience method for running and compiling the output
       # of several mixers. Returns all result dicts in a flat array
@@ -17,10 +16,24 @@ module Kerbi
         end
       end
 
+      def self.coerce_hash_or_array(actual, **options)
+        if (type = options[:coerce_type]).present?
+          if type == 'Array'
+            actual.is_a?(Array) ? actual : [actual]
+          elsif type == 'Hash'
+            actual.is_a?(Array) ? actual[0].to_h : actual.to_h
+          else
+            raise "Unrecognized type coercion #{type}"
+          end
+        else
+          actual
+        end
+      end
+
       ##
       # Turns list of key-symbol dicts into their
       # pretty YAML representation.
-      # @param [Array<Hash>] dicts dicts to YAMLify
+      # @param [Array<Hash>|Hash] dicts dicts to YAMLify
       # @return [String] pretty YAML representation of input
       def self.dicts_to_yaml(dicts)
         if dicts.is_a?(Array)
@@ -29,15 +42,52 @@ module Kerbi
             raw.gsub("---\n", i.zero? ? '' : "---\n\n")
           end.join("\n")
         else
+          return "{}" if dicts.empty?
           as_yaml = YAML.dump(dicts.deep_stringify_keys)
           as_yaml.gsub("---\n", "")
         end
       end
 
+      # @param [Array<Object>] entries
+      def self.list_to_table(entries, serializer_cls)
+        if entries.is_a?(Array)
+          table = Terminal::Table.new(
+            headings: serializer_cls.header_titles,
+            rows: entries.map(&:values)
+          )
+          table.style = LIST_TABLE_STYLE
+          table.to_s
+        else
+          table = Terminal::Table.new do |t|
+            #noinspection RubyResolve
+            entries.each do |key, value|
+              new_key = key.upcase.to_s.bold
+              new_value = fmt_table_value(value)
+              t.add_row [new_key, new_value]
+            end
+            t.style = DESCRIBE_TABLE_STYLE
+
+          end
+          table.to_s
+        end
+      end
+
+      def self.fmt_table_value(value)
+        if value.is_a?(Hash)
+          flattened = Kerbi::Utils::Misc.flatten_hash(value)
+          stringified = flattened.deep_stringify_keys
+          dicts_to_yaml(stringified)
+        elsif value.is_a?(Array)
+          value.join(",")
+        else
+          value.to_s
+        end
+      end
+
       ##
       # Turns list of key-symbol dicts into their
       # pretty JSON representation.
-      # @param [Array<Hash>] dicts dicts to YAMLify
+      # @param [Array<Hash>|Hash] dicts dicts to YAMLify
       # @return [String] pretty JSON representation of input
       def self.dicts_to_json(dicts)
         JSON.pretty_generate(dicts)
@@ -46,14 +96,63 @@ module Kerbi
       ##
       # Searches the expected paths for the kerbifile and ruby-loads it.
       # @param [String] root directory to search
-      def self.load_kerbifile(fname_expr)
-        fname_expr ||= Dir.pwd
-        abs_path = "#{fname_expr}/kerbifile.rb"
-        if File.exists?(abs_path)
-          #noinspection RubyResolve
-          load(abs_path)
+      def self.load_kerbifile(root_dir)
+        root_dir ||= Dir.pwd
+        abs_path = "#{root_dir}/kerbifile.rb"
+        exists = File.exists?(abs_path)
+        raise Kerbi::KerbifileNotFoundError.new(root: root_dir) unless exists
+        #noinspection RubyResolve
+        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,
+        border_top: false,
+        border_x: "",
+        border_y: "",
+        border_i: ""
+      }.freeze
+
+      DESCRIBE_TABLE_STYLE = {
+        all_separators: true,
+        border_x: "-",
+        border_y: "",
+        border_i: ""
+      }.freeze
+
     end
   end
 end

data/lib/utils/helm.rb

@@ -2,15 +2,14 @@ module Kerbi
   module Utils
     module Helm
 
-      def self.config
-        Kerbi::Config::Manager
-      end
-
+      HELM_EXEC = "helm"
+      TMP_VALUES_PATH = "/tmp/kerbi-helm-tmp.yaml"
+      
       ##
       # Tests whether Kerbi can invoke Helm commands
       # @return [Boolean] true if helm commands succeed locally
       def self.can_exec?
-        !!system(config.helm_exec, out: File::NULL, err: File::NULL)
+        !!system(HELM_EXEC, out: File::NULL, err: File::NULL)
       end
 
       ##
@@ -18,18 +17,17 @@ module Kerbi
       # @param [Hash] values a hash of values
       # @return [String] the path of the file
       def self.make_tmp_values_file(values)
-        File.open(config.tmp_helm_values_path, 'w') do |f|
-          f.write(YAML.dump((values || {}).deep_stringify_keys))
-        end
-        config.tmp_helm_values_path
+        content = YAML.dump((values || {}).deep_stringify_keys)
+        File.write(TMP_VALUES_PATH, content)
+        TMP_VALUES_PATH
       end
 
       ##
       # Deletes the temp file
       # @return [void]
       def self.del_tmp_values_file
-        if File.exists?(config.tmp_helm_values_path)
-          File.delete(config.tmp_helm_values_path)
+        if File.exists?(TMP_VALUES_PATH)
+          File.delete(TMP_VALUES_PATH)
         end
       end
 
@@ -53,7 +51,7 @@ module Kerbi
         raise "Helm executable not working" unless can_exec?
         tmp_file = make_tmp_values_file(opts[:values])
         inline_flags = encode_inline_assigns(opts[:inline_assigns])
-        command = "#{config.helm_exec} template #{release} #{project}"
+        command = "#{HELM_EXEC} template #{release} #{project}"
         command += " -f #{tmp_file} #{inline_flags} #{opts[:cli_args]}"
         output = `#{command}`
         del_tmp_values_file

data/lib/utils/k8s_auth.rb

@@ -0,0 +1,87 @@
+module Kerbi
+  module Utils
+
+    ##
+    # ALl *_bundle methods return a custom-schema hash
+    # that is to be used to create a Kubeclient::Client instance.
+    # See its constructor docs to understand.
+    # Underlying lib credit: https://github.com/ManageIQ/kubeclient
+    module K8sAuth
+
+      ##
+      # Auth using config/credentials from a local kube context
+      # entry.
+      # See https://github.com/ManageIQ/kubeclient#kubeclientconfig
+      def self.kube_config_bundle(path: nil, name: nil)
+        path = path || default_kube_config_path
+        config = Kubeclient::Config.read(path)
+        context = config.context(name)
+
+        {
+          endpoint: context.api_endpoint,
+          options: {
+            ssl_options: context.ssl_options,
+            auth_options: context.auth_options
+          }
+        }
+      end
+
+      ##
+      # Basic username password auth.
+      # See https://github.com/ManageIQ/kubeclient#authentication
+      def self.basic_auth_bundle(username:, password:)
+        {
+          endpoint: "https://localhost:8443/api",
+          options: {
+            auth_options: {
+              username: username,
+              password: password
+            }
+          }
+        }
+      end
+
+      ##
+      # Auth using explicit bearer token for each request.
+      # See https://github.com/ManageIQ/kubeclient#authentication
+      def self.token_auth_bundle(bearer_token:)
+        {
+          endpoint: "https://localhost:8443/api",
+          options: {
+            auth_options: {
+              bearer_token: bearer_token
+            }
+          }
+        }
+      end
+
+      ##
+      # Auth if kerbi is inside a Kubernetes cluster. Uses default
+      # credentials in pod's filesystem. Likely requires extra
+      # RBAC resources for that service account to exist, e.g
+      # a few Roles/ClusterRoles and RoleBinding/ClusterRoleBindings
+      # in order for CRUD methods to actually work.
+      # See https://github.com/ManageIQ/kubeclient#middleware
+      def self.in_cluster_auth_bundle
+        token_path = '/var/run/secrets/kubernetes.io/serviceaccount/token'
+        ca_crt_path = "/var/run/secrets/kubernetes.io/serviceaccount/ca.crt"
+        auth_options = { bearer_token_file: token_path }
+
+        ssl_options = {}
+        ssl_options[:ca_file] = ca_crt_path if File.exist?(ca_crt_path)
+
+        {
+          endpoint: "https://kubernetes.default.svc",
+          options: {
+            auth_options: auth_options,
+            ssl_options: ssl_options
+          }
+        }
+      end
+
+      def self.default_kube_config_path
+        ENV['KUBECONFIG'] || "#{Dir.home}/.kube/config"
+      end
+    end
+  end
+end

data/lib/utils/misc.rb

@@ -16,7 +16,7 @@ module Kerbi
       # @return [Array] subset of candidate filenames that are real filenames
       def self.real_files_for(*candidates)
         candidates.select do |fname|
-          File.exists?(fname)
+          File.exists?(fname) && !Dir.exists?(fname)
         end
       end
 
@@ -36,6 +36,41 @@ module Kerbi
           end
         end
       end
+
+      ##
+      # Credit: https://gist.github.com/henrik/146844
+      # @param [Hash] hash_a
+      # @param [Hash] hash_b
+      def self.deep_hash_diff(hash_a, hash_b)
+        (hash_a.keys | hash_b.keys).inject({}) do |diff, k|
+          if hash_a[k] != hash_b[k]
+            if hash_a[k].is_a?(Hash) && hash_b[k].is_a?(Hash)
+              diff[k] = deep_hash_diff(hash_a[k], hash_b[k])
+            else
+              diff[k] = [hash_a[k], hash_b[k]]
+            end
+          end
+          diff
+        end
+      end
+
+      ##
+      # Credit: https://stackoverflow.com/a/195894/11913562
+      # @param [Time] other
+      # @return [String]
+      def self.pretty_time_elapsed(other)
+        a = (Time.now - other).to_i
+        case a
+        when 0 then 'just now'
+        when 1 then 'a second ago'
+        when 2..59 then a.to_s+' seconds ago'
+        when 60..119 then 'a minute ago' #120 = 2 minutes
+        when 120..3540 then (a/60).to_i.to_s+' minutes ago'
+        when 3541..7100 then 'an hour ago' # 3600 = 1 hour
+        when 7101..82800 then ((a+99)/3600).to_i.to_s+' hours ago'
+        else other.to_s
+        end
+      end
     end
   end
 end

data/lib/utils/mixing.rb

@@ -24,7 +24,7 @@ module Kerbi
         contents = File.read(fname)
         begin
           self.yaml_str_to_dicts(contents, **opts)
-        rescue Exception => e
+        rescue Error => e
           STDERR.puts "Exception below from file #{fname}"
           raise e
         end

data/lib/utils/values.rb

@@ -4,8 +4,6 @@ module Kerbi
     # Utilities module for all value loading functionality.
     module Values
 
-      DEFAULT_VALUE_PATH = "values"
-
       def self.from_files(fname_exprs, **opts)
         final_paths = resolve_fname_exprs(fname_exprs, **opts)
         load_yaml_files(final_paths)
@@ -21,16 +19,24 @@ module Kerbi
       # @param [Hash] opts downstream options for file-loading methods
       # @return [Array<String>] list of unique absolute filenames
       def self.resolve_fname_exprs(fname_exprs, **opts)
-        final_exprs = [self::DEFAULT_VALUE_PATH, *fname_exprs].uniq
+        final_exprs = fname_exprs.uniq
         final_exprs.map do |fname_expr|
-          path = resolve_fname_expr(fname_expr, **opts)
-          if fname_expr != 'values' && !path
-            raise "Could not resolve file '#{fname_expr}'"
-          end
+          candidate_paths = values_paths(fname_expr, **opts)
+          path = Kerbi::Utils::Misc.real_files_for(*candidate_paths)[0]
+          raise_if_file_not_found(fname_expr, path, **opts)
           path.presence
         end.compact.uniq
       end
 
+      def self.raise_if_file_not_found(fname_expr, path, **opts)
+        if fname_expr != 'values' && !path
+          raise Kerbi::ValuesFileNotFoundError.new(
+            fname_expr: fname_expr,
+            root: opts[:root]
+          )
+        end
+      end
+
       ##
       # Loads the dicts from files pointed to by final_file_paths into
       # memory, and returns the deep-merged hash in the order of the files.
@@ -54,21 +60,6 @@ module Kerbi
         end
       end
 
-      ##
-      # Turns a user supplied values filename into a final, usable
-      # absolute filesystem path. This method calls the values_paths method,
-      # which assumes a kerbi directory structure.
-      # @param [String] expr
-      # @param [Hash] opts
-      # @return [?String] the absolute filename or nil if it does not exist
-      def self.resolve_fname_expr(expr, **opts)
-        candidate_paths = self.values_paths(expr, **opts)
-        candidate_paths.find do |candidate_path|
-          File.exists?(candidate_path) && \
-          !File.directory?(candidate_path)
-        end
-      end
-
       ##
       # Parses a single cli-level key-value assignment with the form
       # foo.bar=baz. Raises an exception if the expression is malformed.

data/spec/cli/config_handler_spec.rb

@@ -0,0 +1,38 @@
+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
+
+end