kerbi 0.0.1

data/lib/main/mixer.rb

@@ -0,0 +1,235 @@
+module Kerbi
+  class Mixer
+    include Kerbi::Mixins::Mixer
+
+    ##
+    # Values hash available to subclasses
+    # @return [Immutable::Hash] symbol-keyed hash
+    attr_reader :values
+
+    ##
+    # Release name available for templating
+    # @return [String] symbol-keyed hash
+    attr_reader :release_name
+
+    ##
+    # Array of res-hashes being aggregated
+    # @return [Array<Hash>] list of hashes
+    attr_reader :output
+
+    ##
+    # Array of patches to be applied to results
+    # @return [Array<Hash>] list of hashes
+    attr_accessor :patch_stack
+
+    ##
+    # Constructor
+    # @param [Hash] values the values tree that will be accessible to the subclass
+    def initialize(values, opts={})
+      @output = []
+      @release_name = opts[:release_name] || "default"
+      @patch_stack = []
+      @values = self.class.compute_own_values_subtree(
+        values,
+        opts[:overwrite_values_root]
+      )
+    end
+
+    ##
+    # Where users should return a hash or
+    # an array of hashes representing Kubernetes resources
+    # @yield [bucket] Exec context in which hashes are collected into one bucket
+    # @yieldparam [Kerbi::ResBucket] g Bucket object with essential methods
+    # @yieldreturn [Array<Hash>] array of hashes representing Kubernetes resources
+    # @return [Array<Hash>] array of hashes representing Kubernetes resources
+    def run
+      begin
+        self.mix
+      rescue Exception => e
+        puts "Exception below caused by mixer #{self.class.name}"
+        raise e
+      end
+      self.output
+    end
+
+    def mix
+    end
+
+    ##
+    # Registers a dict or an array of dicts that will part of the
+    # mixers's final output, which is an Array<Hash>.
+    # @param [Hash | Array<Hash>] dict the hash to be added
+    def push(dicts)
+      final_list = Utils::Mixing.sanitize_res_dict_list(dicts)
+      self.output.append(*final_list)
+    end
+
+    ##
+    # Normalizes, sanitizes and filters a dict or an array of
+    # dicts.
+    # @param [Hash | Array<Hash>] dict the hash to be added
+    def dicts(dict, **opts)
+      output = Utils::Mixing.clean_and_filter_dicts(dict, **opts)
+      should_patch = opts[:no_patch].blank?
+      should_patch ? apply_patch_context(output) : output
+    end
+    alias_method :dict, :dicts
+
+    ##
+    # Loads a YAML/JSON/ERB file, parses it, interpolates it,
+    # and returns processed and filtered list of dicts via #dicts.
+    # @param [String] fname with or without extension, relative to self
+    # @param [Hash] opts filtering and other options for #dicts
+    # @return [Array<Hash>] processed dicts read from file
+    def file(fname, **opts)
+      output = Utils::Mixing.yaml_file_to_dicts(
+        self.class.resolve_file_name(fname),
+        **opts.merge({src_binding: binding})
+      )
+      dicts(output)
+    end
+
+    # @param [String] fname
+    # @param [Hash] opts filtering and other options for #dicts
+    # @return [Array]
+    def dir(fname, **opts)
+      output = Utils::Mixing.yamls_in_dir_to_dicts(
+        self.class.pwd,
+        resolve_file_name(fname),
+        **opts
+      )
+      dicts(output)
+    end
+
+    ##
+    # Run 'helm template' on Helm project, parse the output into dicts,
+    # return processed and filtered list via #dicts.
+    # @param [String] chart_id using format 'jetstack/cert-manager'
+    # @param [Hash] opts filtering and other options for #dicts
+    # @return [Array<Hash>] processed and filtered dicts
+    def chart(chart_id, **opts)
+      release = opts[:release] || release_name
+      helm_output = Utils::Helm.template(release, chart_id, **opts)
+      dicts(helm_output)
+    end
+
+    ##
+    # Run another mixer given by klass, return processed and
+    # filtered list via #dicts.
+    # @param [Class<Kerbi::Mixer>] klass other mixer's class
+    # @param [Hash] opts filtering and other options for #dicts
+    # @return [Array<Hash>] processed and filtered dicts
+    def mixer(klass, **opts)
+      force_subtree = opts.delete(:values)
+      mixer_inst = klass.new(
+        force_subtree.nil? ? values : force_subtree,
+        release_name: release_name,
+        overwrite_values_subtree: !force_subtree.nil?
+      )
+      output = mixer_inst.run
+      dicts(output)
+    end
+
+    ##
+    # Any x-to-dict statements (e.g #dicts, #dir, #chart) executed
+    # in the &block passed to this method will have their return values
+    # deep merged with the dict(s) passed.
+    # @param [Array<Hash>|Hash] dict
+    # @param [Proc] block
+    # @return [Array<Hash>, Hash]
+    def patched_with(dict, &block)
+      new_patches = extract_patches(dict)
+      patch_stack.push(new_patches)
+      yield(block)
+      patch_stack.pop
+    end
+
+    private
+
+    def extract_patches(obj)
+      (obj.is_a?(Hash) ? [obj] : obj).map(&:deep_dup)
+    end
+
+    def apply_patch_context(output)
+      return output if patch_stack.blank?
+      output.map do |res|
+        patch_stack.flatten.inject(res) do |whole, patch|
+          whole.deep_merge(patch)
+        end
+      end
+    end
+
+    ##
+    # Coerces filename of unknown format to an absolute path
+    # @param [String] fname simplified or absolute path of file
+    # @return [String] a variation of the filename that exists
+    ##
+    # Convenience instance method for accessing class level pwd
+    # @return [String] the subclass' pwd as defined by the user
+
+    class << self
+
+      ##
+      # Pass a deep key that will be used to dig into the values
+      # dict the mixer gets upon initialization. For example if
+      # deep_key is "x", then if the mixer is initialized with
+      # values as x: {y: 'z'}, then its final values attribute
+      # will be {y: 'z'}.
+      def values_root(deep_key)
+        @vals_root_deep_key = deep_key
+      end
+
+      def compute_own_values_subtree(values_root, override)
+        self.compute_values_subtree(
+          values_root,
+          override ? nil : @vals_root_deep_key
+        )
+      end
+
+      ##
+      # Given a values_root dict and a deep key (e.g "x.y.z"), outputs
+      # a frozen, deep-cloned, subtree corresponding to the deep
+      # key's position in the values_root.
+      # @param [Hash] values_root dict from which to extract subtree
+      # @param [String] deep_key key in dict in "x.y.z" format
+      # @return [Hash] frozen and deep-cloned subtree
+      def compute_values_subtree(values_root, deep_key)
+        subtree = values_root.deep_dup
+        if deep_key.present?
+          deep_key_parts = deep_key.split(".")
+          subtree = subtree.dig(*deep_key_parts)
+        end
+        subtree.freeze
+      end
+
+      def resolve_file_name(fname)
+        dir = self.pwd
+        Kerbi::Utils::Misc.real_files_for(
+          fname,
+          "#{fname}.yaml",
+          "#{fname}.yaml.erb",
+          "#{dir}/#{fname}",
+          "#{dir}/#{fname}.yaml",
+          "#{dir}/#{fname}.yaml.erb"
+        ).first
+      end
+
+      ##
+      # Sets the absolute path of the directory where
+      # yamls used by this Gen can be found, usually "__dir__"
+      # @param [String] dirname absolute path of the directory
+      # @return [void]
+      def locate_self(dirname)
+        @dir_location = dirname
+      end
+
+      ##
+      # Returns the value set by locate_self
+      # @return [String] the subclass' pwd as defined by the user
+      def pwd
+        @dir_location
+      end
+    end
+
+  end
+end

