kubes 0.1.0 → 0.2.0

data/lib/kubes/compiler/decorator/resources/container/mapping.rb

@@ -0,0 +1,28 @@
+class Kubes::Compiler::Decorator::Resources::Container
+  # Nice to group the mapping logic in ones spot, making a pattern of this is not worth it.
+  module Mapping
+    def deployment_keys
+      @containers_key = 'spec.template.spec.containers'
+      @volumes_key = 'spec.template.spec.volumes'
+    end
+
+    def pod_keys
+      @containers_key = 'spec.containers'
+      @volumes_key = 'spec.volumes'
+    end
+
+    def configMaps_fields
+      @envFrom_field = 'configMapRef'
+      @valueFrom_field = 'configMapKeyRef'
+      @volume_field = 'configMap'
+      @volume_field_name = 'name'
+    end
+
+    def secrets_fields
+      @envFrom_field = 'secretRef'
+      @valueFrom_field = 'secretKeyRef'
+      @volume_field = 'secret'
+      @volume_field_name = 'secretName'
+    end
+  end
+end

data/lib/kubes/compiler/decorator/resources/deployment.rb

@@ -0,0 +1,10 @@
+module Kubes::Compiler::Decorator::Resources
+  class Deployment < Base
+    def perform
+      container = Container.new(@data, kind: "Deployment", fields_for: "Secret")
+      @data = container.run
+      container = Container.new(@data, kind: "Deployment", fields_for: "ConfigMap")
+      @data = container.run
+    end
+  end
+end

data/lib/kubes/compiler/decorator/resources/pod.rb

@@ -0,0 +1,10 @@
+module Kubes::Compiler::Decorator::Resources
+  class Pod < Base
+    def perform
+      container = Container.new(@data, kind: "Pod", fields_for: "Secret")
+      @data = container.run
+      container = Container.new(@data, kind: "Pod", fields_for: "ConfigMap")
+      @data = container.run
+    end
+  end
+end

data/lib/kubes/compiler/decorator/resources/secret.rb

@@ -0,0 +1,23 @@
+require 'digest'
+
+module Kubes::Compiler::Decorator::Resources
+  class Secret < Base
+    include Kubes::Compiler::Util::YamlDump
+
+    def perform
+      # 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
+
+      md5 = md5(@data)
+      @data['metadata']['name'] = "#{name}-#{md5}"
+      Kubes::Compiler::Decorator.store(name, md5)
+      @data
+    end
+
+    def md5(data)
+      content = yaml_dump(data)
+      Digest::MD5.hexdigest(content)[0..9]
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Kubes::Compiler::Decorator
+  class Write < Base
+    def process(item)
+      case item['kind']
+      when "Deployment"
+        Resources::Deployment.new(item).run
+      when "Pod"
+        Resources::Pod.new(item).run
+      else
+        item # pass through
+      end
+    end
+  end
+end

data/lib/kubes/compiler/dsl/core/base.rb

@@ -0,0 +1,27 @@
+module Kubes::Compiler::Dsl::Core
+  class Base
+    extend Fields
+    include DslEvaluator
+    include Helpers
+    include Kubes::Compiler::Layering
+
+    def initialize(options={})
+      @options = options
+      @name = options[:name]
+      @path = options[:path]
+    end
+
+    def run
+      evaluate_files(pre_layers)
+      evaluate_file(@path) # main resource definition
+      evaluate_files(post_layers)
+      result if respond_to?(:result) # block form doesnt have result
+    end
+
+    def evaluate_files(paths)
+      paths.each do |path|
+        evaluate_file(path)
+      end
+    end
+  end
+end

data/lib/kubes/compiler/dsl/core/blocks.rb

