kubes 0.3.2 → 0.4.1

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/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

data/lib/kubes/config.rb

@@ -11,31 +11,36 @@ module Kubes
     def defaults
       config = ActiveSupport::OrderedOptions.new
 
-      config.state = ActiveSupport::OrderedOptions.new
-      config.state.docker_image_path = "#{Kubes.root}/.kubes/state/docker_image.txt"
+      config.auto_prune = true
 
-      config.logger = Logger.new($stdout)
-      config.logger.level = ENV['KUBES_LOG_LEVEL'] || :info
+      config.builder = "docker" # IE: docker or gcloud
 
       # Auto-switching options
       config.kubectl = ActiveSupport::OrderedOptions.new
       config.kubectl.context = nil
       config.kubectl.context_keep = true # after switching context keep it
-      config.kubectl.exit_on_fail = nil # whether or not continue if the kubectl command fails
 
-      config.kubectl.exit_on_fail_for_apply  = true # whether or not continue if the kubectl apply command fails
-      config.kubectl.exit_on_fail_for_delete = false # whether or not continue if the kubectl delete command fails
-      # Note: not using config.kubectl.delete.exit_on_fail because delete a method internal to ActiveSupport::OrderedOptions
+      # whether or not continue if the kubectl command fails
+      config.kubectl.exit_on_fail = ActiveSupport::OrderedOptions.new
+      config.kubectl.exit_on_fail.apply  = true # whether or not continue if the kubectl apply command fails
+      config.kubectl.exit_on_fail.delete = false # whether or not continue if the kubectl delete command fails
+      # Note: delete is a internal method to ActiveSupport::OrderedOptions so will have to access it with ['...']
 
       config.kubectl.order = ActiveSupport::OrderedOptions.new
       config.kubectl.order.roles = role_order
       config.kubectl.order.kinds = kind_order
 
-      config.suffix_hash = true # append suffix has to ConfigMap and Secret
-
       config.repo = nil # expected to be set by .kubes/config.rb
 
-      config.builder = "docker" # IE: docker or gcloud
+      config.logger = Logger.new($stdout)
+      config.logger.level = ENV['KUBES_LOG_LEVEL'] || :info
+
+      config.skip = []
+
+      config.state = ActiveSupport::OrderedOptions.new
+      config.state.docker_image_path = "#{Kubes.root}/.kubes/state/docker_image.txt"
+
+      config.suffix_hash = true # append suffix hash to ConfigMap and Secret
 
       config
     end

data/lib/kubes/docker/strategy/build/docker.rb

@@ -3,7 +3,7 @@ module Kubes::Docker::Strategy::Build
     def perform
       params = args.flatten.join(' ')
       command = "docker build #{params}"
-      run_hooks "build" do
+      run_hooks("docker.rb", name: "build") do
         sh(command)
       end
     end

data/lib/kubes/docker/strategy/build/gcloud.rb

@@ -2,7 +2,7 @@ module Kubes::Docker::Strategy::Build
   class Gcloud < Base
     def perform
       command = "gcloud builds submit --tag #{@@image_name}"
-      run_hooks "build" do
+      run_hooks("docker.rb", name: "build") do
         sh(command)
       end
     end

data/lib/kubes/docker/strategy/image_name.rb

@@ -61,7 +61,7 @@ module Kubes::Docker::Strategy
     end
 
     def custom
-      custom = Kubes::Args::Custom.new(@name, "#{Kubes.root}/.kubes/config/docker/args.rb")
+      custom = Kubes::Args::Custom.new(@name, "#{Kubes.root}/.kubes/config/args/docker.rb")
       custom.build
       custom
     end

data/lib/kubes/docker/strategy/push/docker.rb

@@ -17,7 +17,7 @@ module Kubes::Docker::Strategy::Push
     def push
       params = args.flatten.join(' ')
       command = "docker push #{params}"
-      run_hooks "push" do
+      run_hooks("docker.rb", name: "push") do
         sh(command)
       end
     end

data/lib/kubes/docker/strategy/push/gcloud.rb

@@ -1,7 +1,7 @@
 module Kubes::Docker::Strategy::Push
   class Gcloud < Base
     def run
-      run_hooks "push" do
+      run_hooks("docker.rb", name: "push") do
         # noop, gcloud builds submit already pushes the image
       end
     end

data/lib/kubes/docker/strategy/utils.rb

@@ -4,6 +4,6 @@ module Kubes::Docker::Strategy
     include Kubes::Util::Sh
     include Kubes::Util::Time
     include Kubes::Docker::Strategy::ImageName
-    include Kubes::Docker::Strategy::Hooks
+    include Kubes::Hooks::Concern
   end
 end

data/lib/kubes/hooks/builder.rb

@@ -4,39 +4,53 @@ module Kubes::Hooks
     include Dsl
     include DslEvaluator
     include Kubes::Logging
-    include Kubes::Util::Sh
 
     attr_accessor :name
-    def initialize(name, file)
-      @name = name.to_s
-      @file = file # IE: .kubes/config/kubectl/hooks.rb
+    def initialize(dsl_file, options={})
+      @dsl_file, @options = dsl_file, options # IE: .kubes/config/hooks/kubectl.rb
+      @output_file = options[:file] # IE: .kubes/output/web/service.yaml
+      @name = options[:name].to_s
       @hooks = {before: {}, after: {}}
     end
 
     def build
-      return @hooks unless File.exist?(@file)
-      evaluate_file(@file)
+      return @hooks unless File.exist?(@dsl_file)
+      evaluate_file(@dsl_file)
       @hooks.deep_stringify_keys!
     end
     memoize :build
 
     def run_hooks
       build
-      run_hook("before")
+      run_each_hook("before")
       out = yield if block_given?
-      run_hook("after")
+      run_each_hook("after")
       out
     end
 
-    def run_hook(type)
-      execute = @hooks.dig(type, @name.to_s, "execute")
-      return unless execute
+    def run_each_hook(type)
+      hooks = @hooks.dig(type, @name.to_s) || []
+      hooks.each do |hook|
+        run_hook(type, hook)
+      end
+    end
+
+    def run_hook(type, hook)
+      return unless run?(hook)
 
-      exit_on_fail = @hooks.dig(type, @name.to_s, "exit_on_fail")
-      exit_on_fail = exit_on_fail.nil? ? true : exit_on_fail
+      command = File.basename(@dsl_file).sub('.rb','') # IE: kubes, kubectl, docker
+      id = "#{command} #{type} #{@name}"
+      on = " on: #{hook["on"]}" if hook["on"]
+      label = " label: #{hook["label"]}" if hook["label"]
+      logger.info  "Running #{id} hook.#{on}#{label}"
+      logger.debug "Hook options: #{hook}"
+      Runner.new(hook).run
+    end
 
-      logger.info "Running #{type} hook"
-      sh(execute, exit_on_fail: exit_on_fail)
+    def run?(hook)
+      return false unless hook["execute"]
+      return true  unless hook["on"]
+      @output_file.include?(hook["on"])
     end
   end
 end