kerbi 0.0.1 → 0.0.2

data/lib/utils/k8s_auth.rb

@@ -0,0 +1,87 @@
+module Kerbi
+  module Utils
+
+    ##
+    # ALl *_bundle methods return a custom-schema hash
+    # that is to be used to create a Kubeclient::Client instance.
+    # See its constructor docs to understand.
+    # Underlying lib credit: https://github.com/ManageIQ/kubeclient
+    module K8sAuth
+
+      ##
+      # Auth using config/credentials from a local kube context
+      # entry.
+      # See https://github.com/ManageIQ/kubeclient#kubeclientconfig
+      def self.kube_config_bundle(path: nil, name: nil)
+        path = path || default_kube_config_path
+        config = Kubeclient::Config.read(path)
+        context = config.context(name)
+
+        {
+          endpoint: context.api_endpoint,
+          options: {
+            ssl_options: context.ssl_options,
+            auth_options: context.auth_options
+          }
+        }
+      end
+
+      ##
+      # Basic username password auth.
+      # See https://github.com/ManageIQ/kubeclient#authentication
+      def self.basic_auth_bundle(username:, password:)
+        {
+          endpoint: "https://localhost:8443/api",
+          options: {
+            auth_options: {
+              username: username,
+              password: password
+            }
+          }
+        }
+      end
+
+      ##
+      # Auth using explicit bearer token for each request.
+      # See https://github.com/ManageIQ/kubeclient#authentication
+      def self.token_auth_bundle(bearer_token:)
+        {
+          endpoint: "https://localhost:8443/api",
+          options: {
+            auth_options: {
+              bearer_token: bearer_token
+            }
+          }
+        }
+      end
+
+      ##
+      # Auth if kerbi is inside a Kubernetes cluster. Uses default
+      # credentials in pod's filesystem. Likely requires extra
+      # RBAC resources for that service account to exist, e.g
+      # a few Roles/ClusterRoles and RoleBinding/ClusterRoleBindings
+      # in order for CRUD methods to actually work.
+      # See https://github.com/ManageIQ/kubeclient#middleware
+      def self.in_cluster_auth_bundle
+        token_path = '/var/run/secrets/kubernetes.io/serviceaccount/token'
+        ca_crt_path = "/var/run/secrets/kubernetes.io/serviceaccount/ca.crt"
+        auth_options = { bearer_token_file: token_path }
+
+        ssl_options = {}
+        ssl_options[:ca_file] = ca_crt_path if File.exist?(ca_crt_path)
+
+        {
+          endpoint: "https://kubernetes.default.svc",
+          options: {
+            auth_options: auth_options,
+            ssl_options: ssl_options
+          }
+        }
+      end
+
+      def self.default_kube_config_path
+        ENV['KUBECONFIG'] || "#{Dir.home}/.kube/config"
+      end
+    end
+  end
+end

data/lib/utils/misc.rb

@@ -16,7 +16,7 @@ module Kerbi
       # @return [Array] subset of candidate filenames that are real filenames
       def self.real_files_for(*candidates)
         candidates.select do |fname|
-          File.exists?(fname)
+          File.exists?(fname) && !Dir.exists?(fname)
         end
       end
 
@@ -36,6 +36,41 @@ module Kerbi
           end
         end
       end
+
+      ##
+      # Credit: https://gist.github.com/henrik/146844
+      # @param [Hash] hash_a
+      # @param [Hash] hash_b
+      def self.deep_hash_diff(hash_a, hash_b)
+        (hash_a.keys | hash_b.keys).inject({}) do |diff, k|
+          if hash_a[k] != hash_b[k]
+            if hash_a[k].is_a?(Hash) && hash_b[k].is_a?(Hash)
+              diff[k] = deep_hash_diff(hash_a[k], hash_b[k])
+            else
+              diff[k] = [hash_a[k], hash_b[k]]
+            end
+          end
+          diff
+        end
+      end
+
+      ##
+      # Credit: https://stackoverflow.com/a/195894/11913562
+      # @param [Time] other
+      # @return [String]
+      def self.pretty_time_elapsed(other)
+        a = (Time.now - other).to_i
+        case a
+        when 0 then 'just now'
+        when 1 then 'a second ago'
+        when 2..59 then a.to_s+' seconds ago'
+        when 60..119 then 'a minute ago' #120 = 2 minutes
+        when 120..3540 then (a/60).to_i.to_s+' minutes ago'
+        when 3541..7100 then 'an hour ago' # 3600 = 1 hour
+        when 7101..82800 then ((a+99)/3600).to_i.to_s+' hours ago'
+        else other.to_s
+        end
+      end
     end
   end
 end

