kerbi 0.0.1 → 0.0.5

data/lib/config/run_opts.rb

@@ -0,0 +1,162 @@
+module Kerbi
+
+  ##
+  # Convenience accessor struct for getting values from
+  # the CLI args.
+  #noinspection RubyTooManyMethodsInspection
+  class RunOpts
+
+    attr_reader :options
+    attr_accessor :release_name
+
+    # @param [Hash{Symbol, Object}] cli_opts CLI args as a hash via Thor
+    # @param [Hash{Symbol, Object}] defaults contextual defaults (per cmd)
+    # @return [Kerbi::RunOpts]
+    def initialize(cli_opts, defaults)
+      @options = defaults.deep_dup.
+        merge(Kerbi::ConfigFile.read.deep_dup).
+        merge(cli_opts.deep_dup).
+        freeze
+    end
+
+    # @return [String]
+    def output_format
+      value = options[consts::OUTPUT_FMT]
+      value || default
+    end
+
+    # @return [TrueClass, FalseClass]
+    def output_yaml?
+      self.output_format == 'yaml'
+    end
+
+    # @return [TrueClass, FalseClass]
+    def output_table?
+      self.output_format == 'table'
+    end
+
+    # @return [TrueClass, FalseClass]
+    def output_json?
+      self.output_format == 'json'
+    end
+
+    # @return [String]
+    def ruby_version
+      options[consts::RUBY_VER]
+    end
+
+    # @return [Array<String>]
+    def fname_exprs
+      options[consts::VALUE_FNAMES]
+    end
+
+    # @return [Array<String>]
+    def inline_val_exprs
+      options[consts::INLINE_ASSIGNMENT]
+    end
+
+    # @return [TrueClass, FalseClass]
+    def load_defaults?
+      options[consts::LOAD_DEFAULT_VALUES].present?
+    end
+
+    # @return [String]
+    def read_state_from
+      options[consts::READ_STATE].presence
+    end
+
+    # @return [String]
+    def write_state_to
+      options[consts::WRITE_STATE].presence
+    end
+
+    # @return [TrueClass, FalseClass]
+    def verbose?
+      options[consts::VERBOSE].present?
+    end
+
+    # @return [TrueClass, FalseClass]
+    def reads_state?
+      read_state_from.present?
+    end
+
+    # @return [TrueClass, FalseClass]
+    def reads_state_strictly?
+      options[consts::STRICT_READ_STATE]
+    end
+
+    # @return [TrueClass, FalseClass]
+    def writes_state?
+      write_state_to.present?
+    end
+
+    # @return [String]
+    def k8s_auth_type
+      options[consts::K8S_AUTH_TYPE]
+    end
+
+    # @return [String]
+    def kube_config_path
+      options[consts::KUBE_CONFIG_PATH]
+    end
+
+    # @return [String]
+    def kube_context_name
+      options[consts::KUBE_CONFIG_CONTEXT]
+    end
+
+    # @return [String]
+    def cluster_namespace
+      options[consts::NAMESPACE]
+    end
+
+    # @return [String]
+    def state_backend_type
+      value = options[consts::STATE_BACKEND_TYPE]
+      value.is_a?(String) ? value : ''
+    end
+
+    # @return [String]
+    def k8s_auth_username
+      options[consts::K8S_USERNAME]
+    end
+
+    # @return [String]
+    def k8s_auth_password
+      options[consts::K8S_PASSWORD]
+    end
+
+    # @return [String]
+    def k8s_auth_token
+      options[consts::K8S_TOKEN]
+    end
+
+    # @return [String]
+    def write_state_msg
+      options[consts::WRITE_STATE_MESSAGE]
+    end
+
+    # @return [String]
+    def project_root
+      options[consts::PROJECT_ROOT].presence
+    end
+
+    # @return [TrueClass, FalseClass]
+    def in_cluster?
+      options[consts::K8S_AUTH_TYPE] == 'in-cluster'
+    end
+
+    # @return [TrueClass, FalseClass]
+    def confirmed?
+      options[consts::PRE_CONFIRM].present?
+    end
+
+    private
+
+    # @return [Module<Kerbi::Consts::OptionKeys>]
+    def consts
+      Kerbi::Consts::OptionKeys
+    end
+
+  end
+end

data/lib/config/state_consts.rb

@@ -0,0 +1,11 @@
+module Kerbi
+  module State
+    module Consts
+      CREATOR_ATTR = :creator
+      CREATOR_VAL = "kerbi"
+      ENTRIES_ATTR = :entries
+      RESOURCE_NAME = "kerbi-db"
+      CM_REGEX = /kerbi-(.*)-db/
+    end
+  end
+end

data/lib/kerbi.rb