data/lib/main/state_manager.rb

@@ -0,0 +1,47 @@
+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/mixins/mixer.rb

@@ -0,0 +1,79 @@
+module Kerbi
+  module Mixins
+    module Mixer
+
+      # @param [Hash] dict hash or array
+      # @return [String] encoded string
+      def embed(dict, indent: 25)
+        _dict = dict.is_a?(Array) ? dict.first : dict
+        raw = YAML.dump(_dict).sub("---", "")
+        indented_lines = raw.split("\n").map do |line|
+          line.indent(indent)
+        end
+        "\n#{indented_lines.join("\n")}"
+      end
+
+      # @param [Array|Hash] dicts hash or array
+      # @return [String] encoded string
+      def embed_array(dicts, indent: 25)
+        return "[]" unless dicts.present?
+
+        unless dicts.is_a?(Array)
+          raise "embed_array called with non-array #{dicts.class} #{dicts}"
+        end
+
+        raw = YAML.dump(dicts).sub("---", "")
+        indented_lines = raw.split("\n").map do |line|
+          line.indent(indent)
+        end
+
+        "\n#{indented_lines.join("\n")}"
+      end
+
+      # @param [String] string string to be base64 encoded
+      # @return [String] encoded string
+      def b64enc(string)
+        if string
+          Base64.strict_encode64(string)
+        else
+          ''
+        end
+      end
+
+      # @param [String] string string to be base64 encoded
+      # @return [String] encoded string
+      def b64dec(string)
+        if string
+          Base64.decode64(string).strip
+        else
+          ''
+        end
+      end
+
+      # @param [String] fname absolute path of file to be encoded
+      # @return [String] encoded string
+      def b64enc_file(fname)
+        file_contents = File.read(fname) rescue nil
+        b64enc(file_contents)
+      end
+
+      ##
+      # @param [Hash] opts options
+      # @option opts [String] url full URL to raw yaml file contents on the web
+      # @option opts [String] from one of [github]
+      # @option opts [String] except list of filenames to avoid
+      # @raise [Exception] if project-id/file missing in github hash
+      def http_descriptor_to_url(**opts)
+        return opts[:url] if opts[:url]
+
+        if opts[:from] == 'github'
+          base = "https://raw.githubusercontent.com"
+          branch = opts[:branch] || 'master'
+          project, file = (opts[:project] || opts[:id]), opts[:file]
+          raise "Project and/or file not found" unless project && file
+          "#{base}/#{project}/#{branch}/#{file}"
+        end
+      end
+    end
+  end
+end