data/lib/utils/mixing.rb

@@ -24,7 +24,7 @@ module Kerbi
         contents = File.read(fname)
         begin
           self.yaml_str_to_dicts(contents, **opts)
-        rescue Exception => e
+        rescue Error => e
           STDERR.puts "Exception below from file #{fname}"
           raise e
         end

data/lib/utils/values.rb

@@ -4,8 +4,6 @@ module Kerbi
     # Utilities module for all value loading functionality.
     module Values
 
-      DEFAULT_VALUE_PATH = "values"
-
       def self.from_files(fname_exprs, **opts)
         final_paths = resolve_fname_exprs(fname_exprs, **opts)
         load_yaml_files(final_paths)
@@ -21,16 +19,24 @@ module Kerbi
       # @param [Hash] opts downstream options for file-loading methods
       # @return [Array<String>] list of unique absolute filenames
       def self.resolve_fname_exprs(fname_exprs, **opts)
-        final_exprs = [self::DEFAULT_VALUE_PATH, *fname_exprs].uniq
+        final_exprs = fname_exprs.uniq
         final_exprs.map do |fname_expr|
-          path = resolve_fname_expr(fname_expr, **opts)
-          if fname_expr != 'values' && !path
-            raise "Could not resolve file '#{fname_expr}'"
-          end
+          candidate_paths = values_paths(fname_expr, **opts)
+          path = Kerbi::Utils::Misc.real_files_for(*candidate_paths)[0]
+          raise_if_file_not_found(fname_expr, path, **opts)
           path.presence
         end.compact.uniq
       end
 
+      def self.raise_if_file_not_found(fname_expr, path, **opts)
+        if fname_expr != 'values' && !path
+          raise Kerbi::ValuesFileNotFoundError.new(
+            fname_expr: fname_expr,
+            root: opts[:root]
+          )
+        end
+      end
+
       ##
       # Loads the dicts from files pointed to by final_file_paths into
       # memory, and returns the deep-merged hash in the order of the files.
@@ -54,21 +60,6 @@ module Kerbi
         end
       end
 
-      ##
-      # Turns a user supplied values filename into a final, usable
-      # absolute filesystem path. This method calls the values_paths method,
-      # which assumes a kerbi directory structure.
-      # @param [String] expr
-      # @param [Hash] opts
-      # @return [?String] the absolute filename or nil if it does not exist
-      def self.resolve_fname_expr(expr, **opts)
-        candidate_paths = self.values_paths(expr, **opts)
-        candidate_paths.find do |candidate_path|
-          File.exists?(candidate_path) && \
-          !File.directory?(candidate_path)
-        end
-      end
-
       ##
       # Parses a single cli-level key-value assignment with the form
       # foo.bar=baz. Raises an exception if the expression is malformed.

data/spec/cli/config_handler_spec.rb

@@ -0,0 +1,38 @@
+require_relative './../spec_helper'
+
+RSpec.describe "$ kerbi config [COMMAND]" do
+
+  before(:each) { Kerbi::ConfigFile.reset }
+
+  describe "$ kerbi config show" do
+    it "outputs the expected text" do
+      exp_cli_eq_file("config show", "config", "show-default", "yaml")
+    end
+  end
+
+  describe "$ kerbi config set [ATTR] [VALUE]" do
+    let(:cmd) { "config set namespace kerbi-spec" }
+    context "for a legal assignment" do
+      it "outputs the expected text and changes the value" do
+        exp_cli_eq_file(cmd, "config", "set", "txt")
+        new_value = Kerbi::ConfigFile.read["namespace"]
+        expect(new_value).to eq("kerbi-spec")
+      end
+    end
+    context "for an illegal assignment" do
+      let(:cmd){ "config set bad-key fail" }
+      it "outputs the expected error message" do
+        exp_cli_eq_file(cmd, "config", "bad-set", "txt")
+      end
+    end
+  end
+
+  describe "$ kerbi config get [ATTR]" do
+    let(:cmd) { "config get namespace" }
+    it "outputs the expected text and changes the value" do
+      cli("config set namespace kerbi-spec")
+      expect(cli(cmd).gsub(/\s+/, "")).to eq("kerbi-spec")
+    end
+  end
+
+end

