kerbi 0.0.1 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 844a7ee42c68f643fd43d0a365d497061cf79b9d6176612d9af17789676a32c9
-  data.tar.gz: 0fa583609a29a99ab0019c46ab1a11f99f240477fce2ca5a8ce3c7017e1a3aa4
+  metadata.gz: 12c9672d03ca241ca969d74f1ef3297c4571976c9f8c2b16d688d9552b472a2e
+  data.tar.gz: 12bdb95a12e5e8a82fec049cfca51deab3d5ddcf922fe880067a86a5bad20f1b
 SHA512:
-  metadata.gz: 9a9d89cbdb45952d3baec555ef373c16b8ca4f59fb3bd88d31335f0eb40ca5537995085c6973c58f08481782202c4371af0db57ae022f75470e547d872833005
-  data.tar.gz: 42b22d628d97405b95c96b51fd7dee0c5b013682f7e482b5792ded5570d09cc97e0bd76d7cf08c922b87cc985d508a5e7af33df64341b9822c49b53f197d54a9
+  metadata.gz: 01d63e202d6c736d15fe3520f50d92f8661790b5718bb690fc6badc7351ea156db4abc55491f2c63293432048e601b3d4e55c689ec8c2fc7a5d5b24f8e936528
+  data.tar.gz: 18ab1a1acae9e29d909e35fef91cb71143d1ba2db38f0db63596944e13dfd1bc3caa8cc868edef1e5da6bdafd34a6092bc03ef976f7fa51324bd120ba5317794

data/lib/cli/base_handler.rb

