kubes 0.1.0 → 0.2.4

data/lib/kubes/completer/script.rb

@@ -0,0 +1,6 @@
+class Kubes::Completer::Script
+  def self.generate
+    bash_script = File.expand_path("script.sh", File.dirname(__FILE__))
+    puts "source #{bash_script}"
+  end
+end

data/lib/kubes/completer/script.sh

@@ -0,0 +1,10 @@
+_kubes() {
+  COMPREPLY=()
+  local word="${COMP_WORDS[COMP_CWORD]}"
+  local words=("${COMP_WORDS[@]}")
+  unset words[0]
+  local completion=$(kubes completion ${words[@]})
+  COMPREPLY=( $(compgen -W "$completion" -- "$word") )
+}
+
+complete -F _kubes kubes

data/lib/kubes/config.rb

@@ -0,0 +1,82 @@
+module Kubes
+  class Config
+    include Singleton
+    include DslEvaluator
+
+    attr_reader :config
+    def initialize
+      @config = defaults
+    end
+
+    def defaults
+      config = ActiveSupport::OrderedOptions.new
+
+      config.state = ActiveSupport::OrderedOptions.new
+      config.state.docker_image_path = "#{Kubes.root}/.kubes/state/docker_image.txt"
+
+      config.logger = Logger.new($stdout)
+      config.logger.level = ENV['KUBES_LOG_LEVEL'] || :info
+
+      # 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
+
+      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
+    end
+
+    # Create shared resources first
+    def role_order
+      %w[
+        common
+        shared
+      ]
+    end
+
+    # Create resources in specific order so dependent resources are available
+    def kind_order
+      %w[
+        Namespace
+        StorageClass
+        CustomResourceDefinition
+        MutatingWebhookConfiguration
+        ServiceAccount
+        PodSecurityPolicy
+        Role
+        ClusterRole
+        RoleBinding
+        ClusterRoleBinding
+        ConfigMap
+        Secret
+        Service
+        LimitRange
+        Deployment
+        StatefulSet
+        CronJob
+        PodDisruptionBudget
+      ]
+    end
+
+    def configure
+      yield(@config)
+    end
+
+    def load_configs
+      evaluate_file(".kubes/config.rb")
+      evaluate_file(".kubes/config/env/#{Kubes.env}.rb")
+    end
+  end
+end

data/lib/kubes/core.rb

@@ -0,0 +1,32 @@
+module Kubes
+  module Core
+    extend Memoist
+
+    def env
+      ENV['KUBES_ENV'] || "dev"
+    end
+
+    def root
+      ENV['KUBES_ROOT'] || Dir.pwd
+    end
+
+    def configure(&block)
+      Config.instance.configure(&block)
+    end
+
+    def config
+      Config.instance.load_configs
+      Config.instance.config
+    end
+    memoize :config
+
+    def logger
+      config.logger
+    end
+    memoize :logger
+
+    def kustomize?
+      Kubectl::Kustomize.detect?
+    end
+  end
+end

data/lib/kubes/docker/args/default.rb

@@ -0,0 +1,39 @@
+module Kubes::Docker::Args
+  class Default
+    def initialize(name, image_name, options={})
+      @name, @image_name, @options = name.to_s, image_name, options
+      @dockerfile = "Dockerfile"
+    end
+
+    def args
+      case @name
+      when "build"
+        build_args
+      when "push"
+        [@image_name]
+      else
+        []
+      end
+    end
+
+    def build_args
+      ["-t #{@image_name} -f #{@dockerfile} ."]
+    end
+
+
+  private
+    def common_args
+      %w[--recursive -f ]
+    end
+
+    def resource_path
+      [".kubes/output", @options[:role], resource].compact.join('/')
+    end
+
+    def resource
+      return unless r = @options[:resource] # intentional assignment
+      r.include?(".yaml") ? r : "#{r}.yaml"
+    end
+
+  end
+end

data/lib/kubes/docker/base.rb

