kubes 0.3.3 → 0.4.2

data/lib/kubes/cli/logs.rb

@@ -1,20 +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]
-      c = container(deployment)
-      sh("kubectl logs deployment/#{name}#{follow} -n #{ns} -c #{c}")
+      container = container(deployment)
+      c = " -c #{container}" if container
+      "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
 
@@ -8,13 +9,16 @@ module Kubes
     end
 
     def run
-      results = resources.map do |path|
-        strategy = Strategy.new(@options.merge(path: path))
-        strategy.compile
-      end.compact
+      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?
@@ -49,7 +53,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

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

@@ -0,0 +1,12 @@
+module Kubes::Compiler::Decorator
+  class Pre < Base
+    def process
+      case @data['kind']
+      when "ConfigMap", "Secret"
+        Hashable.new(@data).store
+      else
+        @data # passthrough
+      end
+    end
+  end
+end

data/lib/kubes/compiler/shared/helpers.rb

@@ -24,8 +24,13 @@ module Kubes::Compiler::Shared
       extra&.strip&.empty? ? nil : extra # if blank string then also return nil
     end
 
-    def base64(v)
-      Base64.encode64(v).strip
+    def encode64(v)
+      Base64.strict_encode64(v).strip
+    end
+    alias_method :base64, :encode64
+
+    def decode64(v)
+      Base64.strict_decode64(v)
     end
   end
 end

data/lib/kubes/compiler/strategy.rb

@@ -11,7 +11,7 @@ class Kubes::Compiler
 
       strategy = klass.new(@options.merge(path: @path)) # Dsl or Erb
       result = strategy.run
-      result.compile_decorate! # compile phase decoration
+      result.decorate!(:pre) # compile pre phase decoration
       result
     end
 
@@ -19,7 +19,7 @@ class Kubes::Compiler
       ext = File.extname(@path)
       case ext
       when '.rb'   then Dsl
-      when '.yaml' then Erb
+      when '.yaml','.yml' then Erb
       else Pass
       end
     end

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

@@ -7,7 +7,7 @@ class Kubes::Compiler::Strategy
       @path = options[:path]
 
       @filename = @path.sub(%r{.*\.kubes/resources/},'') # IE: web/deployment.rb or web/deployment.yaml
-      @save_file = @filename.sub('.rb','.yaml')
+      @save_file = @filename.sub('.yml','.yaml').sub('.rb','.yaml')
     end
   end
 end

data/lib/kubes/compiler/strategy/result.rb

@@ -11,12 +11,10 @@ class Kubes::Compiler::Strategy
       @data.respond_to?(:read)
     end
 
-    def compile_decorate!
-      @data = Kubes::Compiler::Decorator::Compile.new(@data).result
-    end
-
-    def write_decorate!
-      @data = Kubes::Compiler::Decorator::Write.new(@data).result
+    # decorate(:pre) or decorate(:post)
+    def decorate!(phase)
+      klass = "Kubes::Compiler::Decorator::#{phase.to_s.camelize}".constantize
+      @data = klass.new(@data).result
     end
 
     def content