kerbi 0.0.1 → 0.0.2

data/lib/config/cli_schema.rb

@@ -2,51 +2,178 @@ module Kerbi
   module Consts
 
     module OptionKeys
-      OUTPUT_FMT = "output"
+      PROJECT_ROOT = "project-root"
+
+      OUTPUT_FMT = "output-format"
       INLINE_ASSIGNMENT = "inline-value"
+      LOAD_DEFAULT_VALUES = "load-defaults"
       VALUE_FNAMES = "values-file"
-      USE_STATE_VALUES = "use-state-values"
+
       RUBY_VER = "ruby-version"
       VERBOSE = "verbose"
+
+      STATE_BACKEND_TYPE = "state-backend"
+      READ_STATE = "read-state"
+      STRICT_READ_STATE = "strict-read"
+      WRITE_STATE = "write-state"
+      NAMESPACE = "namespace"
+      WRITE_STATE_MESSAGE = "message"
+
+      K8S_AUTH_TYPE = "auth-type"
+      KUBE_CONFIG_PATH = "kube-config-path"
+      KUBE_CONFIG_CONTEXT = "kube-config-context"
+      K8S_USERNAME = "username"
+      K8S_PASSWORD = "password"
+      K8S_TOKEN = "token"
+
+      LEGAL_CONFIG_FILE_KEYS = [
+        STATE_BACKEND_TYPE,
+        NAMESPACE,
+        K8S_AUTH_TYPE,
+        KUBE_CONFIG_CONTEXT,
+        K8S_USERNAME,
+        K8S_PASSWORD,
+        K8S_TOKEN
+      ]
+    end
+
+    module OptionDefaults
+      BASE = {
+        OptionKeys::LOAD_DEFAULT_VALUES => true,
+        OptionKeys::INLINE_ASSIGNMENT => [],
+        OptionKeys::VALUE_FNAMES => [],
+        OptionKeys::OUTPUT_FMT => "yaml",
+        OptionKeys::STATE_BACKEND_TYPE => "configmap",
+        OptionKeys::K8S_AUTH_TYPE => "kube-config"
+      }.freeze
+
+      LIST_STATE = BASE.merge(
+        OptionKeys::OUTPUT_FMT => "table"
+      ).freeze
     end
 
     module OptionSchemas
-      OUTPUT_FMT = {
-        key: OptionKeys::OUTPUT_FMT,
-        desc: "Specify YAML or JSON. Defaults to YAML",
-        enum: %w[yaml json]
-      }
 