@@ -0,0 +1,194 @@
+module Kerbi
+  module Cli
+
+    ##
+    # Superclass for all Thor CLI handlers.
+    class BaseHandler < Thor
+      include Kerbi::Mixins::CliStateHelpers
+
+      protected
+
+      ##
+      # Convenience method for instantiating (and memoizating) a state
+      # management backend.
+      def state_backend(**opts)
+        @_state_backend ||= generate_state_backend(**opts)
+      end
+
+      def mem_release_name(release_name)
+        self.run_opts.release_name = release_name
+      end
+
+      ##
+      # Looks at the CLI options to determine which
+      # data serializer should be used.
+      # @param [Hash] options
+      # @return [Class<Kerbi::Cli::BaseSerializer>|null]
+      def resolve_serializer(options={})
+        if run_opts.output_json?
+          winner = options[:json_serializer]
+        elsif run_opts.output_yaml?
+          winner = options[:yaml_serializer]
+        elsif run_opts.output_table?
+          winner = options[:table_serializer]
+        else
+          raise "Unknown output format '#{run_opts.output_format}'"
+        end
+        winner || options[:serializer]
+      end
+
+      ##
+      # Pretty prints data to STDOUT selecting the right
+      # serializer, and coercing data if requested by the
+      # caller.
+      # @param [Hash|Array<Object>] dicts
+      def echo_data(items, **opts)
+        utils = Kerbi::Utils::Cli
+        serializer = resolve_serializer(opts)
+        items = utils.coerce_hash_or_array(items, opts)
+        if serializer
+          if items.is_a?(Array)
+            items = items.map{ |e| serializer.new(e).serialize }
+          else
+            items = serializer.new(items).serialize
+          end
+        end
+
+        if run_opts.output_yaml?
+          printable_str = utils.dicts_to_yaml(items)
+        elsif run_opts.output_json?
+          printable_str = utils.dicts_to_json(items)
+        elsif run_opts.output_table?
+          printable_str = utils.list_to_table(items, serializer)
+        else
+          raise "Unknown output format '#{run_opts.output_format}'"
+        end
+
+        echo(printable_str)
+      end
+
+      def echo(printable_str)
+        $stdout.puts printable_str
+      end
+
+      ##
+      # Returns single merged dict containing all values given or
+      # pointed to by the CLI args, plus the default values.yaml file.
+      # This includes values from files, inline expressions, and the
+      # state ConfigMap.
+      # @return [Hash] symbol-keyed dict of all loaded values
+      def compile_values
+        @_compiled_values ||=
+          begin
+            utils = Kerbi::Utils::Values
+
+            fname_exprs = run_opts.fname_exprs
+            fname_exprs = ["values", *fname_exprs] if run_opts.load_defaults?
+
+            file_values = utils.from_files(
+              fname_exprs,
+              root: run_opts.project_root
+            )
+
+            inline_values = utils.from_inlines(run_opts.inline_val_exprs)
+            state_values = read_state_values
+
+            file_values.
+              deep_merge(state_values).
+              deep_merge(inline_values)
+          end
+      end
+
+      ##
+      # Compiles the values from only the default values file,
+      # e.g values.yaml, or values/values.yaml.
+      # @return [Hash]
+      def compile_default_values
+        utils = Kerbi::Utils::Values
+        if run_opts.load_defaults?
+          utils.from_files(['values'], root: run_opts.project_root)
+        else
+          {}
+        end
+      end
+
+      ##
+      # Called by command-methods that need to start with a set
+      # of default options that is not the normal default,
+      # i.e that is not Kerbi::Consts::OptionDefaults::BASE.
+      # @param [Hash] defaults alternative defaults
+      def prep_opts(defaults)
+        @_options_obj = Kerbi::RunOpts.new(options, defaults)
+      end
+
+      ##
+      # Returns a re-usable instance of the CLI-args
+      # wrapper Kerbi::RunOpts
+      # @return [Kerbi::RunOpts] re-usable instance
+      def run_opts
+        @_options_obj ||= Kerbi::RunOpts.new(
+          options,
+          Kerbi::Consts::OptionDefaults::BASE
+        )
+      end
+
+      ##
+      # Convenience class method for declaring a Thor subcommand
+      # metadata bundle, in accordance with the schema in
+      # Kerbi::Consts::OptionSchemas.
+      # @param [Hash] _schema a dict from Kerbi::Consts::OptionSchemas
+      # @param [Class<Thor>] handler_cls the handler
+      def self.sub_cmd_meta(_schema, handler_cls)
+        schema = _schema.deep_dup
+        desc(schema[:name], schema[:desc])
+        subcommand schema[:name], handler_cls
+      end
+
+      def self.option_defaults_hash
+        @_option_defaults_hash ||= {}
+      end
+
+      # def self.set_default_options_for_next(defaults)
+      #   defaults ||= Kerbi::Consts::OptionDefaults::BASE
+      #   option_defaults_hash[:__next__] = defaults.deep_dup
+      # end
+
+      ##
+      # Convenience class method for declaring a Thor command
+      # metadata bundle, in accordance with the schema in
+      # Kerbi::Consts::OptionSchemas.
+      # @param [Hash] _schema a dict from Kerbi::Consts::OptionSchemas
+      def self.cmd_meta(_schema)
+        schema = _schema.deep_dup
+        desc(schema[:name], schema[:desc])
+        # set_default_options_for_next(schema[:defaults])
+        (schema[:options] || []).each do |opt_schema|
+          opt_key = opt_schema.delete(:key)
+          self.option opt_key, opt_schema
+        end
+      end
+
+      def self.exit_on_failure?
+        true
+      end
+
+      def user_confirmed?(message='Are you sure?')
+        unless run_opts.confirmed?
+          end_with = "Enter 'yes' to confirm or re-run with --confirm."
+          echo("#{message} #{end_with}")
+          unless STDIN.gets.strip.downcase == "yes"
+            echo("Aborted")
+            return false
+          end
+        end
+        true
+      end
+
+      private
+
+      def utils
+        Kerbi::Utils
+      end
+    end
+  end
+end

data/lib/cli/base_serializer.rb