data/lib/utils/cli.rb

@@ -0,0 +1,59 @@
+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
+      # preserving the order they were created in.
+      # @param [Array<Class<Kerbi::Mixer>] mixer_classes mixers to run
+      # @param [Hash] values root values hash to pass to all mixers
+      # @param [Object] release_name helm-like release_name for mixers
+      # @return [List<Hash>] all dicts emitted by mixers
+      def self.run_mixers(mixer_classes, values, release_name)
+        mixer_classes.inject([]) do |whole, gen_class|
+          mixer_instance = gen_class.new(values, release_name: release_name)
+          whole + mixer_instance.run.flatten
+        end
+      end
+
+      ##
+      # Turns list of key-symbol dicts into their
+      # pretty YAML representation.
+      # @param [Array<Hash>] dicts dicts to YAMLify
+      # @return [String] pretty YAML representation of input
+      def self.dicts_to_yaml(dicts)
+        if dicts.is_a?(Array)
+          dicts.each_with_index.map do |h, i|
+            raw = YAML.dump(h.deep_stringify_keys)
+            raw.gsub("---\n", i.zero? ? '' : "---\n\n")
+          end.join("\n")
+        else
+          as_yaml = YAML.dump(dicts.deep_stringify_keys)
+          as_yaml.gsub("---\n", "")
+        end
+      end
+
+      ##
+      # Turns list of key-symbol dicts into their
+      # pretty JSON representation.
+      # @param [Array<Hash>] dicts dicts to YAMLify
+      # @return [String] pretty JSON representation of input
+      def self.dicts_to_json(dicts)
+        JSON.pretty_generate(dicts)
+      end
+
+      ##
+      # 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
+      end
+    end
+  end
+end

data/lib/utils/helm.rb

@@ -0,0 +1,64 @@
+module Kerbi
+  module Utils
+    module Helm
+
+      def self.config
+        Kerbi::Config::Manager
+      end
+
+      ##
+      # 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)
+      end
+
+      ##
+      # Writes a hash of values to a YAML to a temp file
+      # @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
+      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)
+        end
+      end
+
+      ##
+      # Joins assignments in flat hash into list of --set flags
+      # @param [Hash] inline_assigns flat Hash of deep_key: val
+      # @return [String] corresponding space-separated --set flags
+      def self.encode_inline_assigns(inline_assigns)
+        (inline_assigns || []).map do |key, value|
+          raise "Assignments must be flat"  if value.is_a?(Hash)
+          "--set #{key}=#{value}"
+        end.join(" ")
+      end
+
+      ##
+      # Runs the helm template command
+      # @param [String] release release name to pass to Helm
+      # @param [String] project <org>/<chart> string identifying helm chart
+      # @return [Array<Hash>]
+      def self.template(release, project, opts={})
+        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 += " -f #{tmp_file} #{inline_flags} #{opts[:cli_args]}"
+        output = `#{command}`
+        del_tmp_values_file
+        YAML.load_stream(output)
+      end
+    end
+  end
+end

data/lib/utils/kubectl.rb

@@ -0,0 +1,58 @@
+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/lib/utils/misc.rb

@@ -0,0 +1,41 @@
+module Kerbi
+  module Utils
+    module Misc
+      def self.one_to_array(item)
+        return [] if item.nil?
+        if item.is_a?(Array)
+          item
+        else
+          [item]
+        end
+      end
+
+      ## Given a list of filenames, returns the subset that
+      # are real files.
+      # @param [Array] candidates filenames to try
+      # @return [Array] subset of candidate filenames that are real filenames
+      def self.real_files_for(*candidates)
+        candidates.select do |fname|
+          File.exists?(fname)
+        end
+      end
+
+      ##
+      # Turns a nested dict into a deep-keyed dict. For example
+      # {x: {y: 'z'}} becomes {'x.y': 'z'}
+      # @param [Hash] hash input nested dict
+      # @return [Hash] flattened dict
+      def self.flatten_hash(hash)
+        hash.each_with_object({}) do |(k, v), h|
+          if v.is_a? Hash
+            flatten_hash(v).map do |h_k, h_v|
+              h["#{k}.#{h_k}".to_sym] = h_v
+            end
+          else
+            h[k] = v
+          end
+        end
+      end
+    end
+  end
+end