kubes 0.3.5 → 0.4.0

data/lib/kubes/cli/exec.rb

@@ -1,15 +1,49 @@
 class Kubes::CLI
   class Exec < Base
+    extend Memoist
+    include Kubes::Logging
     include Kubes::Util::Sh
 
     def run
       compile
-      metadata = Kubes::Kubectl::Fetch::Deployment.new(@options).metadata
+      pod = find_pod
 
+      unless pod
+        logger.info <<~EOL
+          Unable to find a pod to exec into. This means there was no deployment found.
+          You can also try using the -p option and specifying enough of the pod name. Example:
+
+              kubes exec -p web
+
+        EOL
+        exit 1
+      end
+
+      container = " -c #{@options[:container]}" unless @options[:container].nil?
+      cmd = @options[:cmd].empty? ? "bash" : @options[:cmd].join(' ')
+      sh("kubectl exec #{ns} -ti #{pod}#{container} -- #{cmd}")
+    end
+
+    def find_pod
+      pod_name || deployment_pod
+    end
+
+    def ns
+      "-n #{metadata['namespace']}" if metadata
+    end
+
+    def metadata
+      deployment = Kubes::Kubectl::Fetch::Deployment.new(@options)
+      deployment.metadata if deployment.found
+    end
+    memoize :metadata
+
+    def deployment_pod
+      return unless metadata
       labels = metadata['labels'].map { |k,v| "#{k}=#{v}" }.join(',')
       ns = metadata['namespace']
 
-      resp = capture("kubectl get pod -l #{labels} -n #{ns} -o json")
+      resp = sh_capture("kubectl get pod -l #{labels} -n #{ns} -o json")
       data = JSON.load(resp)
       pod = latest_pod(data['items'])
 
@@ -18,10 +52,7 @@ class Kubes::CLI
         exit 1
       end
 
-      name = pod['metadata']['name']
-      container = " -c #{@options[:container]}" unless @options[:container].nil?
-      cmd = @options[:cmd].empty? ? "bash" : @options[:cmd].join(' ')
-      sh("kubectl exec -n #{ns} -ti #{name}#{container} -- #{cmd}")
+      pod['metadata']['name']
     end
 
     # get latest running pod

data/lib/kubes/cli/get.rb

@@ -2,7 +2,7 @@ class Kubes::CLI
   class Get < Base
     def run
       compile
-      Kubes::Kubectl.run(:get, @options)
+      Kubes::Kubectl.run(:get, @options.merge(exit_on_fail: false))
       return unless @options[:show_pods]
       pods = Kubes::Kubectl::Fetch::Pods.new(@options)
       pods.show

data/lib/kubes/cli/logs.rb

@@ -1,21 +1,45 @@
 class Kubes::CLI
   class Logs < Base
+    include Kubes::Logging
     include Kubes::Util::Sh
 
     def run
       compile
+      sh("kubectl logs #{args}")
+    end
+
+  private
+    def args
+      args = pod_name || deployment_args
+
+      unless args
+        logger.info <<~EOL
+          Unable to find a pod to show logs for. This means there was no deployment found.
+          You can also try using the -p option and specifying enough of the pod name. Example:
+
+              kubes logs -p web
+
+        EOL
+        exit 1
+      end
+
+      follow = " -f" if @options[:follow]
+      "#{args}#{follow}"
+    end
+
+    def deployment_args
       deployment = Kubes::Kubectl::Fetch::Deployment.new(@options)
       metadata = deployment.metadata
+      return unless metadata
+
       name = metadata['name']
       ns = metadata['namespace']
 
-      follow = " -f" if @options[:follow]
       container = container(deployment)
       c = " -c #{container}" if container
-      sh("kubectl logs deployment/#{name}#{follow} -n #{ns}#{c}")
+      "deployment/#{name} -n #{ns}#{c}"
     end
 
-  private
     def container(deployment)
       container = @options[:container]
       return container if container

data/lib/kubes/cli/prune.rb