@@ -0,0 +1,120 @@
+module Kerbi
+  module Cli
+    class BaseSerializer
+
+      attr_reader :object
+      attr_reader :parent_object
+      attr_reader :context
+
+      def initialize(object, context={})
+        @object = object
+        @parent_object = context.delete(:parent_object)
+        @context = context
+      end
+
+      def serialize
+        flat_attrs = serialize_flat_attrs
+        assoc_attrs = serialize_associations
+        poss_attrs = serialize_possessions
+        flat_attrs.merge(assoc_attrs).merge(poss_attrs)
+      end
+
+      def serialize_flat_attrs
+        Hash[self.class.attributes.map do |attribute_name|
+          [attribute_name, attribute_value(attribute_name)]
+        end]
+      end
+
+      def serialize_possessions
+        Hash[self.class.possessions.map do |possession|
+          attr = possession[:attr] || possession[:name]
+          value = attribute_value(attr)
+          serialized_value = value && begin
+                                        serialized_relation_value(possession, value)
+                                      end
+          [attr, serialized_value]
+        end]
+      end
+
+      def serialize_associations
+        Hash[self.class.associations.map do |association|
+          attr = association[:attr] || association[:name]
+          values = attribute_value(attr)
+          values = limit_has_many(attr, values)
+          serialized_array = values.map do |value|
+            serialized_relation_value(association, value)
+          end
+          [attr, serialized_array]
+        end]
+      end
+
+      def serialized_relation_value(relation, value)
+        serializer = relation[:serializer]
+        new_context = context.merge(parent_object: object)
+        serializer.serialize(value, new_context)
+      end
+
+      def attribute_value(name)
+        receiver = self.respond_to?(name) ? self : object
+        receiver.send(name)
+      end
+
+      def limit_has_many(association_name, query_result)
+        limit_quantity = context["#{association_name}_limit".to_sym]
+        limit_quantity && query_result.limit(limit_quantity) || query_result
+      end
+
+      def key
+        object.id
+      end
+
+      def self.has_many(name, serializer, attr=nil)
+        @associations ||= []
+        @associations << {
+          name: name.to_sym,
+          serializer: serializer,
+          attr: attr
+        }
+      end
+
+      def self.has_one(name, serializer, attr=nil)
+        @possessions ||= []
+        @possessions << {
+          name: name.to_sym,
+          serializer: serializer,
+          attr: attr
+        }
+      end
+
+      def self.possessions
+        @possessions ||= []
+      end
+
+      def self.associations
+        @associations ||= []
+      end
+
+      def self.attributes
+        @attributes ||= []
+      end
+
+      def self.has_attributes(*attrs)
+        @attributes = attrs.map(&:to_sym)
+      end
+
+      def self.header_titles
+        attributes.map(&:to_s).map(&:upcase)
+      end
+
+      def self.serialize(object, context={})
+        instance = new(object, context)
+        instance.serialize
+      end
+
+      def self.serialize_many(objects, context={})
+        out = objects.map {|object| serialize(object, context)}
+        { data: out }
+      end
+    end
+  end
+end

data/lib/cli/config_handler.rb

@@ -0,0 +1,51 @@
+module Kerbi
+  module Cli
+    class ConfigHandler < BaseHandler
+
+      cmd_meta Kerbi::Consts::CommandSchemas::CONFIG_LOCATION
+      def location
+        echo Kerbi::ConfigFile.file_path
+      end
+
+      cmd_meta Kerbi::Consts::CommandSchemas::CONFIG_SET
+      def set(key, new_value)
+        raise_if_bad_write(key)
+        old_value = run_opts.options[key]
+        Kerbi::ConfigFile.patch(key => new_value)
+
+        name = "config[#{key}]"
+        change_str = "from #{old_value} => #{new_value}"
+        echo "Updated #{name} #{change_str}".colorize(:green)
+      end
+
+      cmd_meta Kerbi::Consts::CommandSchemas::CONFIG_GET
+      def get(key)
+        echo run_opts.options[key]
+      end
+
+      cmd_meta Kerbi::Consts::CommandSchemas::CONFIG_SHOW
+      def show
+        echo_data(run_opts.options)
+      end
+
+      cmd_meta Kerbi::Consts::CommandSchemas::CONFIG_RESET
+      def reset
+        Kerbi::ConfigFile.reset
+        echo("Config reset".colorize(:green))
+        echo("See #{Kerbi::ConfigFile.file_path}")
+      end
+
+      private
+
+      def raise_if_bad_write(key)
+        unless legal_keys.include?(key)
+          raise Kerbi::IllegalConfigWrite.new(key)
+        end
+      end
+
+      def legal_keys
+        Kerbi::Consts::OptionKeys::LEGAL_CONFIG_FILE_KEYS
+      end
+    end
+  end
+end

data/lib/cli/entry_serializers.rb