@@ -0,0 +1,55 @@
+module Kubes::Compiler::Dsl::Core
+  class Blocks < Base
+    attr_reader :results
+    def run
+      @results = {} # Hash key is the name of resource, using it so we can keep a map to handle layering
+      @block_form = true # pluralizes the layer names
+      super # handles layering and evaluating the main DSL file
+      self
+    end
+
+    def syntax_instance(meth, name)
+      lookup = lookup_key(meth, name)
+      klass = "Kubes::Compiler::Dsl::Syntax::#{meth.camelize}".constantize
+      syntax = self.class.syntax_instances[lookup]
+      return syntax if syntax
+
+      syntax = klass.new(@options.merge(name: name))
+      syntax.kind_from_block = meth.camelize
+      self.class.syntax_instances[lookup] = syntax
+    end
+
+    def lookup_key(meth, name)
+      [meth, name].join('-')
+    end
+
+    class << self
+      def discovered_methods
+        syntax = File.expand_path("../syntax", __dir__)
+        expr = "#{syntax}/*.rb"
+        Dir.glob(expr).map do |path|
+          File.basename(path).sub('.rb','')
+        end
+      end
+
+      def block_method(meth)
+        meth = meth.to_s
+        define_method meth do |name, &block|
+          syntax = syntax_instance(meth, name)
+          syntax.instance_eval(&block) if block
+          lookup = lookup_key(meth, name)
+          @results[lookup] = syntax.result
+        end
+      end
+
+      @@syntax_instances = {}
+      def syntax_instances
+        @@syntax_instances
+      end
+    end
+
+    discovered_methods.each do |meth|
+      block_method meth
+    end
+  end
+end

data/lib/kubes/compiler/dsl/core/fields.rb

@@ -0,0 +1,78 @@
+module Kubes::Compiler::Dsl::Core
+  module Fields
+    # Defines field methods. Example:
+    #
+    #    field :spec
+    #
+    # Results in:
+    #
+    #    def spec(value=nil)
+    #      value.nil? ? spec_reader : spec_writer(value)
+    #    end
+    #
+    #    def spec_reader
+    #      default = default_spec if respond_to?(:default_spec)
+    #      @spec || default
+    #    end
+    #
+    #    def spec_writer(value)
+    #      case type # captured by closure. IE: labels:hash => type = hash
+    #      when 'hash'
+    #        spec_writer_hash(value)
+    #      else
+    #        @spec = value
+    #      end
+    #    end
+    #
+    #    def spec_writer_hash(value)
+    #      mode = value.delete(:_mode)
+    #      @spec = {} if mode == "reset"
+    #      @spec ||= {}
+    #      @spec.deeper_merge!(value)
+    #    end
+    #
+    def field(name)
+      name, type = name.to_s.split(':')
+      type ||= 'string'
+
+      reader = "#{name}_reader"
+      writer = "#{name}_writer"
+      ivar = "@#{name}"
+      writer_hash = "#{name}_writer_hash"
+
+      define_method(name) do |value=nil|
+        value.nil? ? send(reader) : send(writer, value)
+      end
+
+      define_method(reader) do
+        default_meth = "default_#{name}" # IE: default_spec, default_apiVersion etc
+        default = send(default_meth) if respond_to?(default_meth.to_sym)
+        instance_variable_get(ivar) || default
+      end
+
+      define_method(writer) do |value|
+        case type
+        when 'hash'
+          send(writer_hash, value)
+        else # string, object, etc
+          instance_variable_set(ivar, value)
+        end
+      end
+
+      define_method(writer_hash) do |value|
+        mode = value.delete(:_mode) # special treatment
+        result = instance_variable_get(ivar)
+        result = {} if mode == "reset" # allow user to override with mode: reset option
+        result ||= {} # maintain value for layering
+        result.deeper_merge!(value)
+        instance_variable_set(ivar, result)
+      end
+    end
+
+    def fields(*names)
+      names.each do |name|
+        field(name)
+      end
+    end
+  end
+end

data/lib/kubes/compiler/dsl/core/files.rb

@@ -0,0 +1,28 @@
+module Kubes::Compiler::Dsl::Core
+  module Files
+    def files(*list)
+      dir = current_dir
+      list.each do |file|
+        path = "#{dir}/#{file}"
+        load_data_from_file(path)
+      end
+    end
+
+    def load_data_from_file(path)
+      parser = Kubes::Compiler::Dsl::Core::Parser.new(path)
+      items = parser.parse
+      items.transform_values! { |v| base64(v) } if secret_class?
+      data(items)
+    end
+
+    def secret_class?
+      self.class == Kubes::Compiler::Dsl::Syntax::Secret
+    end
+
+    def current_dir
+      resources_line = caller.find { |l| l.include?('.kubes/resources') }
+      path = resources_line.split(':').first
+      File.dirname(path) # IE: /full/path/.kubes/resources
+    end
+  end
+end