@@ -3,41 +3,66 @@
 #
 require 'erb'
 require "irb"
-require 'open3'
-require "http"
 require 'json'
 require 'yaml'
+require 'time'
 require "thor"
+require 'open3'
 require "base64"
 require 'optparse'
 require 'colorize'
+require 'kubeclient'
+require 'spicy-proton'
+require 'terminal-table'
 
-require 'active_support/concern'
 require 'active_support/inflector'
 require 'active_support/core_ext/object/deep_dup'
 require 'active_support/core_ext/hash/keys'
 require 'active_support/core_ext/hash/deep_merge'
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/string/indent.rb'
+require 'active_support/core_ext/string/filters'
+require 'active_support/callbacks'
 
 require_relative './utils/misc'
+require_relative './utils/k8s_auth'
+require_relative './state/entry'
+require_relative './cli/base_serializer'
 
 require_relative './config/cli_schema'
-require_relative './config/manager'
+require_relative './config/state_consts'
+require_relative './config/config_file'
 require_relative './config/globals'
-require_relative './config/cli_opts'
+require_relative './config/run_opts'
 
 require_relative './mixins/mixer'
+require_relative './mixins/cm_backend_testing'
+require_relative './utils/cli'
+require_relative './mixins/cli_state_helpers'
 
 require_relative './utils/mixing'
 require_relative './utils/helm'
-require_relative './utils/kubectl'
-require_relative './utils/cli'
+
 require_relative './utils/values'
 require_relative './main/code_gen'
 
-require_relative './cli/base'
+require_relative './main/mixer'
+
+require_relative './cli/entry_serializers'
+require_relative './cli/release_serializer'
+
+require_relative './mixins/entry_tag_logic'
+require_relative './state/entry_set'
+
+require_relative './state/base_backend'
+require_relative './state/mixers'
+require_relative './state/config_map_backend'
+
+require_relative './main/errors'
+require_relative './cli/base_handler'
+require_relative './cli/config_handler'
 require_relative './cli/values_handler'
 require_relative './cli/project_handler'
-require_relative './cli/root_handler'
-require_relative './main/mixer'
+require_relative './cli/state_handler'
+require_relative './cli/release_handler'
+require_relative './cli/root_handler'

data/lib/main/code_gen.rb

@@ -3,7 +3,7 @@ module Kerbi
     class ProjectGenerator
 
       ERB_EXT = ".erb"
-      BOILER_REL_PATH = "/../../boilerplate"
+      BOILER_REL_PATH = "/../code-gen/new-project"
 
       ##
       # Serves as both the new project's dir name and the mixer's _module name

data/lib/main/errors.rb

@@ -0,0 +1,115 @@
+module Kerbi
+  class Error < ::StandardError
+  end
+
+  class StateBackendNotReadyError < Error
+    MSG = "State-keeping backend not ready. Run 'kerbi state status' for more."
+
+    def initialize(msg = MSG)
+      super
+    end
+  end
+
+  class IllegalEntryTag < Error
+    def initialize(msg = "State entry tag cannot be 'latest'")
+      super
+    end
+  end
+
+  class IllegalConfigWrite < Error
+    LEGAL = Kerbi::Consts::OptionKeys::LEGAL_CONFIG_FILE_KEYS
+    def initialize(key)
+      super("Illegal config assignment. '#{key}' not in #{LEGAL}")
+    end
+  end
+
+  class BadEntryQueryForWrite < Error
+    MSG = "write-state needs an existing entry id/tag, 'candidate', or 'latest'"
+    def initialize(msg = MSG)
+      super
+    end
+  end
+
+  class IllegalWriteStateTagWordError < Error
+    MSG = "Tag names for writing cannot contain special words exclusive to tag "
+    def initialize(msg = MSG)
+      super
+    end
+  end
+
+  class StateNotFoundError < Error
+    def initialize(tag='')
+      super("State given by tag #{tag} not found")
+    end
+  end
+
+  class StateNotPromotable < Error
+    MSG = "Non-candidate states cannot be promoted"
+    def initialize(msg = MSG)
+      super
+    end
+  end
+
+  class StateNotDemotable < Error
+    MSG = "Candidate states cannot be demoted"
+    def initialize(msg = MSG)
+      super
+    end
+  end
+
+  class NoSuchStateAttrName < Error
+    MSG = "This attribute does not exist or is not writeable"
+    def initialize(msg = MSG)
+      super(MSG)
+    end
+  end
+
+  class ValuesFileNotFoundError < Error
+    def initialize(fname_expr: , root: )
+      msg = "Could not resolve values file '#{fname_expr}' in #{root}"
+      super(msg)
+    end
+  end
+
+  class KerbifileNotFoundError < Error
+    def initialize(root: )
+      msg = "Could not resolve kerbifile in #{root}"
+      super(msg)
+    end
+  end
+
+  class UnsupportedBackendError < Error
+    def initialize(name)
+      super("Unsupported state backend type")
+    end
+  end
+
+  class EntryValidationError < Error
+    MSG = "Cannot write state because of validation errors: "
+
+    # @param [Hash] errors
+    def initialize(errors)
+      message = self.class.build_message(errors)
+      super(message)
+    end
+
+    # @param [Hash] errors
+    def self.error_line(error)
+      "#{error[:attr]}['#{error[:value]}']: #{error[:msg]}".indent(1)
+    end
+
+    # @param [String] tag
+    # @param [Array<Hash>] errors
+    def self.entry_line(tag, error_dicts)
+      per_tag_parts = error_dicts.map{ |d| error_line(d) }
+      "Entry['#{tag}'] \n #{per_tag_parts.join("\n")}".indent(1)
+    end
+
+    # @param [Hash] errors
+    def self.build_message(errors)
+      parts = errors.map { |h| entry_line(h[0], h[1]) }
+      "#{MSG} \n#{parts.join("\n")}"
+    end
+  end
+
+end