@@ -0,0 +1,99 @@
+module Kerbi
+  module Cli
+    module EntrySerializationHelpers
+      def defined_or_na(actual_value)
+        if !(value = actual_value).nil?
+          if block_given?
+            begin
+              yield(value)
+            rescue
+              "ERR"
+            end
+          else
+            value
+          end
+        else
+          "N/A"
+        end
+      end
+
+      def colored_tag
+        #noinspection RubyResolve
+        color = object.committed? ? :blue : :yellow
+        object.tag.colorize(color)
+      end
+
+    end
+
+    class EntryYamlJsonSerializer < Kerbi::Cli::BaseSerializer
+      include Kerbi::Cli::EntrySerializationHelpers
+
+      has_attributes(
+        :tag,
+        :message,
+        :created_at,
+        :values,
+        :default_values,
+        :overridden_keys
+      )
+    end
+
+    class FullEntryRowSerializer < Kerbi::Cli::BaseSerializer
+      include Kerbi::Cli::EntrySerializationHelpers
+
+      has_attributes(
+        :tag,
+        :message,
+        :created_at,
+        :values,
+        :default_values,
+        :overridden_keys
+      )
+
+      def tag
+        #noinspection RubyResolve
+        colored_tag.bold
+      end
+    end
+
+    class EntryRowSerializer < Kerbi::Cli::BaseSerializer
+      include Kerbi::Cli::EntrySerializationHelpers
+
+      has_attributes(
+        :tag,
+        :message,
+        :assignments,
+        :overrides,
+        :created_at
+      )
+
+      def tag
+        colored_tag
+      end
+
+      def message
+        (object.message || "").truncate(27)
+      end
+
+      def assignments
+        defined_or_na(object.values) do |values|
+          Kerbi::Utils::Misc.flatten_hash(values).count
+        end
+      end
+
+      def overrides
+        defined_or_na(object.overrides_delta) do |differences|
+          Kerbi::Utils::Misc.flatten_hash(differences).count
+        end
+      end
+
+      def created_at
+        if object.created_at
+          Kerbi::Utils::Misc.pretty_time_elapsed(object.created_at)
+        else
+          "N/A"
+        end
+      end
+    end
+  end
+end

data/lib/cli/project_handler.rb

@@ -2,11 +2,11 @@ module Kerbi
   module Cli
     class ProjectHandler < BaseHandler
 
-      thor_meta Kerbi::Consts::CommandSchemas::NEW_PROJECT
+      cmd_meta Kerbi::Consts::CommandSchemas::NEW_PROJECT
       def new_project(project_name)
         generator = Kerbi::CodeGen::ProjectGenerator.new(
           project_name: project_name,
-          ruby_version: cli_opts.ruby_version,
+          ruby_version: run_opts.ruby_version,
           verbose: true
         )
         success = generator.run

data/lib/cli/release_handler.rb

@@ -0,0 +1,41 @@
+module Kerbi
+  module Cli
+    class ReleaseHandler < BaseHandler
+
+      cmd_meta Kerbi::Consts::CommandSchemas::INIT_RELEASE
+      # @param [String] release_name refers to a Kubernetes namespace
+      def init(release_name)
+        mem_release_name(release_name)
+        state_backend.provision_missing_resources(verbose: run_opts.verbose?)
+        ns_key = Kerbi::Consts::OptionSchemas::NAMESPACE
+        Kerbi::ConfigFile.patch({ns_key => release_name})
+      end
+
+      cmd_meta Kerbi::Consts::CommandSchemas::RELEASE_STATUS
+      def status(release_name)
+        mem_release_name(release_name)
+        backend = state_backend
+        backend.test_connection(verbose: run_opts.verbose?)
+      end
+
+      cmd_meta Kerbi::Consts::CommandSchemas::RELEASE_LIST
+      def list
+        prep_opts(Kerbi::Consts::OptionDefaults::LIST_STATE)
+        auth_bundle = Kerbi::Utils::Cli.make_k8s_auth_bundle(run_opts)
+        backends = Kerbi::State::ConfigMapBackend.releases(auth_bundle)
+        backends.each(&:prime)
+        echo_data(backends, serializer: Kerbi::Cli::ReleaseSerializer)
+      end
+
+      cmd_meta Kerbi::Consts::CommandSchemas::RELEASE_DELETE
+      def delete(release_name)
+        mem_release_name(release_name)
+        backend = state_backend
+        return unless user_confirmed?
+        old_signature = backend.resource_signature
+        backend.delete
+        echo("Deleted #{old_signature}")
+      end
+    end
+  end
+end

