kubes 0.1.0 → 0.2.4

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

@@ -0,0 +1,20 @@
+module Kubes::Compiler::Dsl::Syntax
+  class ServiceAccount < Resource
+    # kubectl explain serviceaccount
+    fields :automountServiceAccountToken, # <boolean>
+           :imagePullSecrets,             # <[]Object>
+           :secrets                       # <[]Object>
+
+    # override superclass method - no spec
+    def default_top
+      {
+        apiVersion: apiVersion,
+        kind: kind,
+        metadata: metadata,
+        automountServiceAccountToken: automountServiceAccountToken,
+        imagePullSecrets: imagePullSecrets,
+        secrets: secrets,
+      }
+    end
+  end
+end

data/lib/kubes/compiler/layering.rb

@@ -0,0 +1,39 @@
+class Kubes::Compiler
+  module Layering
+    def pre_layers
+      return [] if Kubes.kustomize?
+
+      ext = File.extname(@path)
+      kind = File.basename(@path).sub(ext,'') # IE: deployment
+      all = "all"
+      if @block_form
+        kind = kind.pluralize
+        all = all.pluralize
+      end
+      layers = [
+        "#{all}#{ext}",
+        "#{all}/#{Kubes.env}#{ext}",
+        "#{kind}#{ext}",
+        "#{kind}/#{Kubes.env}#{ext}",
+      ]
+      layers.map do |layer|
+        "#{Kubes.root}/.kubes/resources/base/#{layer}"
+      end
+    end
+
+    def post_layers
+      return [] if Kubes.kustomize?
+
+      ext = File.extname(@path)
+      kind_path = @path.sub(ext,'')
+
+      layers = [
+        "base",
+        Kubes.env.to_s
+      ]
+      layers.map do |layer|
+        "#{kind_path}/#{layer}#{ext}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require "base64"
+
+module Kubes::Compiler::Shared
+  module Helpers
+    extend Kubes::Compiler::Dsl::Core::Fields
+    fields "name"
+
+    def built_image
+      return @options[:image] if @options[:image] # override
+
+      path = Kubes.config.state.docker_image_path
+      unless File.exist?(path)
+        raise "Missing file with docker image built by kubes: #{path}. Try first running: kubes docker build"
+      end
+      IO.read(path)
+    end
+
+    def with_extra(value)
+      [value, extra].compact.join('-')
+    end
+
+    def extra
+      extra = ENV['KUBES_EXTRA']
+      extra&.strip&.empty? ? nil : extra # if blank string then also return nil
+    end
+
+    def base64(v)
+      Base64.encode64(v).strip
+    end
+  end
+end

data/lib/kubes/compiler/strategy.rb

@@ -0,0 +1,27 @@
+class Kubes::Compiler
+  class Strategy
+    def initialize(options={})
+      @options = options
+      @path = options[:path]
+    end
+
+    def compile
+      klass = strategy_class
+      return false unless klass
+
+      strategy = klass.new(@options.merge(path: @path)) # Dsl or Erb
+      result = strategy.run
+      result.compile_decorate! # compile phase decoration
+      result
+    end
+
+    def strategy_class
+      ext = File.extname(@path)
+      case ext
+      when '.rb'   then Dsl
+      when '.yaml' then Erb
+      else Pass
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+class Kubes::Compiler::Strategy
+  class Base
+    include Kubes::Logging
+
+    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')
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+class Kubes::Compiler::Strategy
+  class Dsl < Base
+    include Kubes::Compiler::Util::Normalize
+
+    def run
+      dsl = dsl_class.new(@options) # Deployment, Service, etc
+      data = dsl.run
+      Result.new(@save_file, data)
+    end
+
+    def dsl_class
+      if block_form?
+        Kubes::Compiler::Dsl::Core::Blocks
+      else
+        syntax_class
+      end
+    end
+
+    def syntax_class
+      klass_name = normalize_kind(@filename)
+      "Kubes::Compiler::Dsl::Syntax::#{klass_name}".constantize
+    rescue NameError
+      logger.debug "Using default resource for: #{klass_name}"
+      Kubes::Compiler::Dsl::Syntax::Resource # default
+    end
+
+    def block_form?
+      type = extract_type(@filename)
+      type.pluralize == type
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require "render_me_pretty"
+
+class Kubes::Compiler::Strategy
+  class Erb < Base
+    extend Kubes::Compiler::Dsl::Core::Fields
+    include Kubes::Compiler::Dsl::Core::Helpers
+    include Kubes::Compiler::Shared::Helpers
+    include Kubes::Compiler::Layering
+
+    def run
+      @data = {}
+
+      render_files(pre_layers)
+      render(@path) # main resource definition
+      render_files(post_layers)
+
+      Result.new(@save_file, @data)
+    end
+
+    def render_files(paths)
+      paths.each do |path|
+        render(path)
+      end
+    end
+
+    # render and merge
+    def render(path)
+      result = render_result(path)
+      @data.deeper_merge!(result)
+    end
+
+    def render_result(path)
+      if File.exist?(path)
+        yaml = RenderMePretty.result(path, context: self)
+        result = YAML.load(yaml)
+        result.is_a?(Hash) ? result : {} # in case of blank yaml doc a Boolean false is returned
+      else
+        {}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+class Kubes::Compiler::Strategy
+  class Pass < Base
+    def run
+      # use filehandle instead of content. write is aware of this and handles properly
+      io = File.read(@path)
+      Result.new(@save_file, io)
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+class Kubes::Compiler::Strategy
+  class Result
+    include Kubes::Compiler::Util::YamlDump
+
+    attr_reader :filename
+    def initialize(filename, data)
+      @filename, @data = filename, data
+    end
+
+    def io?
+      @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
+    end
+
+    def content
+      yaml_dump(@data)
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Kubes::Compiler::Util
+  module Normalize
+    def normalize_kind(path)
+      extract_type(path).underscore.camelize # Deployment, Service, Ingress, ManagedCertificate, etc
+    end
+
+    def extract_type(path)
+      File.basename(path).sub('.rb','').sub(/-.*/,'')
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require "json"
+require "yaml"
+
+module Kubes::Compiler::Util
+  module YamlDump
+    def yaml_dump(data)
+      if data.is_a?(Kubes::Compiler::Dsl::Core::Blocks)
+        items = data.results.map { |k,v| standardize_yaml(v) }
+        items.map(&:to_yaml).join("")
+      else
+        data = standardize_yaml(data)
+        data.to_yaml
+      end
+    end
+
+    # https://stackoverflow.com/questions/24508364/how-to-emit-yaml-in-ruby-expanding-aliases/46104244#46104244
+    # Prevents YAML from generating aliases/anchors.
+    def standardize_yaml(data)
+      json = data.to_json
+      YAML.load(json)
+    end
+  end
+end

