kerbi 0.0.1 → 0.0.5

data/lib/config/cli_opts.rb

@@ -1,50 +0,0 @@
-module Kerbi
-
-  ##
-  # Convenience accessor struct for getting values from
-  # the CLI args.
-  class CliOpts
-
-    attr_reader :options
-
-    def initialize(options={})
-      @options = options.deep_dup
-    end
-
-    def output_format
-      value = options[consts::OUTPUT_FMT]
-      value || "yaml"
-    end
-
-    def outputs_yaml?
-      self.output_format == 'yaml'
-    end
-
-    def outputs_json?
-      self.output_format == 'json'
-    end
-
-    def ruby_version
-      options[consts::RUBY_VER]
-    end
-
-    def fname_exprs
-      options[consts::VALUE_FNAMES] || []
-    end
-
-    def inline_val_exprs
-      options[consts::INLINE_ASSIGNMENT] || []
-    end
-
-    def use_state?
-      options[consts::USE_STATE_VALUES].present?
-    end
-
-    private
-
-    def consts
-      Kerbi::Consts::OptionKeys
-    end
-
-  end
-end

data/lib/config/manager.rb

@@ -1,36 +0,0 @@
-module Kerbi
-  module Config
-    class Manager
-      attr_reader :bundle
-
-      def initialize
-        # TODO load me from filesystem
-        @bundle = {
-          tmp_helm_values_path: '/tmp/kerbi-helm-vals.yaml',
-          helm_exec: "helm"
-        }
-      end
-
-      def self.inst
-        # TODO create ~/.config/kerbi etc...
-        @_instance ||= self.new
-      end
-
-      def self.tmp_helm_values_path
-        inst.bundle[:tmp_helm_values_path]
-      end
-
-      def self.helm_exec
-        inst.bundle[:helm_exec]
-      end
-
-      def self.tmp_helm_values_path=(val)
-        inst.bundle[:tmp_helm_values_path] = val
-      end
-
-      def self.helm_exec=(val)
-        inst.bundle[:helm_exec] = val
-      end
-    end
-  end
-end

data/lib/main/state_manager.rb

@@ -1,47 +0,0 @@
-module Kerbi
-  class StateManager
-    def self.patch
-      self.create_configmap_if_missing
-      patch_values = self.compile_patch
-      config_map = utils::State.kubectl_get_cm("state", raise_on_err: false)
-      crt_values = utils::State.read_cm_data(config_map)
-      merged_vars = crt_values.deep_merge(patch_values)
-      new_body = { **config_map, data: { variables: JSON.dump(merged_vars) } }
-      yaml_body = YAML.dump(new_body.deep_stringify_keys)
-      Utils::Kubectl.apply_tmpfile(yaml_body, args_manager.get_kmd_arg_str)
-    end
-
-    def compile_patch
-      values = {}
-
-      args_manager.get_fnames.each do |fname|
-        new_values = YAML.load_file(fname).deep_symbolize_keys
-        values.deep_merge!(new_values)
-      end
-
-      args_manager.get_inlines.each do |assignment_str|
-        assignment = Utils::Utils.str_assign_to_h(assignment_str)
-        values.deep_merge!(assignment)
-      end
-      values
-    end
-
-    def get_crt_vars
-      create_configmap_if_missing
-      get_configmap_values(get_configmap)
-    end
-
-    def create_configmap_if_missing
-      unless get_configmap(raise_on_er: false)
-        kmd = "create cm state #{args_manager.get_kmd_arg_str}"
-        Utils::Kubectl.kmd(kmd)
-      end
-    end
-
-    private
-
-    def utils
-      Kerbi::Utils
-    end
-  end
-end

data/lib/utils/kubectl.rb