data/lib/cli/release_serializer.rb

@@ -0,0 +1,46 @@
+module Kerbi
+  module Cli
+    class ReleaseSerializer < Kerbi::Cli::BaseSerializer
+      has_attributes(
+        :name,
+        :backend,
+        :namespace,
+        :resource,
+        :states,
+        :latest
+      )
+
+      def name
+        object.release_name
+      end
+
+      def backend
+        object.class.type_signature
+      end
+
+      def resource
+        object.resource_name
+      end
+
+      def states
+        if object.working?
+          object.entries.count
+        else
+          broken_txt
+        end
+      end
+
+      def latest
+        if object.working?
+          object.entry_set.latest&.tag
+        else
+          broken_txt
+        end
+      end
+
+      def broken_txt
+        "ERR"
+      end
+    end
+  end
+end

data/lib/cli/root_handler.rb

@@ -2,6 +2,7 @@ module Kerbi
 
   class Console
     attr_reader :values
+
     def initialize(values)
       @values = values
     end
@@ -12,36 +13,56 @@ module Kerbi
   end
 
   module Cli
-
     ##
     # Top level CLI command handler with Thor.
     class RootHandler < BaseHandler
 
-      cmd_schemas = Kerbi::Consts::CommandSchemas
+      ##
+      # Two things happen here:
+      # 1. Kerbi::Globals.reset is necessary for testing, because memory
+      # is not flushed.
+      def self.start(*args, **kwargs)
+        begin
+          Kerbi::Globals.reset
+          super
+        rescue Kerbi::Error => e
+          #noinspection RubyResolve
+          puts e.to_s.colorize(:red).bold
+        end
+      end
 
-      thor_meta cmd_schemas::TEMPLATE
+      cmd_meta Kerbi::Consts::CommandSchemas::TEMPLATE
       # @param [String] release_name helm-like Kubernetes release name
-      # @param [String] path root dir from which to search for kerbifile.rb
-      def template(release_name, path)
-        utils::Cli.load_kerbifile(path)
-        values = self.compile_values
+      def template(release_name)
+        mem_release_name(release_name)
+        utils::Cli.load_kerbifile(run_opts.project_root)
+        values = compile_values
+        persist_compiled_values
         mixer_classes = Kerbi::Globals.mixers
         res_dicts = utils::Cli.run_mixers(mixer_classes, values, release_name)
-        print_dicts(res_dicts)
+        echo_data(res_dicts, coerce_type: "Array")
       end
 
-      thor_meta cmd_schemas::CONSOLE
+      cmd_meta Kerbi::Consts::CommandSchemas::CONSOLE
       def console
-        utils::Cli.load_kerbifile(".")
-        values = self.compile_values
+        utils::Cli.load_kerbifile(run_opts.project_root)
+        values = compile_values
         ARGV.clear
         IRB.setup(eval("__FILE__"), argv: [])
         workspace = IRB::WorkSpace.new(Console.new(values))
         IRB::Irb.new(workspace).run(IRB.conf)
       end
 
-      thor_sub_meta cmd_schemas::VALUES_SUPER, ValuesHandler
-      thor_sub_meta cmd_schemas::PROJECT_SUPER, ProjectHandler
+      cmd_meta Kerbi::Consts::CommandSchemas::SHOW_VERSION
+      def version
+        puts "1"
+      end
+
+      sub_cmd_meta Kerbi::Consts::CommandSchemas::VALUES_SUPER, ValuesHandler
+      sub_cmd_meta Kerbi::Consts::CommandSchemas::PROJECT_SUPER, ProjectHandler
+      sub_cmd_meta Kerbi::Consts::CommandSchemas::RELEASE_SUPER, ReleaseHandler
+      sub_cmd_meta Kerbi::Consts::CommandSchemas::STATE_SUPER, StateHandler
+      sub_cmd_meta Kerbi::Consts::CommandSchemas::CONFIG_SUPER, ConfigHandler
     end
   end
 end