@@ -0,0 +1,95 @@
+class Kubes::CLI
+  class Prune < Base
+    KINDS = %w[ConfigMap Secret]
+    extend Memoist
+    include Kubes::Util::Sure
+
+    def run
+      return unless anything_to_prune?
+      logger.info "Pruning old resources: #{KINDS.join(', ')}"
+
+      perform(preview: true) unless @options[:yes]
+      sure?("This will prune/delete resources. Are you sure?")
+      perform(preview: false)
+    end
+
+    def fetcher
+      Kubes::Kubectl::Fetch::Base.new(@options)
+    end
+    memoize :fetcher
+
+    def namespace
+      fetcher.namespace
+    end
+
+    def anything_to_prune?
+      items = []
+      return unless namespace
+
+      with_old_items { |i| items << i }
+      if items.empty?
+        logger.info("There are no old resources that need pruning.") unless @options[:quiet]
+      end
+      !items.empty?
+    end
+
+    def perform(preview:)
+      with_old_items do |item|
+        prune(item, preview)
+      end
+    end
+
+    def with_old_items
+      items = get_all_items
+      items.each do |i|
+        next unless old?(i)
+        yield(i)
+      end
+    end
+
+    def old?(item)
+      name = item['metadata']['name']
+      kind = item['kind']
+      built = built_kinds[kind] || [] # IE: {"demo-secret"=>"ebd93b58dd"}
+      built.each do |original_name,hash|
+        return false unless name.include?(original_name)
+        current = "#{original_name}-#{hash}"
+        return false if name == current
+        # Spec cover the tricky regexp logic
+        regexp = Regexp.new("#{original_name}-\\w{10}$") # IE: # demo-secret-\w{10}$
+        return true if name.match(regexp)
+      end
+
+      false
+    end
+
+    def get_all_items
+      secrets = capture_items('secret')
+      config_maps = capture_items('configmap')
+      secrets + config_maps
+    end
+
+    def capture_items(kind)
+      data = Kubes::Kubectl.capture("get #{kind} -o json -n #{namespace}")
+      data['items'] || []
+    end
+
+    # IE: {"Secret"=>{"demo-secret"=>"ebd93b58dd"}}
+    def built_kinds
+      compile # compile so built kinds are in memory
+      Kubes::Compiler::Decorator::Hashable::Storage.md5s
+    end
+    memoize :built_kinds
+
+    def prune(item, preview=false)
+      kind = item['kind']
+      name = item['metadata']['name']
+      args = "delete #{kind} #{name} -n #{namespace}"
+      if preview
+        logger.info "    kubectl #{args}"
+      else
+        Kubes::Kubectl.execute(args)
+      end
+    end
+  end
+end

data/lib/kubes/compiler.rb

@@ -1,5 +1,6 @@
 module Kubes
   class Compiler
+    include Kubes::Hooks::Concern
     include Kubes::Logging
     include Kubes::Util::Consider
 
@@ -7,17 +8,27 @@ module Kubes
       @options = options
     end
 
+    # Separate command like prune can call compile. Apply also calls Prune.
+    # Instead of moving Compile out of Prune, will use this class variable.
+    # In case we have other cases where compile is called in another area.
+    # We only want compiled to be called once so hooks only fire once.
+    @@compiled = false
     def run
-      results = resources.map do |path|
-        strategy = Strategy.new(@options.merge(path: path))
-        strategy.compile
-      end.compact
+      return if @@compiled
+      Kubes.config # trigger config load. So can set ENV['VAR'] in config/envs/dev.rb etc
+      run_hooks("kubes.rb", name: "compile") do
+        results = resources.map do |path|
+          strategy = Strategy.new(@options.merge(path: path))
+          strategy.compile
+        end.compact
 
-      results.each do |result|
-        write(result)
+        results.each do |result|
+          write(result)
+        end
       end
 
       puts "Compiled  .kubes/resources files to .kubes/output" if show_compiled_message?
+      @@compiled = true
     end
 
     def resources
@@ -49,7 +60,7 @@ module Kubes
     end
 
     def write(result)
-      result.write_decorate!
+      result.decorate!(:post)
       filename, content = result.filename, result.content
       dest = "#{Kubes.root}/.kubes/output/#{filename}"
 

data/lib/kubes/compiler/decorator/base.rb

@@ -1,14 +1,20 @@
 module Kubes::Compiler::Decorator
   class Base
+    attr_reader :data
     def initialize(data)
       @data = data
     end
 
+    def run
+      return @data unless Kubes.config.suffix_hash
+      process
+    end
+
     def result
       if @data.is_a?(Kubes::Compiler::Dsl::Core::Blocks)
         @data.results.each { |k,v| process(v) } # returns nil
       else
-        process(@data) # returns Hash
+        process # processes and returns @data
       end
       @data # important to return @data so we keep the original @data structure: Blocks or Hash
     end

data/lib/kubes/compiler/decorator/{resources/secret.rb → hashable.rb}

@@ -1,17 +1,18 @@
 require 'digest'
 
-module Kubes::Compiler::Decorator::Resources
-  class Secret < Base
+module Kubes::Compiler::Decorator
+  class Hashable < Base
     include Kubes::Compiler::Util::YamlDump
 
-    def perform
+    def store
       # even though name is required, will allow logic to get the kubectl apply and kubectl to surface the required name error
       name = @data.dig('metadata','name')
       return @data unless name
 