-      USE_STATE_VALUES = {
-        key: OptionKeys::USE_STATE_VALUES,
-        desc: "If true, merges in values loaded from state ConfigMap",
-        type: "boolean"
+      PROJECT_ROOT = {
+        key: OptionKeys::PROJECT_ROOT,
+        desc: "Project root. An abs path, a rel path, or remote (/foo, foo, @foo/bar)",
+        aliases: "-p"
       }
 
+      K8S_AUTH_TYPE = {
+        key: OptionKeys::K8S_AUTH_TYPE,
+        desc: "Strategy for connecting to target cluster (defaults to kube-config)",
+        enum: %w[kube-config in-cluster basic token]
+      }.freeze
+
+      KUBE_CONFIG_PATH = {
+        key: OptionKeys::KUBE_CONFIG_PATH,
+        desc: "path to your kube-config file, defaults to ~/.kube/config"
+      }.freeze
+
+      KUBE_CONFIG_CONTEXT = {
+        key: OptionKeys::KUBE_CONFIG_CONTEXT,
+        desc: "context to use in your kube config,
+defaults to $(kubectl config current-context)"
+      }.freeze
+
+      K8S_USERNAME = {
+        key: OptionKeys::K8S_USERNAME,
+        desc: "Kubernetes auth username for basic password auth"
+      }.freeze
+
+      K8S_PASSWORD = {
+        key: OptionKeys::K8S_PASSWORD,
+        desc: "Kubernetes auth password for basic password auth"
+      }.freeze
+
+      LOAD_DEFAULT_VALUES = {
+        key: OptionKeys::LOAD_DEFAULT_VALUES,
+        desc: "Automatically load values.yaml. Defaults to true.",
+        type: "boolean",
+        default: true
+      }.freeze
+
+      K8S_TOKEN = {
+        key: OptionKeys::K8S_TOKEN,
+        desc: "Kubernetes auth bearer token for token auth"
+      }.freeze
+
+      STATE_BACKEND_TYPE = {
+        key: OptionKeys::STATE_BACKEND_TYPE,
+        desc: "Persistent store to keep track of applied values (configmap, secret)",
+        enum: %w[configmap secret]
+      }.freeze
+
+      OUTPUT_FMT = {
+        key: OptionKeys::OUTPUT_FMT,
+        aliases: "-o",
+        desc: "Specify YAML, JSON, or table",
+        enum: %w[yaml json table]
+      }.freeze
+
       INLINE_ASSIGNMENT = {
         key: OptionKeys::INLINE_ASSIGNMENT,
         aliases: "--set",
         desc: "An inline variable assignment, e.g --set x.y=foo --set x.z=bar",
         repeatable: true
-      }
+      }.freeze
+
+      READ_STATE = {
+        key: OptionKeys::READ_STATE,
+        desc: "Merge values from given state record into final values.",
+      }.freeze
+
+      STRICT_READ_STATE = {
+        key: OptionKeys::STRICT_READ_STATE,
+        desc: "Makes read-state operations fail if the state does not exist for the given tag",
+      }.freeze
+
+      WRITE_STATE = {
+        key: OptionKeys::WRITE_STATE,
+        desc: "write compiled values into given state record"
+      }.freeze
+
+      NAMESPACE = {
+        key: OptionKeys::NAMESPACE,
+        aliases: "-n",
+        desc: "for state operations, tell kerbi that the state
+               configmap/secret is in this namespace"
+      }.freeze
 
       VALUE_FNAMES = {
         key: OptionKeys::VALUE_FNAMES,
         aliases: "-f",
         desc: "Name of a values file to be loaded.",
         repeatable: true
-      }
+      }.freeze
 
       RUBY_VER = {
         key: OptionKeys::RUBY_VER,
         desc: "Specify ruby version for Gemfile in a new project"
-      }
+      }.freeze
 
       VERBOSE = {
         key: OptionKeys::VERBOSE,
         desc: "Run in verbose mode",
         enum: %w[true false]
-      }
+      }.freeze
+
+      KUBERNETES_OPTIONS = [
+        NAMESPACE,
+        STATE_BACKEND_TYPE,
+        READ_STATE,
+        WRITE_STATE,
+        K8S_AUTH_TYPE,
+        KUBE_CONFIG_PATH,
+        KUBE_CONFIG_CONTEXT
+      ].freeze
+
+      VALUES_OPTIONS = [
+        VALUE_FNAMES,
+        INLINE_ASSIGNMENT,
+        LOAD_DEFAULT_VALUES,
+      ].freeze
     end
 
     module CommandSchemas
@@ -54,31 +181,49 @@ module Kerbi
       VALUES_SUPER = {
         name: "values",
         desc: "Command group for values actions: show, get"
-      }
+      }.freeze
 
       PROJECT_SUPER = {
         name: "project",
         desc: "Command group for project actions: new, info"
-      }
+      }.freeze
+
+      STATE_SUPER = {
+        name: "state",
+        desc: "Command group for state actions: test, list, show"
+      }.freeze
+
+      CONFIG_SUPER = {
+        name: "config",
+        desc: "Command group for config actions: set, get, show"
+      }.freeze
 
       TEMPLATE = {
         name: "template [KERBIFILE] [RELEASE_NAME]",
         desc: "Runs mixers for RELEASE_NAME",
         options: [
+          OptionSchemas::PROJECT_ROOT,
           OptionSchemas::OUTPUT_FMT,
-          OptionSchemas::VALUE_FNAMES,
-          OptionSchemas::INLINE_ASSIGNMENT
+          *OptionSchemas::VALUES_OPTIONS,
+          *OptionSchemas::KUBERNETES_OPTIONS
         ]
-      }
+      }.freeze
 
       CONSOLE = {
         name: "console",
         desc: "Opens an IRB console so you can play with your mixers",
         options: [
+          OptionSchemas::PROJECT_ROOT,
           OptionSchemas::VALUE_FNAMES,
           OptionSchemas::INLINE_ASSIGNMENT
         ]
-      }
+      }.freeze
+
+      VERSION = {
+        name: "version",
+        desc: "Prints the version of this RubyGem",
+        options: []
+      }.freeze
 
       NEW_PROJECT = {
         name: "new",
@@ -87,18 +232,145 @@ module Kerbi
           OptionSchemas::RUBY_VER,
           OptionSchemas::VERBOSE
         ]