data/lib/kubes/completer.rb

@@ -0,0 +1,159 @@
+=begin
+Code Explanation:
+
+There are 3 types of things to auto-complete:
+
+  1. command: the command itself
+  2. parameters: command parameters.
+  3. options: command options
+
+Here's an example:
+
+  mycli hello name --from me
+
+  * command: hello
+  * parameters: name
+  * option: --from
+
+When command parameters are done processing, the remaining completion words will be options.  We can tell that the command params are completed based on the method arity.
+
+## Arity
+
+For example, say you had a method for a CLI command with the following form:
+
+  ufo scale service count --cluster development
+
+It's equivalent ruby method:
+
+  scale(service, count) = has an arity of 2
+
+So typing:
+
+  ufo scale service count [TAB] # there are 3 parameters including the "scale" command according to Thor's CLI processing.
+
+So the completion should only show options, something like this:
+
+  --noop --verbose --cluster
+
+## Splat Arguments
+
+When the ruby method has a splat argument, it's arity is negative.  Here are some example methods and their arities.
+
+   ship(service) = 1
+   scale(service, count) = 2
+   ships(*services) = -1
+   foo(example, *rest) = -2
+
+Fortunately, negative and positive arity values are processed the same way. So we take simply take the absolute value of the arity and process it the same.
+
+Here are some test cases, hit TAB after typing the command:
+
+  kubes completion
+  kubes completion hello
+  kubes completion hello name
+  kubes completion hello name --
+  kubes completion hello name --noop
+
+  kubes completion
+  kubes completion sub:goodbye
+  kubes completion sub:goodbye name
+
+## Subcommands and Thor::Group Registered Commands
+
+Sometimes the commands are not simple thor commands but are subcommands or Thor::Group commands. A good specific example is the ufo tool.
+
+  * regular command: ufo ship
+  * subcommand: ufo docker
+  * Thor::Group command: ufo init
+
+Auto-completion accounts for each of these type of commands.
+=end
+module Kubes
+  class Completer
+    def initialize(command_class, *params)
+      @params = params
+      @current_command = @params[0]
+      @command_class = command_class # CLI initiall
+    end
+
+    def run
+      if subcommand?(@current_command)
+        subcommand_class = @command_class.subcommand_classes[@current_command]
+        @params.shift # destructive
+        Completer.new(subcommand_class, *@params).run # recursively use subcommand
+        return
+      end
+
+      # full command has been found!
+      unless found?(@current_command)
+        puts all_commands
+        return
+      end
+
+      # will only get to here if command aws found (above)
+      arity = @command_class.instance_method(@current_command).arity.abs
+      if @params.size > arity or thor_group_command?
+        puts options_completion
+      else
+        puts params_completion
+      end
+    end
+
+    def subcommand?(command)
+      @command_class.subcommands.include?(command)
+    end
+
+    # hacky way to detect that command is a registered Thor::Group command
+    def thor_group_command?
+      command_params(raw=true) == [[:rest, :args]]
+    end
+
+    def found?(command)
+      public_methods = @command_class.public_instance_methods(false)
+      command && public_methods.include?(command.to_sym)
+    end
+
+    # all top-level commands
+    def all_commands
+      commands = @command_class.all_commands.reject do |k,v|
+        v.is_a?(Thor::HiddenCommand)
+      end
+      commands.keys
+    end
+
+    def command_params(raw=false)
+      params = @command_class.instance_method(@current_command).parameters
+      # Example:
+      # >> Sub.instance_method(:goodbye).parameters
+      # => [[:req, :name]]
+      # >>
+      raw ? params : params.map!(&:last)
+    end
+
+    def params_completion
+      offset = @params.size - 1
+      offset_params = command_params[offset..-1]
+      command_params[offset..-1].first
+    end
+
+    def options_completion
+      used = ARGV.select { |a| a.include?('--') } # so we can remove used options
+
+      method_options = @command_class.all_commands[@current_command].options.keys
+      class_options = @command_class.class_options.keys
+
+      all_options = method_options + class_options + ['help']
+
+      all_options.map! { |o| "--#{o.to_s.gsub('_','-')}" }
+      filtered_options = all_options - used
+      filtered_options.uniq
+    end
+
+    # Useful for debugging. Using puts messes up completion.
+    def log(msg)
+      File.open("/tmp/complete.log", "a") do |file|
+        file.puts(msg)
+      end
+    end
+  end
+end