kerbi 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c7feca84f2b9ee27f1334a5e52025d16fb1a368d9d728a7de6e771d59fd65cc
-  data.tar.gz: 9834cee7f2e2c660eb141b52717e4f797548c2f71ce5c6e45fbf1cd763f85315
+  metadata.gz: bc84c52b063114ccf2c33721e609959a91ae8be6feeab8ff8036d94570ec1b5a
+  data.tar.gz: c6f4c586035a79b8a6588383e644d67707425d0ad015ba36063ce107874ae200
 SHA512:
-  metadata.gz: 15dca87ecb11f965ff00ba8ec715887764f896e23ddc847b3ef1ada56b68c61e12f072d8efd3fe281bf7d8777b1d7c8c32a4f338bc61e6db3c9d0eac0b5f69a5
-  data.tar.gz: f52084f692bda7ab3406e7142caf3c9521f2b62f0ddd1d8dc3b96b2fd766dd17ccd81966ede965383308f5a4e8ab56d82a2b0173d8fe2a381df5e203415288d8
+  metadata.gz: f2f8e07c36cce67f6caf752ac710d696edfa470266b018300eb3d793587ab866d0fda628d9838f926021bc66905fac19d686149b6018297a9282a8124398c80b
+  data.tar.gz: f637456bafb649caf59af1859de97fed2f84604a3b62ab34bf804a0deb4147074467150466c4b2ea7a4cd774270f20386ec32124e506db39ea9a4c6ab0695649

data/lib/cli/base_handler.rb

@@ -11,10 +11,12 @@ module Kerbi
       ##
       # Convenience method for instantiating (and memoizating) a state
       # management backend.
-      # @param [String] namespace force a k8s ns, otherwise uses run option's
-      # @return [Kerbi::State::Backend]
-      def state_backend(namespace=nil)
-        @_state_backend ||= generate_state_backend(namespace)
+      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
 
       ##
@@ -170,6 +172,18 @@ module Kerbi
         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

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

@@ -34,6 +34,7 @@ module Kerbi
       cmd_meta Kerbi::Consts::CommandSchemas::TEMPLATE
       # @param [String] release_name helm-like Kubernetes release name
       def template(release_name)
+        mem_release_name(release_name)
         utils::Cli.load_kerbifile(run_opts.project_root)
         values = compile_values
         persist_compiled_values
@@ -59,6 +60,7 @@ module Kerbi
 
       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

data/lib/cli/state_handler.rb

@@ -1,24 +1,10 @@
 module Kerbi
   module Cli
     class StateHandler < BaseHandler
-      cmd_meta Kerbi::Consts::CommandSchemas::INIT_STATE
-      # @param [String] namespace refers to a Kubernetes namespace
-      def init(namespace)
-        state_backend(namespace).provision_missing_resources(
-          verbose: run_opts.verbose?
-        )
-        ns_key = Kerbi::Consts::OptionSchemas::NAMESPACE
-        Kerbi::ConfigFile.patch({ns_key => namespace})
-      end
-
-      cmd_meta Kerbi::Consts::CommandSchemas::STATE_STATUS
-      def status
-        state_backend.test_connection(verbose: run_opts.verbose?)
-      end
-
       cmd_meta Kerbi::Consts::CommandSchemas::LIST_STATE
-      def list
+      def list(release_name)
         prep_opts(Kerbi::Consts::OptionDefaults::LIST_STATE)