data/spec/cli/root_handler_spec.rb

@@ -0,0 +1,99 @@
+require_relative './../spec_helper'
+require 'io/console'
+
+RSpec.describe "$ kerbi [COMMAND]" do
+  let(:namespace) { "kerbi-spec" }
+  let(:cm_name) { Kerbi::State::Consts::RESOURCE_NAME }
+  let(:exps_dir) { "root" }
+  let(:root_dir) { "#{__dir__}/../../examples/hello-kerbi" }
+
+  spec_bundles = [
+    ["", "template"],
+    ["-f production", "template-production"],
+    ["-f production --set pod.image=ubuntu", "template-inlines"]
+  ].freeze
+
+  describe "$ kerbi template" do
+
+    context "without state" do
+      spec_bundles.each do |bundle|
+        context "with #{bundle[0].presence || "no args"}" do
+          it "echos the expected text" do
+            cmd = hello_kerbi("template foo #{bundle[0]}")
+            exp_cli_eq_file(cmd, "root", bundle[1], "yaml")
+          end
+        end
+      end
+    end
+
+    context "with with state" do
+
+      let(:backend){ make_backend(namespace) }
+
+      before :each do
+        kmd("create ns #{namespace}")
+        kmd("delete cm #{cm_name} -n #{namespace}")
+        backend = make_backend(namespace)
+        backend.provision_missing_resources(quiet: true)
+      end
+
+      def exp_vals(which)
+        str_keyed_hash = read_exp_file("root", "values", "json")
+        str_keyed_hash.deep_symbolize_keys[which.to_sym]
+      end
+
+      def template_write_cmd(pod_image)
+        base_cmd = "template foo --set pod.image=#{pod_image} --write-state foo"
+        hello_kerbi(base_cmd, namespace)
+      end
+
+      context "with writing" do
+        before :each do
+          cmd = template_write_cmd("centos")
+          exp_cli_eq_file(cmd, "root", "template-write", "yaml")
+        end
+
+        context "--write-state when the entry does not yet exist" do
+          it "creates a new entry with the expected values" do
+            entry = backend.entries[0]
+            expect(backend.entries.count).to eq(1)
+            expect(entry.tag).to eq("foo")
+            expect(entry.values).to eq(exp_vals("centos"))
+            expect(entry.default_values).to eq(exp_vals("nginx"))
+          end
+        end
+
+        context "--write-state with an existing state entry" do
+          it "updates the existing entry with the expected values" do
+            cli(template_write_cmd("centos"))
+            cli(template_write_cmd("debian"))
+            expect(backend.entries.count).to eq(1)
+            entry = backend.entries[0]
+            expect(entry.tag).to eq("foo")
+            expect(entry.values).to eq(exp_vals("debian"))
+            expect(entry.default_values).to eq(exp_vals("nginx"))
+          end
+        end
+      end
+
+      context "--read-state with an existing state entry" do
+        before(:each) { cli(template_write_cmd("centos")) }
+
+        context "without inline overrides" do
+          it "echos the expected text" do
+            cmd = hello_kerbi("template foo --read-state foo", namespace)
+            exp_cli_eq_file(cmd, "root", "template-read", "yaml")
+          end
+        end
+
+        context "with inline overrides" do
+          it "echos the expected text, preferring the inline over the state" do
+            base = "template foo --read-state foo --set pod.image=busybox"
+            cmd = hello_kerbi(base, namespace)
+            exp_cli_eq_file(cmd, "root", "template-read-inlines", "yaml")
+          end
+        end
+      end
+    end
+  end
+end

data/spec/cli/state_handler_spec.rb

