kerbi 0.0.1 → 0.0.2

data/lib/state/config_map_backend.rb

@@ -0,0 +1,119 @@
+module Kerbi
+  module State
+
+    ##
+    # Treats a Kubernetes configmap in a namespace as a
+    # persistent store for state entries. Reads and writes
+    # to the configmap.
+    class ConfigMapBackend < Kerbi::State::BaseBackend
+      include Kerbi::Mixins::CmBackendTesting
+
+      attr_reader :auth_bundle
+      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)
+        @auth_bundle = auth_bundle.freeze
+        @namespace = namespace.freeze
+      end
+
+      ##
+      # Checks for the namespace and configmap, creating along
+      # the way if missing. Does not raise if already exists.
+      # @param [Hash] opts for things like verbose
+      def provision_missing_resources(**opts)
+        create_namespace unless (ns_existed = namespace_exists?)
+        echo_init("namespaces/#{namespace}", ns_existed, opts)
+
+        create_resource unless (cm_existed = resource_exists?)
+        echo_init("#{namespace}/configmaps/#{cm_name}", cm_existed, opts)
+      end
+
+      ##
+      # Creates the configmap with 0 entries.
+      def create_resource
+        apply_resource(template_resource([]))
+      end
+
+      ##
+      # Creates the configmap given an exact dict representation
+      # 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)
+      end
+
+      ##
+      # Outputs the dict representation of the configmap, templated
+      # with the given entries.
+      # @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
+      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
+        #noinspection RubyResolve
+        client("v1").create_namespace(dict)
+      end
+
+      protected
+
+      ##
+      # Reads the configmap from Kubernetes, returns its dict representation.
+      def load_resource
+        #noinspection RubyResolve
+        client("v1").get_config_map(cm_name, namespace).to_h
+      end
+
+      ##
+      # Templates the updated version of the configmap given the entries
+      # in memory, and uses the new dict to overwrite the last configmap
+      # in the cluster.
+      def update_resource
+        new_resource = template_resource(entries)
+        #noinspection RubyResolve
+        client("v1").update_config_map(new_resource)
+      end
+
+      ##
+      # Deserializes the list of entries in the configmap. Calls
+      # #resources, which is memoized, so may trigger a cluster read.
+      # @return [Array<Hash>] entries
+      def read_entries
+        str_entries = resource[:data][:entries]
+        JSON.parse(str_entries)
+      end
+
+      ## Creates an instance of Kubeclient::Client given
+      # the auth_bundle in the state, and a Kubernetes API name
+      # like appsV1 (defaults to "v1" if not passed).
+      # @return [Kubeclient::Client]
+      def client(api_name="v1")
+        Kubeclient::Client.new(
+          auth_bundle[:endpoint],
+          api_name,
+          **auth_bundle[:options]
+        )
+      end
+
+      def consts
+        Kerbi::State::Consts
+      end
+
+      def cm_name
+        consts::RESOURCE_NAME
+      end
+    end
+  end
+end

data/lib/state/entry.rb