+        mem_release_name(release_name)
         echo_data(
           state_backend.entries,
           table_serializer: Kerbi::Cli::EntryRowSerializer,
@@ -28,8 +14,9 @@ module Kerbi
 
       cmd_meta Kerbi::Consts::CommandSchemas::SHOW_STATE
       # @param [String] tag_expr e.g 1.9.1, @latest
-      def show(tag_expr)
+      def show(release_name, tag_expr)
         prep_opts(Kerbi::Consts::OptionDefaults::LIST_STATE)
+        mem_release_name(release_name)
         entry = find_readable_entry(tag_expr)
         echo_data(
           entry,
@@ -41,7 +28,8 @@ module Kerbi
       cmd_meta Kerbi::Consts::CommandSchemas::RETAG_STATE
       # @param [String] old_tag_expr e.g 1.9.1, @latest
       # @param [String] new_tag_expr e.g 1.9.1, @latest
-      def retag(old_tag_expr, new_tag_expr)
+      def retag(release_name, old_tag_expr, new_tag_expr)
+        mem_release_name(release_name)
         entry = find_readable_entry(old_tag_expr)
         old_tag = entry.retag(new_tag_expr)
         touch_and_save_entry(entry, tag: old_tag)
@@ -49,7 +37,8 @@ module Kerbi
 
       cmd_meta Kerbi::Consts::CommandSchemas::PROMOTE_STATE
       # @param [String] tag_expr e.g 1.9.1, @latest
-      def promote(tag_expr)
+      def promote(release_name, tag_expr)
+        mem_release_name(release_name)
         entry = find_readable_entry(tag_expr)
         old_name = entry.promote
         touch_and_save_entry(entry, tag: old_name)
@@ -57,7 +46,8 @@ module Kerbi
 
       cmd_meta Kerbi::Consts::CommandSchemas::DEMOTE_STATE
       # @param [String] tag_expr e.g 1.9.1, @latest
-      def demote(tag_expr)
+      def demote(release_name, tag_expr)
+        mem_release_name(release_name)
         entry = find_readable_entry(tag_expr)
         old_name = entry.demote
         touch_and_save_entry(entry, tag: old_name)
@@ -67,7 +57,8 @@ module Kerbi
       # @param [String] tag_expr e.g 1.9.1, @latest
       # @param [String] attr_name e.g message
       # @param [String] new_value e.g i am a new message
-      def set(tag_expr, attr_name, new_value)
+      def set(release_name, tag_expr, attr_name, new_value)
+        mem_release_name(release_name)
         entry = find_readable_entry(tag_expr)
         old_value = entry.assign_attr(attr_name, new_value)
         touch_and_save_entry(entry, attr_name => old_value)
@@ -75,7 +66,8 @@ module Kerbi
 
       cmd_meta Kerbi::Consts::CommandSchemas::DELETE_STATE
       # @param [String] tag_expr e.g 1.9.1, @latest
-      def delete(tag_expr)
+      def delete(release_name, tag_expr)
+        mem_release_name(release_name)
         entry = find_readable_entry(tag_expr)
         state_backend.delete_entry(entry)
         new_count = state_backend.entries.count
@@ -83,7 +75,8 @@ module Kerbi
       end
 
       cmd_meta Kerbi::Consts::CommandSchemas::PRUNE_CANDIDATES_STATE
-      def prune_candidates
+      def prune_candidates(release_name)
+        mem_release_name(release_name)
         old_count = entry_set.entries.count
         entry_set.prune_candidates
         state_backend.save

data/lib/code-gen/new-project/kerbifile.rb.erb

@@ -0,0 +1,9 @@
+module <%= (module_name = data[:user_module_name]) %>
+  class RootMixer < Kerbi::Mixer
+    def mix
+      push dict(text: "#{values[:message]} #{release_name} message")
+    end
+  end
+end
+
+Kerbi::Globals.mixers << <%= module_name %>::RootMixer

data/lib/code-gen/new-project/values.yaml.erb

@@ -0,0 +1 @@
+message: "normal"

data/lib/config/cli_schema.rb

@@ -11,6 +11,7 @@ module Kerbi
 
       RUBY_VER = "ruby-version"
       VERBOSE = "verbose"
+      PRE_CONFIRM = "confirm"
 
       STATE_BACKEND_TYPE = "state-backend"
       READ_STATE = "read-state"
@@ -19,21 +20,21 @@ module Kerbi
       NAMESPACE = "namespace"
       WRITE_STATE_MESSAGE = "message"
 
-      K8S_AUTH_TYPE = "auth-type"
+      K8S_AUTH_TYPE = "k8s-auth-type"
       KUBE_CONFIG_PATH = "kube-config-path"
       KUBE_CONFIG_CONTEXT = "kube-config-context"
-      K8S_USERNAME = "username"
-      K8S_PASSWORD = "password"
-      K8S_TOKEN = "token"
+      KUBE_ACCESS_TOKEN = "k8s-access-token"
+      K8S_USERNAME = "k8s-username"
+      K8S_PASSWORD = "k8s-password"
+      K8S_TOKEN = "k8s-access-token"
 
       LEGAL_CONFIG_FILE_KEYS = [
         STATE_BACKEND_TYPE,
-        NAMESPACE,
         K8S_AUTH_TYPE,
         KUBE_CONFIG_CONTEXT,
         K8S_USERNAME,
         K8S_PASSWORD,
-        K8S_TOKEN
+        KUBE_ACCESS_TOKEN
       ]
     end
 
@@ -50,19 +51,25 @@ module Kerbi
       LIST_STATE = BASE.merge(
         OptionKeys::OUTPUT_FMT => "table"
       ).freeze
+
+      LIST_RELEASE = BASE.merge(
+        OptionKeys::OUTPUT_FMT => "table"
+      ).freeze
     end
 
     module OptionSchemas
 
       PROJECT_ROOT = {
         key: OptionKeys::PROJECT_ROOT,
-        desc: "Project root. An abs path, a rel path, or remote (/foo, foo, @foo/bar)",
+        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)",
+        desc: "Strategy for connecting to target cluster "\
+              "(defaults to kube-config)",
         enum: %w[kube-config in-cluster basic token]
       }.freeze
 
@@ -101,7 +108,8 @@ defaults to $(kubectl config current-context)"
 
       STATE_BACKEND_TYPE = {
         key: OptionKeys::STATE_BACKEND_TYPE,
-        desc: "Persistent store to keep track of applied values (configmap, secret)",
+        desc: "Persistent store to keep track of applied "\
+              "values (configmap, secret)",
         enum: %w[configmap secret]
       }.freeze
 
@@ -115,7 +123,8 @@ defaults to $(kubectl config current-context)"
       INLINE_ASSIGNMENT = {
         key: OptionKeys::INLINE_ASSIGNMENT,
         aliases: "--set",
-        desc: "An inline variable assignment, e.g --set x.y=foo --set x.z=bar",
+        desc: "An inline variable assignment, e.g --set x.y=foo "\
+              "--set x.z=bar",
         repeatable: true
       }.freeze
 
@@ -126,7 +135,8 @@ defaults to $(kubectl config current-context)"
 
       STRICT_READ_STATE = {
         key: OptionKeys::STRICT_READ_STATE,
-        desc: "Makes read-state operations fail if the state does not exist for the given tag",
+        desc: "Makes read-state operations fail if the " \
+                "state does not exist for the given tag",
       }.freeze
 
       WRITE_STATE = {
@@ -159,6 +169,12 @@ defaults to $(kubectl config current-context)"
         enum: %w[true false]
       }.freeze
 
+      PRE_CONFIRM = {
+        key: OptionKeys::PRE_CONFIRM,
+        desc: "Skip CLI confirmation",
+        enum: %w[true false]
+      }.freeze
+
       KUBERNETES_OPTIONS = [
         NAMESPACE,
         STATE_BACKEND_TYPE,
@@ -190,7 +206,12 @@ defaults to $(kubectl config current-context)"
 
       STATE_SUPER = {
         name: "state",
-        desc: "Command group for state actions: test, list, show"
+        desc: "Command group for state actions"
+      }.freeze
+
+      RELEASE_SUPER = {
+        name: "release",
+        desc: "Command group for release actions"
       }.freeze
 
       CONFIG_SUPER = {
@@ -234,18 +255,39 @@ defaults to $(kubectl config current-context)"
         ]
       }.freeze
 
-      STATE_STATUS = {
-        name: "status",
-        desc: "Verbosely assesses the readiness of your state-tracking backend.",
+      RELEASE_STATUS = {
+        name: "status [RELEASE_NAME]",
+        desc: "Verbosely assesses the readiness of your "\
+              "state-tracking backend.",
         options: [
           *OptionSchemas::KUBERNETES_OPTIONS,
           OptionSchemas::VERBOSE
         ]
       }.freeze
 
-      LIST_STATE = {
+      RELEASE_LIST = {
         name: "list",
-        desc: "Print all recorded states for this namespace",
+        desc: "Lists all known Kerbi releases by scanning cluster" \
+              " ConfigMaps/Secrets",
+        options: [
+          *OptionSchemas::KUBERNETES_OPTIONS,
+          OptionSchemas::VERBOSE
+        ]
+      }.freeze
+
+      RELEASE_DELETE = {
+        name: "delete [RELEASE_NAME]",
+        desc: "Delete the ConfigMap/Secret storing states for"\
+              " this release",
+        options: [
+          *OptionSchemas::KUBERNETES_OPTIONS,
+          OptionSchemas::PRE_CONFIRM
+        ]
+      }.freeze
+
+      LIST_STATE = {
+        name: "list [RELEASE_NAME]",
+        desc: "Print all recorded states for [RELEASE_NAME]",
         options: [
           *OptionSchemas::KUBERNETES_OPTIONS,
           OptionSchemas::OUTPUT_FMT
@@ -253,8 +295,8 @@ defaults to $(kubectl config current-context)"
         defaults: OptionDefaults::LIST_STATE
       }.freeze
 
-      INIT_STATE = {
-        name: "init [NAMESPACE]",
+      INIT_RELEASE = {
+        name: "init [RELEASE_NAME]",
         desc: "Provision the resources for persisting the state",
         options: [
           *OptionSchemas::KUBERNETES_OPTIONS,
@@ -263,7 +305,7 @@ defaults to $(kubectl config current-context)"
       }.freeze
 
       SHOW_STATE = {
-        name: "show [TAG]",
+        name: "show [RELEASE_NAME] [TAG]",
         desc: "Print summary of state identified by [TAG]",
         options: [
           *OptionSchemas::KUBERNETES_OPTIONS,
@@ -273,7 +315,7 @@ defaults to $(kubectl config current-context)"
       }.freeze
 
       RETAG_STATE = {
-        name: "retag [OLD_TAG] [NEW_TAG]",
+        name: "retag [RELEASE_NAME] [OLD_TAG] [NEW_TAG]",
         desc: "Updates entry's tag given by [OLD_TAG] to [NEW_TAG]",
         options: [
           *OptionSchemas::KUBERNETES_OPTIONS,
@@ -283,7 +325,7 @@ defaults to $(kubectl config current-context)"
       }.freeze
 
       PROMOTE_STATE = {
-        name: "promote [TAG]",
+        name: "promote [RELEASE_NAME] [TAG]",
         desc: "Removes the [cand]- prefix from the given entry,
                removing its candidate status.",
         options: [
@@ -293,7 +335,7 @@ defaults to $(kubectl config current-context)"
       }.freeze
 
       DEMOTE_STATE = {
-        name: "promote [TAG]",
+        name: "promote [RELEASE_NAME] [TAG]",
         desc: "Adds the [cand]- prefix from the given entry,
                giving it candidate status.",
         options: [
@@ -303,7 +345,7 @@ defaults to $(kubectl config current-context)"
       }.freeze
 
       DELETE_STATE = {
-        name: "delete [TAG]",
+        name: "delete [RELEASE_NAME] [TAG]",
         desc: "Deletes the state entry given by [TAG]",
         options: [
           *OptionSchemas::KUBERNETES_OPTIONS,
@@ -311,15 +353,16 @@ defaults to $(kubectl config current-context)"
       }.freeze
 
       SET_STATE_ATTR = {
-        name: "set [TAG] [ATTR_NAME] [NEW_VALUE]",
-        desc: "Updates state entry [TAG], attribute [ATTR_NAME] to value [NEW_VALUE]",
+        name: "set [RELEASE_NAME] [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",
+        name: "prune-candidates [RELEASE_NAME]",
         desc: "Deletes all state entries flagged as candidates",
         options: [
           *OptionSchemas::KUBERNETES_OPTIONS,

data/lib/config/run_opts.rb

@@ -7,6 +7,7 @@ module Kerbi
   class RunOpts
 
     attr_reader :options
+    attr_accessor :release_name
 
     # @param [Hash{Symbol, Object}] cli_opts CLI args as a hash via Thor
     # @param [Hash{Symbol, Object}] defaults contextual defaults (per cmd)
@@ -111,7 +112,8 @@ module Kerbi
 
     # @return [String]
     def state_backend_type
-      options[consts::STATE_BACKEND_TYPE]
+      value = options[consts::STATE_BACKEND_TYPE]
+      value.is_a?(String) ? value : ''
     end
 
     # @return [String]
@@ -139,6 +141,16 @@ module Kerbi
       options[consts::PROJECT_ROOT].presence
     end
 
+    # @return [TrueClass, FalseClass]
+    def in_cluster?
+      options[consts::K8S_AUTH_TYPE] == 'in-cluster'
+    end
+
+    # @return [TrueClass, FalseClass]
+    def confirmed?
+      options[consts::PRE_CONFIRM].present?
+    end
+
     private
 
     # @return [Module<Kerbi::Consts::OptionKeys>]

data/lib/config/state_consts.rb

@@ -5,6 +5,7 @@ module Kerbi
       CREATOR_VAL = "kerbi"
       ENTRIES_ATTR = :entries
       RESOURCE_NAME = "kerbi-state-tracker"
+      CM_REGEX = /kerbi-(.*)-state-tracker/
     end
   end
 end

data/lib/kerbi.rb

@@ -37,17 +37,19 @@ require_relative './config/run_opts'
 
 require_relative './mixins/mixer'
 require_relative './mixins/cm_backend_testing'
+require_relative './utils/cli'
 require_relative './mixins/cli_state_helpers'
 
 require_relative './utils/mixing'
 require_relative './utils/helm'
-require_relative './utils/cli'
+
 require_relative './utils/values'
 require_relative './main/code_gen'
 
 require_relative './main/mixer'
 
 require_relative './cli/entry_serializers'
+require_relative './cli/release_serializer'
 
 require_relative './mixins/entry_tag_logic'
 require_relative './state/entry_set'
@@ -62,4 +64,5 @@ require_relative './cli/config_handler'
 require_relative './cli/values_handler'
 require_relative './cli/project_handler'
 require_relative './cli/state_handler'
+require_relative './cli/release_handler'
 require_relative './cli/root_handler'

data/lib/main/code_gen.rb

@@ -3,7 +3,7 @@ module Kerbi
     class ProjectGenerator
 
       ERB_EXT = ".erb"
-      BOILER_REL_PATH = "/../../boilerplate"
+      BOILER_REL_PATH = "/../code-gen/new-project"
 
       ##
       # Serves as both the new project's dir name and the mixer's _module name

data/lib/main/errors.rb

@@ -78,6 +78,12 @@ module Kerbi
     end
   end
 
+  class UnsupportedBackendError < Error
+    def initialize(name)
+      super("Unsupported state backend type")
+    end
+  end
+
   class EntryValidationError < Error
     MSG = "Cannot write state because of validation errors: "
 

data/lib/mixins/cli_state_helpers.rb

@@ -91,44 +91,16 @@ module Kerbi
       # generate an instance of the corresponding backend
       # class.
       # @return [Kerbi::State::Backend]
-      def generate_state_backend(namespace=nil)
-        if run_opts.state_backend_type == 'configmap'
-          auth_bundle = make_k8s_auth_bundle
+      def generate_state_backend(release_name: nil, namespace: nil)
+        if run_opts.state_backend_type.downcase.strip == 'configmap'
+          auth_bundle = Kerbi::Utils::Cli.make_k8s_auth_bundle(run_opts)
           Kerbi::State::ConfigMapBackend.new(
             auth_bundle,
+            release_name || run_opts.release_name,
             namespace || run_opts.cluster_namespace
           )
-        end
-      end
-
-      ##
-      # Given the various Kubernetes authentication options and
-      # configs, generates a Hash with the necessary data/schema
-      # to pass onto the internal k8s authentication logic.
-      #
-      # This method only delegates. Actual work done is done here at:
-      # Kerbi::Utils::K8sAuth.
-      # @return [Hash] auth bundle for the k8s authentication logic.
-      def make_k8s_auth_bundle
-        case run_opts.k8s_auth_type
-        when "kube-config"
-          Kerbi::Utils::K8sAuth.kube_config_bundle(
-            path: run_opts.kube_config_path,
-            name: run_opts.kube_context_name
-          )
-        when "basic"
-          Kerbi::Utils::K8sAuth.basic_auth_bundle(
-            username: run_opts.k8s_auth_username,
-            password: run_opts.k8s_auth_password
-          )
-        when "token"
-          Kerbi::Utils::K8sAuth.token_auth_bundle(
-            bearer_token: run_opts.k8s_auth_token,
-            )
-        when "in-cluster"
-          Kerbi::Utils::K8sAuth.in_cluster_auth_bundle
         else
-          raise "Bad k8s connect type '#{run_opts.k8s_auth_type}'"
+          raise Kerbi::UnsupportedBackendError
         end
       end
     end