@@ -1,58 +0,0 @@
-module Kerbi
-  module Utils
-    module Kubectl
-      def self.kmd(cmd, options = {})
-        cmd = "kubectl #{cmd}"
-        self.eval_shell_cmd(cmd, options)
-      end
-
-      def self.jkmd(cmd, options={})
-        cmd = "kubectl #{cmd} -o json"
-        begin
-          output = self.eval_shell_cmd(cmd, options)
-          as_hash = JSON.parse(output).deep_symbolize_keys
-          if as_hash.has_key?(:items)
-            as_hash[:items]
-          else
-            as_hash
-          end
-        rescue
-          nil
-        end
-      end
-
-      def self.eval_shell_cmd(cmd, options={})
-        print_err = options[:print_err]
-        raise_on_err = options[:raise_on_err]
-        begin
-          output, status = Open3.capture2e(cmd)
-          if status.success?
-            output = output[0..output.length - 2] if output.end_with?("\n")
-            output
-          else
-            if print_err
-              puts "Command \"#{cmd}\" error status #{status} with message:"
-              puts output
-              puts "---"
-            end
-            nil
-          end
-        rescue Exception => e
-          if print_err
-            puts "Command \"#{cmd}\" failed with message:"
-            puts e.message
-            puts "---"
-          end
-          nil
-        end
-      end
-
-      def self.apply_tmpfile(yaml_str, append)
-        tmp_fname = "/tmp/man-#{SecureRandom.hex(32)}.yaml"
-        File.write(tmp_fname, yaml_str)
-        kmd("apply -f #{tmp_fname} #{append}", print_err: true)
-        File.delete(tmp_fname)
-      end
-    end
-  end
-end

data/spec/main/examples_spec.rb

@@ -1,12 +0,0 @@
-require_relative './../spec_helper'
-require_relative './../../examples/hello-kerbi/kerbifile'
-
-RSpec.describe "Examples Directory" do
-  describe "The mixer" do
-    describe "#run" do
-      it "runs" do
-        # puts Kerbi::Globals.mixers.first.new({ }).run
-      end
-    end
-  end
-end

data/spec/main/state_manager_spec.rb

@@ -1,84 +0,0 @@
-# require_relative './../spec_helper'
-
-# RSpec.describe Kerbi::StateManager do
-#
-#   subject { Kerbi::StateManager.new }
-#
-#   context = ENV['KERBI_RSPEC_K8S_CONTEXT'] || 'kind-kind'
-#
-  # before :each do
-  #   puts "KONTEXT #{context}"
-  # end
-  #
-  # describe "#patch" do
-  #   context "when there is no entry for variables" do
-  #
-  #     before :each do
-  #       system(
-  #         "kubectl delete cm state -n default --context #{context}",
-  #         out: File::NULL,
-  #         err: File::NULL
-  #       )
-  #     end
-  #
-  #     it "patches the configmap" do
-  #       argue("--context #{context} --set foo.bar=baz")
-  #       old_values = subject.get_crt_vars
-  #       expect(old_values).to eq({})
-  #       subject.patch
-  #       new_values = subject.get_crt_vars
-  #       expect(new_values).to eq({foo: {bar: "baz"}})
-  #     end
-  #   end
-  #
-  #   context "when there is an entry for variables" do
-  #
-  #     before :each do
-  #       system "kubectl delete cm state -n default --context #{context}"
-  #     end
-  #
-  #     it "patches the configmap" do
-  #       argue("--context #{context} --set foo.bar=baz")
-  #       subject.patch
-  #
-  #       argue("--context #{context} --set foo.bar=car")
-  #       subject.patch
-  #
-  #       new_values = subject.get_crt_vars
-  #       expect(new_values).to eq({foo: {bar: "car"}})
-  #     end
-  #
-  #   end
-  # end
-  #
-  # describe "#get_configmap" do
-  #   context "when it does not exist" do
-  #
-  #     before :each do
-  #       system "kubectl delete cm state -n default --context #{context}"
-  #     end
-  #
-  #     it "returns the configmap as a hash" do
-  #       argue("--context #{context}")
-  #       result = subject.get_configmap(raise_on_er: false)
-  #       expect(result).to be_nil
-  #     end
-  #   end
-  #
-  #   context "when it does exist" do
-  #     before :each do
-  #       system "kubectl create cm state -n default --context #{context}"
-  #     end
-  #
-  #     it "returns the configmap as a hash" do
-  #       argue("--context #{context}")
-  #       result = subject.get_configmap
-  #       expect(result).to_not be_nil
-  #       must_have = { name: "state", namespace: "default" }
-  #       expect(result[:metadata].slice(:name, :namespace)).to eq(must_have)
-  #     end
-  #   end
-  # end
-
-
-# end

data/spec/utils/state_utils.rb

@@ -1,15 +0,0 @@
-module Kerbi
-  module Utils
-    module State
-      def self.kubectl_get_cm(res_name, opts={})
-        kmd = "get configmap #{res_name} #{opts[:kubectl_args]}"
-        Utils::Kubectl.jkmd(kmd, **opts)
-      end
-
-      def self.read_cm_data(configmap)
-        json_enc_vars = configmap.dig(:data, :variables) || '{}'
-        JSON.parse(json_enc_vars).deep_symbolize_keys
-      end
-    end
-  end
-end