@@ -0,0 +1,139 @@
+require_relative './../spec_helper'
+
+RSpec.describe "$ kerbi state [COMMAND]" do
+
+  let(:namespace) { "kerbi-spec" }
+  let(:cm_name) { Kerbi::State::Consts::RESOURCE_NAME }
+  let(:exps_dir) { "state" }
+
+  let(:set) do
+    new_state_set(
+      one: { values: {x: "x"}, created_at: Time.new(2000).to_s },
+      two: { message: "message", created_at: Time.new(2001).to_s },
+      "[cand]-three".to_sym => { created_at: Time.new(2002).to_s },
+      "[cand]-four".to_sym => { created_at: Time.new(2003).to_s }
+    )
+  end
+
+  before :each do
+    kmd("create ns #{namespace}")
+    kmd("delete cm #{cm_name} -n #{namespace}")
+    backend = make_backend(namespace)
+    configmap_dict = backend.template_resource(set.entries)
+    backend.apply_resource(configmap_dict)
+  end
+
+  describe "$ kerbi state init" do
+    let(:cmd) { "state init kerbi-spec" }
+    context "when resources already existed" do
+      it "echoes the correct text" do
+        exp_cli_eq_file(cmd, exps_dir, "init-already-existed")
+      end
+    end
+
+    context "when the resources did not exist" do
+      it "echoes the correct text" do
+        kmd("delete ns #{namespace}")
+        exp_cli_eq_file(cmd, exps_dir, "init-both-created")
+      end
+    end
+  end
+
+  describe "$ kerbi state status" do
+    let(:cmd) { "state status -n #{namespace}" }
+    context "when everything is ready" do
+      it "echoes the correct text" do
+        exp_cli_eq_file(cmd, exps_dir, "status-all-working")
+      end
+    end
+
+    context "when connected but resources not provisioned" do
+      it "echoes the correct text" do
+        kmd("delete ns #{namespace}")
+        exp_cli_eq_file(cmd, exps_dir, "status-not-provisioned")
+      end
+    end
+  end
+
+  describe "$ kerbi state list" do
+    cmd_group_spec("state list -n kerbi-spec", "state", "list")
+  end
+
+  describe "$ kerbi state show [TAG]" do
+    cmd_group_spec(
+      "state show one -n kerbi-spec",
+      "state",
+      "show"
+    )
+
+    cmd_group_spec(
+      "state show @oldest -n kerbi-spec",
+      "state",
+      "show",
+      context_append: " using @oldest instead of a literal tag"
+    )
+  end
+
+  describe "$ kerbi state retag [OLD_TAG] [NEW_TAG]" do
+    def make_cmd(old_tag)
+      "state retag #{old_tag} born-again -n #{namespace}"
+    end
+
+    context "when the old tag exists" do
+      context "using a literal tag" do
+        it "echos the expected text" do
+          exp_cli_eq_file(make_cmd("two"), exps_dir, "retag")
+        end
+      end
+
+      context "using @latest or @oldest" do
+        it "echos the expected text" do
+          exp_cli_eq_file(make_cmd("@latest"), exps_dir, "retag")
+        end
+      end
+    end
+
+    context "when the old tag does not exist" do
+      it "echos the expected text" do
+        exp_cli_eq_file(make_cmd("bad-tag"), "common", "bad-tag")
+      end
+    end
+  end
+
+  describe "$ kerbi state promote" do
+    let(:cmd) { "state promote @candidate -n #{namespace}" }
+    it "echos the expected text" do
+      exp_cli_eq_file(cmd, exps_dir, "promote")
+    end
+  end
+
+  describe "$ kerbi state demote" do
+    let(:cmd) { "state demote @latest -n #{namespace}" }
+    it "echos the expected text" do
+      exp_cli_eq_file(cmd, exps_dir, "demote")
+    end
+  end
+
+  describe "$ kerbi state set" do
+    let(:easy_part) { "state set @latest message" }
+    let(:cmd) { easy_part.split(" ") + ["new message", "-n", namespace] }
+    it "echos the expected text" do
+      exp_cli_eq_file(cmd, exps_dir, "set")
+    end
+  end
+
+  describe "$ kerbi state delete" do
+    let(:cmd) { "state delete @latest -n #{namespace}" }
+    it "echos the expected text" do
+      exp_cli_eq_file(cmd, exps_dir, "delete")
+    end
+  end
+
+  describe "$ kerbi state prune-candidates" do
+    let(:cmd) { "state prune-candidates -n #{namespace}" }
+    it "echos the expected text" do
+      exp_cli_eq_file(cmd, exps_dir, "prune-candidates")
+    end
+  end
+
+end

data/spec/cli/values_handler_spec.rb

@@ -0,0 +1,17 @@
+require_relative './../spec_helper'
+require 'io/console'
+
+RSpec.describe "$ kerbi values [COMMAND]" do
+  let(:namespace) { "kerbi-spec" }
+
+  describe "$ kerbi values show" do
+    context "without state" do
+      it "respects --set > -f > defaults" do
+        base = "values show -f v2 -f production --set service.type=NodePort"
+        cmd = hello_kerbi(base)
+        exp_cli_eq_file(cmd, "values", "order-of-precedence", "yaml")
+      end
+    end
+  end
+
+end