data/lib/main/mixer.rb

@@ -12,6 +12,11 @@ module Kerbi
     # @return [String] symbol-keyed hash
     attr_reader :release_name
 
+    ##
+    # Namespace (defaults to release_name) from CLI options
+    # @return [String] symbol-keyed hash
+    attr_reader :namespace
+
     ##
     # Array of res-hashes being aggregated
     # @return [Array<Hash>] list of hashes
@@ -27,12 +32,13 @@ module Kerbi
     # @param [Hash] values the values tree that will be accessible to the subclass
     def initialize(values, opts={})
       @output = []
-      @release_name = opts[:release_name] || "default"
+      @release_name = opts[:release_name]
+      @namespace = opts[:namespace] || @release_name
       @patch_stack = []
       @values = self.class.compute_own_values_subtree(
         values,
         opts[:overwrite_values_root]
-      )
+      ).freeze
     end
 
     ##
@@ -45,7 +51,7 @@ module Kerbi
     def run
       begin
         self.mix
-      rescue Exception => e
+      rescue Error => e
         puts "Exception below caused by mixer #{self.class.name}"
         raise e
       end
@@ -202,15 +208,19 @@ module Kerbi
         subtree.freeze
       end
 
-      def resolve_file_name(fname)
+      ## Resolves a user-given short name for a file to interpolate,
+      # like 'pod', 'pod.yaml', into an absolute file path.
+      # @param [String] fname_expr e.g 'pod', 'pod.yaml'
+      # @return [?String]
+      def resolve_file_name(fname_expr)
         dir = self.pwd
         Kerbi::Utils::Misc.real_files_for(
-          fname,
-          "#{fname}.yaml",
-          "#{fname}.yaml.erb",
-          "#{dir}/#{fname}",
-          "#{dir}/#{fname}.yaml",
-          "#{dir}/#{fname}.yaml.erb"
+          fname_expr,
+          "#{fname_expr}.yaml",
+          "#{fname_expr}.yaml.erb",
+          "#{dir}/#{fname_expr}",
+          "#{dir}/#{fname_expr}.yaml",
+          "#{dir}/#{fname_expr}.yaml.erb"
         ).first
       end
 

data/lib/mixins/cli_state_helpers.rb