-      }
+      }.freeze
+
+      STATE_STATUS = {
+        name: "status",
+        desc: "Verbosely assesses the readiness of your state-tracking backend.",
+        options: [
+          *OptionSchemas::KUBERNETES_OPTIONS,
+          OptionSchemas::VERBOSE
+        ]
+      }.freeze
+
+      LIST_STATE = {
+        name: "list",
+        desc: "Print all recorded states for this namespace",
+        options: [
+          *OptionSchemas::KUBERNETES_OPTIONS,
+          OptionSchemas::OUTPUT_FMT
+        ],
+        defaults: OptionDefaults::LIST_STATE
+      }.freeze
+
+      INIT_STATE = {
+        name: "init [NAMESPACE]",
+        desc: "Provision the resources for persisting the state",
+        options: [
+          *OptionSchemas::KUBERNETES_OPTIONS,
+          OptionSchemas::VERBOSE
+        ]
+      }.freeze
+
+      SHOW_STATE = {
+        name: "show [TAG]",
+        desc: "Print summary of state identified by [TAG]",
+        options: [
+          *OptionSchemas::KUBERNETES_OPTIONS,
+          OptionSchemas::OUTPUT_FMT
+        ],
+        defaults: OptionDefaults::LIST_STATE
+      }.freeze
+
+      RETAG_STATE = {
+        name: "retag [OLD_TAG] [NEW_TAG]",
+        desc: "Updates entry's tag given by [OLD_TAG] to [NEW_TAG]",
+        options: [
+          *OptionSchemas::KUBERNETES_OPTIONS,
+          OptionSchemas::OUTPUT_FMT
+        ],
+        defaults: OptionDefaults::LIST_STATE
+      }.freeze
+
+      PROMOTE_STATE = {
+        name: "promote [TAG]",
+        desc: "Removes the [cand]- prefix from the given entry,
+               removing its candidate status.",
+        options: [
+          *OptionSchemas::KUBERNETES_OPTIONS,
+        ],
+        defaults: OptionDefaults::LIST_STATE
+      }.freeze
+
+      DEMOTE_STATE = {
+        name: "promote [TAG]",
+        desc: "Adds the [cand]- prefix from the given entry,
+               giving it candidate status.",
+        options: [
+          *OptionSchemas::KUBERNETES_OPTIONS,
+        ],
+        defaults: OptionDefaults::LIST_STATE
+      }.freeze
+
+      DELETE_STATE = {
+        name: "delete [TAG]",
+        desc: "Deletes the state entry given by [TAG]",
+        options: [
+          *OptionSchemas::KUBERNETES_OPTIONS,
+        ]
+      }.freeze
+
+      SET_STATE_ATTR = {
+        name: "set [TAG] [ATTR_NAME] [NEW_VALUE]",
+        desc: "Updates state entry [TAG], attribute [ATTR_NAME] to value [NEW_VALUE]",
+        options: [
+          *OptionSchemas::KUBERNETES_OPTIONS,
+        ]
+      }.freeze
+
+      PRUNE_CANDIDATES_STATE = {
+        name: "prune-candidates",
+        desc: "Deletes all state entries flagged as candidates",
+        options: [
+          *OptionSchemas::KUBERNETES_OPTIONS,
+        ]
+      }.freeze
+
+      SHOW_VERSION = {
+        name: "version",
+        desc: "Print kerbi version",
+        options: []
+      }.freeze
 
       SHOW_VALUES = {
         name: "show",
         desc: "Print out loaded values as YAML",
         options: [
+          OptionSchemas::PROJECT_ROOT,
           OptionSchemas::OUTPUT_FMT,
-          OptionSchemas::VALUE_FNAMES,
-          OptionSchemas::INLINE_ASSIGNMENT
+          *OptionSchemas::VALUES_OPTIONS,
+          *OptionSchemas::KUBERNETES_OPTIONS
         ]
-      }
+      }.freeze
+
+      CONFIG_LOCATION = {
+        name: "location",
+        desc: "Prints out filesystem path for global Kerbi config"
+      }.freeze
+
+      CONFIG_SET = {
+        name: "set [KEY] [VALUE]",
+        desc: "Writes an x=y configuration to the global kerbi config"
+      }.freeze
+
+      CONFIG_GET = {
+        name: "get [KEY]",
+        desc: "Prints out the value of KEY as loaded into the options"
+      }.freeze
+
+      CONFIG_SHOW = {
+        name: "show",
+        desc: "Prints out the value of KEY as loaded into the options",
+        options: [
+          OptionSchemas::OUTPUT_FMT
+        ]
+      }.freeze
+
+      CONFIG_RESET = {
+        name: "reset",
+        desc: "Resets the config file to its default state",
+        options: []
+      }.freeze
     end
   end