@@ -0,0 +1,88 @@
+module Kubes::Docker
+  class Base
+    extend Memoist
+    include Kubes::Logging
+    include Kubes::Util::Sh
+
+    def initialize(options={})
+      @options = options
+      @name = self.class.name.split('::').last.underscore
+    end
+
+    def run_hooks(name, &block)
+      hooks = Kubes::Hooks::Builder.new(name, "#{Kubes.root}/.kubes/config/docker/hooks.rb")
+      hooks.build # build hooks
+      hooks.run_hooks(&block)
+    end
+
+    def args
+      # base at end in case of redirection. IE: command > /path
+      custom.args + default.args
+    end
+
+    def custom
+      custom = Kubes::Args::Custom.new(@name, "#{Kubes.root}/.kubes/config/docker/args.rb")
+      custom.build
+      custom
+    end
+    memoize :custom
+
+    def default
+      Args::Default.new(@name, image_name, @options)
+    end
+    memoize :default
+
+    @@image_name = nil
+    def reserve_image_name
+      @@image_name = generate_name
+    end
+
+    # Store this in a file because this name gets reference in other tasks later
+    # and we want the image name to stay the same when the commands are run separate
+    # in different processes.  So we store the state in a file.
+    # Only when a new docker build command gets run will the image name state be updated.
+    def store_image_name
+      FileUtils.mkdir_p(File.dirname(image_state_path))
+      IO.write(image_state_path, @@image_name)
+    end
+
+    # output can get entirely wiped so dont use that folder
+    def image_state_path
+      Kubes.config.state.docker_image_path
+    end
+
+    # full_image - Includes the tag. Examples:
+    #   123456789.dkr.ecr.us-west-2.amazonaws.com/myapp:kubes-2018-04-20T09-29-08-b7d51df
+    #   tongueroo/demo-kubes:kubes-2018-04-20T09-29-08-b7d51df
+    def image_name
+      return generate_name if @options[:generate]
+      return @@image_name if @@image_name
+      return "tongueroo/demo-kubes:kubes-12345678" if ENV['TEST']
+
+      unless File.exist?(image_state_path)
+        puts "Unable to find #{image_state_path} which contains the last docker image name built with kubes build.  Please run `kubes docker build` first."
+        exit 1
+      end
+      IO.read(image_state_path).strip
+    end
+
+    @@timestamp = Time.now.strftime('%Y-%m-%dT%H-%M-%S')
+    def generate_name
+      # IE: tongueroo/demo:kubes-
+      ["#{repo}:kubes-#{@@timestamp}", git_sha].compact.join('-')
+    end
+
+    def repo
+      Kubes.config.repo
+    end
+
+    def git_sha
+      return @git_sha if @git_sha
+      # always call this and dont use the execute method because of the noop option
+      git_installed = system("type git > /dev/null 2>&1")
+      return unless git_installed && File.exist?("#{Kubes.root}/.git")
+      @git_sha = `cd #{Kubes.root} && git rev-parse --short HEAD`
+      @git_sha.strip!
+    end
+  end
+end

data/lib/kubes/docker/build.rb

@@ -0,0 +1,22 @@
+module Kubes::Docker
+  class Build < Base
+    def run
+      reserve_image_name
+      build
+      store_image_name
+    end
+
+    def build
+      # Dockerfile is also used in args/default.rb, will have to combine if Dockerfile is made configurable
+      unless File.exist?("Dockerfile")
+        logger.error "ERROR: The Dockerfile does not exist. Cannot build the docker image without a Dockerfile".color(:red)
+        exit 1
+      end
+      params = args.flatten.join(' ')
+      command = "docker build #{params}"
+      run_hooks "build" do
+        sh(command)
+      end
+    end
+  end
+end

data/lib/kubes/docker/push.rb

@@ -0,0 +1,33 @@
+module Kubes::Docker
+  class Push < Base
+    include Kubes::Logging
+    include Kubes::Util::Time
+
+    def run
+      update_auth_token
+      start_time = Time.now
+      message = "Pushed #{image_name} docker image."
+      if @options[:noop]
+        message = "NOOP #{message}"
+      else
+        push
+      end
+      took = Time.now - start_time
+      message << "\nDocker push took #{pretty_time(took)}.".color(:green)
+      logger.info message
+    end
+
+    def push
+      params = args.flatten.join(' ')
+      command = "docker push #{params}"
+      run_hooks "push" do
+        sh(command)
+      end
+    end
+
+    def update_auth_token
+      auth = Kubes::Auth.new(image_name)
+      auth.run
+    end
+  end
+end