@@ -0,0 +1,108 @@
+module Kerbi
+  module Mixins
+    module CliStateHelpers
+
+      protected
+
+      ##
+      # Convenience method that returns the state backend's entry set.
+      # @return [Kerbi::State::EntrySet]
+      def entry_set
+        state_backend.entry_set
+      end
+
+      ##
+      # For commands that need a working state backend,
+      # ask the backend if it is operational, and raise otherwise.
+      def raise_unless_backend_ready
+        unless state_backend.read_write_ready?
+          raise Kerbi::StateBackendNotReadyError
+        end
+      end
+
+      ##
+      # Convenience method for invoking #find_entry_for_read
+      # on the state backend's entry-set.
+      # @return [Kerbi::State::Entry]
+      def find_readable_entry(tag_expr)
+        entry_set.find_entry_for_read(tag_expr)
+      end
+
+      ##
+      # Convenience method for updating a state entry's created_at
+      # and then persisting the new list of entries via the state backend.
+      # Also optionally pretty prints changes.
+      # @param [Kerbi::State::Entry] entry
+      def touch_and_save_entry(entry, changes={})
+        entry.created_at = Time.now
+        state_backend.save
+        if changes && (change = changes.first)
+          key, old_value = change
+          new_value = entry.send(key) rescue "ERR"
+          name = "state[#{entry.tag}].#{key}"
+          change_str = "from #{old_value} => #{new_value}"
+          echo "Updated #{name} #{change_str}".colorize(:green)
+        end
+      end
+
+      ##
+      # Given a tag by read-state [TAG], find the corresponding
+      # state entry and return its values dict.
+      #
+      # If the state entry is NOT found, an empty dict is returned,
+      # unless the strict-read option is also passed, in which
+      # case it raises a fatal exception.
+      # @return [Hash{Symbol->String}]
+      def read_state_values
+        if run_opts.reads_state?
+          expr = run_opts.read_state_from
+          begin
+            entry = entry_set.find_entry_for_read(expr)
+            entry.values.deep_dup.deep_symbolize_keys
+          rescue Kerbi::StateNotFoundError => e
+            raise e if run_opts.reads_state_strictly?
+            {}
+          end
+        else
+          {}
+        end
+      end
+
+      ##
+      # Given a tag by write-state [TAG], find or create a state entry
+      # and assign its values and default_values to the respective
+      # just values and default_values just compiled.
+      def persist_compiled_values
+        if run_opts.writes_state?
+          raise_unless_backend_ready
+          expr = run_opts.write_state_to
+          entry = entry_set.find_or_init_entry_for_write(expr)
+
+          entry.values = compile_values.deep_dup
+          entry.default_values = compile_default_values.deep_dup
+          entry.created_at = Time.now
+
+          state_backend.save
+        end
+      end
+
+      ##
+      # Given the state-backend parameter or config value,
+      # generate an instance of the corresponding backend
+      # class.
+      # @return [Kerbi::State::Backend]
+      def generate_state_backend(release_name: nil, namespace: nil)
+        if run_opts.state_backend_type.downcase.strip == 'configmap'
+          auth_bundle = Kerbi::Utils::Cli.make_k8s_auth_bundle(run_opts)
+          Kerbi::State::ConfigMapBackend.new(
+            auth_bundle,
+            release_name || run_opts.release_name,
+            namespace || run_opts.cluster_namespace
+          )
+        else
+          raise Kerbi::UnsupportedBackendError
+        end
+      end
+    end
+  end
+end

data/lib/mixins/cm_backend_testing.rb

@@ -0,0 +1,109 @@
+module Kerbi
+  module Mixins
+    module CmBackendTesting
+
+      # @return [TrueClass, FalseClass]
+      def namespace_exists?
+        begin
+          !!client("v1").get_namespace(namespace)
+        rescue Kubeclient::ResourceNotFoundError
+          false
+        end
+      end
+
+      def resource_exists?
+        begin
+          !!resource
+        rescue Kubeclient::ResourceNotFoundError
+          false
+        end
+      end
+
+      def read_write_ready?
+        namespace_exists? && \
+        resource_exists? && \
+        data_readable?
+      end
+
+      def test_connection(options={})
+        exceptions = []
+
+        schema = [
+          {
+            method: :client,
+            message: "1. Create Kubernetes client"
+          },
+          {
+            method: :test_list_namespaces,
+            message: "2. List cluster namespaces"
+          },
+          {
+            method: :test_target_ns_exists,
+            message: "3. Target namespace #{namespace} exists"
+          },
+          {
+            method: :load_resource,
+            message: "4. Resource #{namespace}/cm/#{cm_name} exists"
+          },
+          {
+            method: :entries,
+            message: "5. Data from resource is readable"
+          }
+        ]
+
+        schema.each do |spec|
+          begin
+            self.send(spec[:method])
+            puts_outcome(spec[:message], true)
+          rescue StandardError => e
+            puts_outcome(spec[:message], false)
+            exceptions << { exception: e, test: spec[:message] }
+          end
+        end
+
+        if exceptions.any? && options[:verbose]
+          #noinspection RubyResolve
+          puts "\n---EXCEPTIONS---\n".colorize(:red).bold
+          exceptions.each do |exc|
+            base = "[#{exc[:test]}] #{exc[:exception]}"
+            #noinspection RubyResolve
+            puts base.to_s.colorize(:red).bold
+            puts exc[:exception].backtrace
+            puts "\n\n"
+          end
+        end
+      end
+
+      def test_list_namespaces
+        #noinspection RubyResolve
+        client("v1").get_namespaces.any?
+      end
+
+      def test_target_ns_exists
+        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"
+        color = result.present? ? :green : :red
+        outcome_str = outcome_str.colorize(color)
+        puts "#{msg}: #{outcome_str}".bold
+      end
+
+      def echo_init(msg, result, options={})
+        unless options[:quiet].present?
+          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
+    end
+  end
+end