+      # puts "name #{name}" # TODO: scope Kind so Secret and ConfigMap can have the same name...
       md5 = md5(@data)
       @data['metadata']['name'] = "#{name}-#{md5}"
-      Kubes::Compiler::Decorator.store(name, md5)
+      Storage.store(@data['kind'], name, md5)
       @data
     end
 

data/lib/kubes/compiler/decorator/hashable/field.rb

@@ -0,0 +1,53 @@
+class Kubes::Compiler::Decorator::Hashable
+  class Field
+    # item is full wrapper structure
+    #
+    #     secretRef:  <--- wrapper
+    #       name: demo-secret
+    #
+    def initialize(item)
+      @item = item
+    end
+
+    def hashable?
+      x = @item.keys & map.keys
+      !x.empty?
+    end
+
+    def kind
+      wrapper =~ /configMap/ ? "ConfigMap" : "Secret"
+    end
+
+    # The key of the hashable value.
+    #
+    #     envFrom:
+    #     - secretRef:
+    #         name: demo-secret    <--- wrapper is 'name'
+    #
+    def key
+      map[wrapper]
+    end
+
+    # The wrapper field is nested right above the item with the hashable value.
+    #
+    #     envFrom:
+    #     - secretRef:  <--- wrapper
+    #         name: demo-secret
+    #
+    def wrapper
+      @item.keys.first
+    end
+
+    # wrapper element to key that stores the hashable value
+    def map
+      {
+        'configMapRef' => 'name',
+        'configMapKeyRef' => 'name',
+        'configMap' => 'name',
+        'secretRef' => 'name',
+        'secretKeyRef' => 'name',
+        'secret' => 'secretName',
+      }
+    end
+  end
+end

data/lib/kubes/compiler/decorator/hashable/storage.rb

@@ -0,0 +1,19 @@
+class Kubes::Compiler::Decorator::Hashable
+  module Storage
+    @@md5s = {}
+    def store(kind, name, md5)
+      @@md5s[kind] ||= {}
+      @@md5s[kind][name] = md5
+    end
+
+    def fetch(kind, name)
+      @@md5s[kind] ||= {}
+      @@md5s[kind][name]
+    end
+
+    def md5s
+      @@md5s
+    end
+    extend self
+  end
+end

data/lib/kubes/compiler/decorator/post.rb

@@ -0,0 +1,77 @@
+module Kubes::Compiler::Decorator
+  class Post < Base
+    def process
+      add_hash(@data)
+      clean_namespace
+      @data
+    end
+
+    def clean_namespace
+      return unless @data['kind'] == 'Namespace'
+      @data['metadata'].delete('namespace')
+      @data
+    end
+
+    def add_hash(item, options={})
+      # hashable set from previous stack call
+      if options[:hashable_field] && item.is_a?(Hash)
+        field = options[:hashable_field]
+        value_without_md5 = item[field.key]
+        @reset_hashable_field = true unless value_without_md5
+        if field.hashable? && value_without_md5
+          md5 = Hashable::Storage.fetch(field.kind, value_without_md5)
+          v = [value_without_md5, md5].compact.join('-')
+          item[field.key] = v
+        end
+      end
+
+      options[:hashable_field] ||= hashable_field(item) # set for next stack call
+      # Pretty tricky case. Given:
+      #
+      #     envFrom:
+      #     - secretRef:
+      #         name: demo-secret
+      #     - configMapRef:
+      #         name: demo-config-map
+      #
+      # Need to reset the stored hashable_field in the call stack.
+      # Else the field.kind is cached and the md5 look is incorrect
+      # The spec/fixtures/decorators/deployment/both/envFrom.yaml fixture covers this.
+      if @reset_hashable_field
+        options[:hashable_field] = hashable_field(item)
+        @reset_hashable_field = false
+      end
+      case item
+      when Array, Hash
+        item.each { |i| add_hash(i, options) }
+      end
+      item
+    end
+
+    # Returns the nested key name that will be hashable. Examples:
+    #
+    #     1. envFrom example
+    #     envFrom:
+    #     - secretRef:
+    #         name: demo-secret
+    #
+    #     2. valueFrom example
+    #     valueFrom:
+    #       secretKeyRef:
+    #         name: demo-secret
+    #         key: password
+    #
+    #     3. volumes example
+    #     volumes:
+    #     - secret:
+    #         secretName: demo-secret
+    #
+    # This is useful to capture for the next level of the stack call
+    #
+    def hashable_field(item)
+      return false unless item.is_a?(Hash)
+      field = Hashable::Field.new(item)
+      field if field.hashable?
+    end
+  end
+end