-end
-
+end

data/lib/config/config_file.rb

@@ -0,0 +1,60 @@
+module Kerbi
+
+  module ConfigFile
+
+    DIR_NAME = ".kerbi"
+    FILE_NAME = "config.yaml"
+
+    def self.file_path
+      "#{Dir.home}/#{DIR_NAME}/#{FILE_NAME}"
+    end
+
+    def self.dir_path
+      "#{Dir.home}/#{DIR_NAME}"
+    end
+
+    def self.create_file_if_missing
+      unless File.exists?(file_path)
+        unless Dir.exists?(dir_path)
+          Dir.mkdir(dir_path)
+        end
+        write({}, skip_check: true)
+      end
+    end
+
+    # @return [Hash{Symbol, String}]
+    def self.read
+      begin
+        create_file_if_missing
+        contents = YAML.load_file(file_path)
+        contents.slice(*legal_keys)
+      rescue StandardError => e
+        puts "[WARN] failed to read config #{file_path} (#{e})"
+        {}
+      end
+    end
+
+    # @param [Hash] config
+    def self.write(config, skip_check: false)
+      create_file_if_missing unless skip_check
+      config = config.deep_dup.stringify_keys.slice(*legal_keys)
+      File.write(file_path, YAML.dump(config))
+    end
+
+    # @param [Hash] config
+    def self.patch(config)
+      existing_config = read
+      new_config = existing_config.merge(config)
+      write(new_config)
+    end
+
+    def self.reset
+      create_file_if_missing
+      write({})
+    end
+
+    def self.legal_keys
+      Kerbi::Consts::OptionKeys::LEGAL_CONFIG_FILE_KEYS
+    end
+  end
+end

data/lib/config/globals.rb

@@ -3,5 +3,9 @@ module Kerbi
     def self.mixers
       $_mixers ||= []
     end
+
+    def self.reset
+      $_mixers = []
+    end
   end
 end

data/lib/config/run_opts.rb

@@ -0,0 +1,150 @@
+module Kerbi
+
+  ##
+  # Convenience accessor struct for getting values from
+  # the CLI args.
+  #noinspection RubyTooManyMethodsInspection
+  class RunOpts
+
+    attr_reader :options
+
+    # @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
+      options[consts::STATE_BACKEND_TYPE]
+    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
+
+    private
+
+    # @return [Module<Kerbi::Consts::OptionKeys>]
+    def consts
+      Kerbi::Consts::OptionKeys
+    end
+
+  end
+end

data/lib/config/state_consts.rb

@@ -0,0 +1,10 @@
+module Kerbi
+  module State
+    module Consts
+      CREATOR_ATTR = :creator
+      CREATOR_VAL = "kerbi"
+      ENTRIES_ATTR = :entries
+      RESOURCE_NAME = "kerbi-state-tracker"
+    end
+  end
+end

data/lib/kerbi.rb

@@ -3,41 +3,63 @@
 #
 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 './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 './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/root_handler'