data/lib/kubes/compiler/dsl/core/helpers.rb

@@ -0,0 +1,4 @@
+module Kubes::Compiler::Dsl::Core
+  module Helpers
+  end
+end

data/lib/kubes/compiler/dsl/core/parser.rb

@@ -0,0 +1,43 @@
+module Kubes::Compiler::Dsl::Core
+  class Parser
+    def initialize(path)
+      @path = path
+    end
+
+    def parse
+      contents = IO.read(@path)
+      lines = parse_contents(contents)
+
+      # First use a Hash structure so that overlay env files will override
+      # the base param file.
+      data = {}
+      lines.each do |line|
+        key,value = line.strip.split("=").map {|x| x.strip}
+        value = remove_surrounding_quotes(value)
+        data[key] = value
+      end
+      data
+    end
+
+    def parse_contents(contents)
+      lines = contents.split("\n")
+      # remove comment at the end of the line
+      lines.map! { |l| l.sub(/#.*/,'').strip }
+      # filter out commented lines
+      lines = lines.reject { |l| l =~ /(^|\s)#/i }
+      # filter out empty lines
+      lines = lines.reject { |l| l.strip.empty? }
+      lines
+    end
+
+    def remove_surrounding_quotes(s)
+      if s =~ /^"/ && s =~ /"$/
+        s.sub(/^["]/, '').gsub(/["]$/,'') # remove surrounding double quotes
+      elsif s =~ /^'/ && s =~ /'$/
+        s.sub(/^[']/, '').gsub(/[']$/,'') # remove surrounding single quotes
+      else
+        s
+      end
+    end
+  end
+end

data/lib/kubes/compiler/dsl/syntax/backend_config.rb

@@ -0,0 +1,10 @@
+module Kubes::Compiler::Dsl::Syntax
+  class BackendConfig < Resource
+    fields :domain,
+           :domains
+
+    def default_apiVersion
+      "cloud.google.com/v1"
+    end
+  end
+end

data/lib/kubes/compiler/dsl/syntax/cluster_role.rb

@@ -0,0 +1,4 @@
+module Kubes::Compiler::Dsl::Syntax
+  class ClusterRole < Role
+  end
+end

data/lib/kubes/compiler/dsl/syntax/cluster_role_binding.rb

@@ -0,0 +1,4 @@
+module Kubes::Compiler::Dsl::Syntax
+  class ClusterRoleBinding < RoleBinding
+  end
+end

data/lib/kubes/compiler/dsl/syntax/config_map.rb

@@ -0,0 +1,20 @@
+module Kubes::Compiler::Dsl::Syntax
+  class ConfigMap < Resource
+    include Kubes::Compiler::Dsl::Core::Files
+
+    # kubectl explain secret
+    fields "data:hash",        # <map[string]string>
+           "binaryData:hash"   # <map[string]string>
+
+    def default_apiVersion
+      "v1"
+    end
+
+    def default_result_append
+      {
+        data: data,
+        binaryData: binaryData,
+      }
+    end
+  end
+end

data/lib/kubes/compiler/dsl/syntax/daemon_set.rb

@@ -0,0 +1,23 @@
+module Kubes::Compiler::Dsl::Syntax
+  class DaemonSet < Resource
+    fields :minReadySeconds,       # <integer>
+           :revisionHistoryLimit,  # <integer>
+           :selector,              # <Object> -required-
+           :template,              # <Object> -required-
+           :updateStrategy         # <Object>
+
+    def default_apiVersion
+      "apps/v1"
+    end
+
+    def default_spec
+      {
+        minReadySeconds: minReadySeconds,
+        revisionHistoryLimit: revisionHistoryLimit,
+        selector: selector,
+        template: template,
+        updateStrategy: updateStrategy,
+      }
+    end
+  end
+end

data/lib/kubes/compiler/dsl/syntax/deployment.rb

@@ -0,0 +1,163 @@
+module Kubes::Compiler::Dsl::Syntax
+  class Deployment < Resource
+    fields :container,          # <Object>
+           :containers,         # <[]Object>
+           "matchLabels:hash",  # <map[string]string>
+           :sidecar,            # <Object>
+           :templateMetadata,   # <Object>
+           :templateSpec        # <Object>
+
+    # kubectl explain deployment.spec
+    fields :minReadySeconds,         # <integer>
+           :paused,                  # <boolean>
+           :progressDeadlineSeconds, # <integer>
+           :replicas,                # <integer>
+           :revisionHistoryLimit,    # <integer>
+           :selector,                # <Object> -required-
+           :strategy,                # <Object>
+           :template                 # <Object> -required-
+
+    # kubectl explain deployment.spec.strategy.rollingUpdate
+    fields :maxSurge,         # <string>
+           :maxUnavailable    # <string>
+
+    # kubectl explain deployment.spec.template.spec.containers
+    fields :args,                     # <[]string>
+           :command,                  # <[]string>
+           :env,                      # <[]Object>
+           :envFrom,                  # <[]Object>
+           :image,                    # <string>
+           :imagePullPolicy,          # <string>
+           :lifecycle,                # <Object>
+           :livenessProbe,            # <Object>
+           :containerName,            # <string> -required- (originally called name)
+           :ports,                    # <[]Object>
+           :readinessProbe,           # <Object>
+           :resources,                # <Object>
+           :securityContext,          # <Object>
+           :startupProbe,             # <Object>
+           :stdin,                    # <boolean>
+           :stdinOnce,                # <boolean>
+           :terminationMessagePath,   # <string>
+           :terminationMessagePolicy, # <string>
+           :tty,                      # <boolean>
+           :volumeDevices,            # <[]Object>
+           :volumeMounts,             # <[]Object>
+           :workingDir                # <string>
+
+    # kubectl explain deployment.spec.template.spec.containers.ports
+   fields :containerPort, # <integer> -required-
+          :hostIP,        # <string>
+          :hostPort,      # <integer>
+          :portName,      # <string> (originally called name)
+          :protocol       # <string>
+
+    def default_apiVersion
+      "apps/v1"
+    end
+
+    def default_spec
+      {
+        minReadySeconds: minReadySeconds,
+        paused: paused,
+        progressDeadlineSeconds: progressDeadlineSeconds,
+        replicas: replicas,
+        revisionHistoryLimit: revisionHistoryLimit,
+        selector: selector,
+        strategy: strategy,
+        template: template,
+      }
+    end
+
+    def default_replicas
+      1
+    end
+
+    def default_selector
+      { matchLabels: matchLabels }
+    end
+
+    def default_matchLabels
+      labels
+    end
+
+    def default_strategy
+      {
+        rollingUpdate: {
+          maxSurge: maxSurge,
+          maxUnavailable: maxUnavailable,
+        },
+        type: "RollingUpdate",
+      }
+    end
+
+    def default_maxSurge
+      25
+    end
+
+    def default_maxUnavailable
+      25
+    end
+
+    def default_template
+      {
+        metadata: templateMetadata,
+        spec: templateSpec,
+      }
+    end
+
+    def default_templateSpec
+      { containers: containers }
+    end
+
+    def default_templateMetadata
+      { labels: labels }
+    end
+
+    def default_containers
+      [container, sidecar].compact
+    end
+
+    def default_container
+      {
+        args: args,
+        command: command,
+        env: env,
+        envFrom: envFrom,
+        image: image,
+        imagePullPolicy: imagePullPolicy,
+        lifecycle: lifecycle,
+        livenessProbe: livenessProbe,
+        name: containerName || name,
+        ports: ports,
+        readinessProbe: readinessProbe,
+        resources: resources,
+        securityContext: securityContext,
+        startupProbe: startupProbe,
+        stdin: stdin,
+        stdinOnce: stdinOnce,
+        terminationMessagePath: terminationMessagePath,
+        terminationMessagePolicy: terminationMessagePolicy,
+        tty: tty,
+        volumeDevices: volumeDevices,
+        volumeMounts: volumeMounts,
+        workingDir: workingDir,
+      }
+    end
+
+    def default_ports
+      [
+        containerPort: containerPort,
+        hostIP: hostIP,
+        hostPort: hostPort,
+        name: portName,
+        protocol: protocol,
+      ]
+    end
+
+    # Override command instead of default_command since we want to change a String to an Array
+    def command_reader
+      @command.is_a?(String) ? @command.split(' ') : @command # else assume Array
+    end
+  end
+end