data/lib/kubes/hooks/builder.rb

@@ -0,0 +1,41 @@
+module Kubes::Hooks
+  class Builder
+    extend Memoist
+    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
+      @hooks = {before: {}, after: {}}
+    end
+
+    def build
+      return @hooks unless File.exist?(@file)
+      evaluate_file(@file)
+      @hooks.deep_stringify_keys!
+    end
+    memoize :build
+
+    def run_hooks
+      build
+      run_hook("before")
+      yield if block_given?
+      run_hook("after")
+    end
+
+    def run_hook(type)
+      execute = @hooks.dig(type, @name.to_s, "execute")
+      return unless execute
+
+      exit_on_fail = @hooks.dig(type, @name.to_s, "exit_on_fail")
+      exit_on_fail = exit_on_fail.nil? ? true : exit_on_fail
+
+      logger.info "Running #{type} hook"
+      sh(execute, exit_on_fail: exit_on_fail)
+    end
+  end
+end

data/lib/kubes/hooks/dsl.rb

@@ -0,0 +1,19 @@
+module Kubes::Hooks
+  module Dsl
+    def before(*commands, **props)
+      commands.each do |name|
+        each_hook(:before, name, props)
+      end
+    end
+
+    def after(*commands, **props)
+      commands.each do |name|
+        each_hook(:after, name, props)
+      end
+    end
+
+    def each_hook(type, name, props={})
+      @hooks[type][name] = props
+    end
+  end
+end

data/lib/kubes/kubectl.rb

@@ -0,0 +1,87 @@
+module Kubes
+  class Kubectl
+    extend Memoist
+    include Kubes::Util::Sh
+
+    def initialize(name, options={})
+      @name, @options = name, options
+    end
+
+    def run
+      validate!
+      params = args.flatten.join(' ')
+      command = "kubectl #{@name} #{params}" # @name: apply or delete
+      options = {}
+      options[:exit_on_fail] = exit_on_fail unless exit_on_fail.nil?
+      switch_context do
+        run_hooks(@name) do
+          sh(command, options)
+        end
+      end
+    end
+
+    # Useful for kustomize mode
+    def validate!
+      return true unless Kubes.kustomize?
+
+      unless @options[:role]
+        logger.error "Missing argument: A folder must be provided when using kustomization.yaml files".color(:red)
+        logger.info "Please provide a folder"
+        exit 1
+      end
+    end
+
+    def exit_on_fail
+      kubectl = Kubes.config.kubectl
+      exit_on_fail = kubectl.send("exit_on_fail_for_#{@name}")
+      exit_on_fail.nil? ? kubectl.exit_on_fail : exit_on_fail
+    end
+
+    def switch_context(&block)
+      kubectl = Kubes.config.kubectl
+      context = kubectl.context
+      if context
+        previous_context = capture("kubectl config current-context")
+        sh("kubectl config use-context #{context}", mute: true)
+        result = block.call
+        if !previous_context.blank? && !kubectl.context_keep
+          sh("kubectl config use-context #{previous_context}", mute: true)
+        end
+        result
+      else
+        block.call
+      end
+    end
+
+    def run_hooks(name, &block)
+      hooks = Kubes::Hooks::Builder.new(name, "#{Kubes.root}/.kubes/config/kubectl/hooks.rb")
+      hooks.build # build hooks
+      hooks.run_hooks(&block)
+    end
+
+    def args
+      # base at end in case of redirection. IE: command > /path
+      custom.args + default.args
+    end
+
+    def custom
+      custom = Kubes::Args::Custom.new(@name, "#{Kubes.root}/.kubes/config/kubectl/args.rb")
+      custom.build
+      custom
+    end
+    memoize :custom
+
+    def default
+      klass = Kubes.kustomize? ? Args::Kustomize : Args::Standard
+      klass.new(@name, @options)
+    end
+    memoize :default
+
+    class << self
+      def run(name, options={})
+        new(name, options).run
+      end
+    end
+  end
+end
+