data/spec/expectations/common/bad-tag.txt

@@ -0,0 +1 @@
+\e[1;31;49mState given by tag bad-tag not found\e[0m

data/spec/expectations/config/bad-set.txt

@@ -0,0 +1 @@
+\e[1;31;49mIllegal config assignment. 'bad-key' not in ["state-backend", "namespace", "auth-type", "kube-config-context", "username", "password", "token"]\e[0m

data/spec/expectations/config/set.txt

@@ -0,0 +1 @@
+\e[0;32;49mUpdated config[namespace] from  => kerbi-spec\e[0m

data/spec/expectations/config/show-default.yaml

@@ -0,0 +1,6 @@
+load-defaults: true
+inline-value: []
+values-file: []
+output-format: yaml
+state-backend: configmap
+auth-type: kube-config

data/spec/expectations/root/template-inlines.yaml

@@ -0,0 +1,31 @@
+apiVersion: v1
+kind: Pod
+metadata:
+  name: hello-kerbi
+  namespace: foo
+  annotations:
+    author: xavier
+  labels:
+    app: hello-kerbi
+spec:
+  containers:
+    - name: main
+      image: ubuntu:alpine
+
+---
+
+apiVersion: v1
+kind: Service
+metadata:
+  name: hello-kerbi
+  namespace: foo
+  annotations:
+    author: xavier
+  labels:
+    app: hello-kerbi
+spec:
+  type: LoadBalancer
+  selector:
+    app: hello-kerbi
+  ports:
+    - port: 80

data/spec/expectations/root/template-production.yaml

@@ -0,0 +1,31 @@
+apiVersion: v1
+kind: Pod
+metadata:
+  name: hello-kerbi
+  namespace: foo
+  annotations:
+    author: xavier
+  labels:
+    app: hello-kerbi
+spec:
+  containers:
+    - name: main
+      image: nginx:alpine
+
+---
+
+apiVersion: v1
+kind: Service
+metadata:
+  name: hello-kerbi
+  namespace: foo
+  annotations:
+    author: xavier
+  labels:
+    app: hello-kerbi
+spec:
+  type: LoadBalancer
+  selector:
+    app: hello-kerbi
+  ports:
+    - port: 80

data/spec/expectations/root/template-read-inlines.yaml

@@ -0,0 +1,31 @@
+apiVersion: v1
+kind: Pod
+metadata:
+  name: hello-kerbi
+  namespace: foo
+  annotations:
+    author: xavier
+  labels:
+    app: hello-kerbi
+spec:
+  containers:
+    - name: main
+      image: busybox:alpine
+
+---
+
+apiVersion: v1
+kind: Service
+metadata:
+  name: hello-kerbi
+  namespace: foo
+  annotations:
+    author: xavier
+  labels:
+    app: hello-kerbi
+spec:
+  type: ClusterIP
+  selector:
+    app: hello-kerbi
+  ports:
+    - port: 80

data/spec/expectations/root/template-read.yaml

@@ -0,0 +1,31 @@
+apiVersion: v1
+kind: Pod
+metadata:
+  name: hello-kerbi
+  namespace: foo
+  annotations:
+    author: xavier
+  labels:
+    app: hello-kerbi
+spec:
+  containers:
+    - name: main
+      image: centos:alpine
+
+---
+
+apiVersion: v1
+kind: Service
+metadata:
+  name: hello-kerbi
+  namespace: foo
+  annotations:
+    author: xavier
+  labels:
+    app: hello-kerbi
+spec:
+  type: ClusterIP
+  selector:
+    app: hello-kerbi
+  ports:
+    - port: 80

data/spec/expectations/root/template-write.yaml

@@ -0,0 +1,31 @@
+apiVersion: v1
+kind: Pod
+metadata:
+  name: hello-kerbi
+  namespace: foo
+  annotations:
+    author: xavier
+  labels:
+    app: hello-kerbi
+spec:
+  containers:
+    - name: main
+      image: centos:alpine
+
+---
+
+apiVersion: v1
+kind: Service
+metadata:
+  name: hello-kerbi
+  namespace: foo
+  annotations:
+    author: xavier
+  labels:
+    app: hello-kerbi
+spec:
+  type: ClusterIP
+  selector:
+    app: hello-kerbi
+  ports:
+    - port: 80