kubes 0.3.5 → 0.4.4

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

@@ -1,13 +1,12 @@
 class Kubes::Compiler::Strategy
   class Base
     include Kubes::Logging
+    include Kubes::Compiler::Util::SaveFile
 
     def initialize(options={})
       @options = options
       @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 = save_file(@path)
     end
   end
 end

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

@@ -17,7 +17,7 @@ class Kubes::Compiler::Strategy
     end
 
     def syntax_class
-      klass_name = normalize_kind(@filename)
+      klass_name = normalize_kind(@save_file)
       "Kubes::Compiler::Dsl::Syntax::#{klass_name}".constantize
     rescue NameError
       logger.debug "Using default resource for: #{klass_name}"
@@ -25,7 +25,7 @@ class Kubes::Compiler::Strategy
     end
 
     def block_form?
-      type = extract_type(@filename)
+      type = extract_type(@save_file)
       type.pluralize == type
     end
   end

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

@@ -32,11 +32,18 @@ class Kubes::Compiler::Strategy
     def render_result(path)
       if File.exist?(path)
         yaml = RenderMePretty.result(path, context: self)
-        result = YAML.load(yaml)
+        result = yaml_load(path, yaml)
         result.is_a?(Hash) ? result : {} # in case of blank yaml doc a Boolean false is returned
       else
         {}
       end
     end
+
+    def yaml_load(path, yaml)
+      YAML.load(yaml)
+    rescue Psych::SyntaxError
+      YamlError.new(path, yaml).show
+      exit 1
+    end
   end
 end

data/lib/kubes/compiler/strategy/erb/yaml_error.rb

@@ -0,0 +1,60 @@
+class Kubes::Compiler::Strategy::Erb
+  class YamlError
+    include Kubes::Compiler::Util::SaveFile
+
+    def initialize(path, rendered_yaml)
+      @path, @rendered_yaml = path, rendered_yaml
+    end
+
+    def show
+      FileUtils.mkdir_p(File.dirname(dest))
+      IO.write(dest, @rendered_yaml)
+      show_error(dest)
+    end
+
+    def dest
+      save_file = save_file(@path)
+      "#{Kubes.root}/.kubes/output/#{save_file}"
+    end
+
+    def show_error(path)
+      text = IO.read(path)
+      begin
+        YAML.load(text)
+      rescue Psych::SyntaxError => e
+        handle_yaml_syntax_error(e, path)
+      end
+    end
+
+    def handle_yaml_syntax_error(e, path)
+      io = StringIO.new
+      io.puts "Invalid yaml. Output written for debugging: #{path}".color(:red)
+      io.puts "ERROR: #{e.message}".color(:red)
+
+      # Grab line info.  Example error:
+      #   ERROR: (<unknown>): could not find expected ':' while scanning a simple key at line 2 column 1
+      md = e.message.match(/at line (\d+) column (\d+)/)
+      line = md[1].to_i
+
+      lines = IO.read(path).split("\n")
+      context = 5 # lines of context
+      top, bottom = [line-context-1, 0].max, line+context-1
+      spacing = lines.size.to_s.size
+      lines[top..bottom].each_with_index do |line_content, index|
+        line_number = top+index+1
+        if line_number == line
+          io.printf("%#{spacing}d %s\n".color(:red), line_number, line_content)
+        else
+          io.printf("%#{spacing}d %s\n", line_number, line_content)
+        end
+      end
+
+      if ENV['KUBES_TEST']
+        io.string
+      else
+        puts io.string
+        exit 1
+      end
+    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/compiler/util/normalize.rb

@@ -5,7 +5,7 @@ module Kubes::Compiler::Util
     end
 
     def extract_type(path)
-      File.basename(path).sub('.rb','').sub(/-.*/,'')
+      File.basename(path).sub('.yaml','').sub('.yml','').sub('.rb','').sub(/-.*/,'')
     end
   end
 end

data/lib/kubes/compiler/util/save_file.rb

@@ -0,0 +1,8 @@
+module Kubes::Compiler::Util
+  module SaveFile
+    def save_file(path)
+      filename = path.sub(%r{.*\.kubes/resources/},'') # IE: web/deployment.rb or web/deployment.yaml
+      filename.sub('.yml','.yaml').sub('.rb','.yaml')
+    end
+  end
+end

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