@@ -0,0 +1,173 @@
+module Kerbi
+  module State
+
+    ##
+    # Represents a single Kerbi state entry.
+    class Entry
+
+      CANDIDATE_PREFIX = "[cand]-"
+
+      ATTRS = %i[tag message values default_values created_at]
+      SETTABLE_ATTRS = %i[message created_at]
+
+      attr_accessor :set
+
+      attr_accessor :tag
+      attr_accessor :message
+      attr_accessor :default_values
+      attr_accessor :values
+      attr_accessor :created_at
+
+      attr_reader :validation_errors
+
+      def initialize(set, dict)
+        @set = set
+        ATTRS.each do |attr|
+          instance_variable_set("@#{attr}", dict[attr].freeze)
+        end
+        @_was_validated = false
+        @validation_errors = []
+      end
+
+      ## A state entry is a 'candidate' if its tag has the
+      # candidate signature - that is it starts with [cand]-.
+      # @return [TrueClass, FalseClass]
+      def candidate?
+        tag.start_with?(CANDIDATE_PREFIX)
+      end
+
+      ##
+      # Convenience method that returns the negation of #candidate?
+      # @return [TrueClass, FalseClass]
+      def committed?
+        !candidate?
+      end
+
+      ##
+      # Ghetto attribute validation. Pushes a attr => msg hash to the
+      # @validation_errors for every problem found. Does not raise on
+      # problems.
+      # @return [NilClass]
+      def validate
+        @validation_errors.push(
+          attr: 'tag',
+          msg: "Cannot be empty",
+          value: tag
+        ) unless tag.present?
+
+        @_was_validated = true
+      end
+
+      def valid?
+        raise "valid? called before #validate" unless @_was_validated
+        validation_errors.empty?
+      end
+
+      ##
+      # Computes a delta between this state's values and its
+      # default values.
+      # @return [Hash]
+      def overrides_delta
+        if values.is_a?(Hash) & default_values.is_a?(Hash)
+          Kerbi::Utils::Misc.deep_hash_diff(default_values, values)
+        else
+          nil
+        end
+      end
+
+      ##
+      # Dynamically assign as a user.
+      # @param [String|Symbol] attr_name
+      # @param [Object] new_value
+      # @return [String] the old value, for convenience
+      def assign_attr(attr_name, new_value)
+        if SETTABLE_ATTRS.include?(attr_name.to_sym)
+          old_value = send(attr_name)
+          send("#{attr_name}=", new_value)
+          old_value
+        else
+          raise Kerbi::NoSuchStateAttrName
+        end
+      end
+
+      ##
+      # Replace current tag with a new one, where the new
+      # one can contain special interpolatable words like
+      # @candidate.
+      # @param [String] new_tag_expr
+      # @return [String] the old tag, for convenience
+      def retag(new_tag_expr)
+        old_tag = tag
+        self.tag = set.resolve_write_tag_expr(new_tag_expr)
+        old_tag
+      end
+
+      ##
+      # Removes the [cand]- part of the tag, making this
+      # entry lose its candidate status.
+      #
+      # Raises an exception if this entry was not a candidate.
+      # @return [String] the old tag, for convenience
+      def promote
+        raise Kerbi::StateNotPromotable unless candidate?
+        old_tag = tag
+        self.tag = tag[CANDIDATE_PREFIX.length..]
+        old_tag
+      end
+
+      ##
+      # Adds the [cand]- flag to this entry's tag, making this
+      # entry gain candidate status.
+      #
+      # Raises an exception if this entry was already a candidate.
+      # @return [String] the old tag, for convenience
+      def demote
+        raise Kerbi::StateNotDemotable unless committed?
+        old_tag = tag
+        self.tag = "#{CANDIDATE_PREFIX}#{tag}"
+        old_tag
+      end
+
+      ##
+      # Convenience method to get all overridden keys between
+      # the values and default_values dicts.
+      # @return [Array<String>]
+      def overridden_keys
+        (delta = overrides_delta) ? delta.keys.map(&:to_s) : []
+      end
+
+      def to_h
+        special_ser = {
+          values: values || {},
+          default_values: default_values || {},
+          created_at: created_at.to_s
+        }
+        Hash[ATTRS.map{|k|[k, send(k)]}].merge(special_ser)
+      end
+      alias_method :serialize, :to_h
+
+      def to_json
+        JSON.dump(serialize)
+      end
+
+      # @param [Hash] dict
+      # @return [Kerbi::State::Entry]
+      def self.from_dict(set, dict={})
+        dict.deep_symbolize_keys!
+        dict.slice!(*ATTRS)
+
+        self.new(
+          set,
+          **dict,
+          values: dict[:values] || {},
+          default_values: dict[:default_values] || {},
+          created_at: (Time.parse(dict[:created_at]) rescue nil)
+        )
+      end
+
+      def self.versioned?(expr)
+        Gem::Version.correct?(expr)
+      end
+    end
+  end
+end

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: <%= consts::RESOURCE_NAME %>
+  namespace: <%= release_name %>
+data: <%= embed({consts::ENTRIES_ATTR => entries_json}) %>
+
+---
+
+apiVersion: v1
+kind: Namespace
+metadata:
+  name: <%= release_name %>

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,31 @@ 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)
-        end
+      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
+
+      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