kubes 0.1.0 → 0.2.0

data/lib/kubes/cli/docker.rb

@@ -0,0 +1,20 @@
+class Kubes::CLI
+  class Docker < Kubes::Command
+    desc "build", "Build docker image."
+    long_desc Help.text("docker:build")
+    option :push, type: :boolean, default: false
+    def build
+      builder = Kubes::Docker::Build.new(options)
+      builder.run
+      push if options[:push]
+    end
+
+    desc "push IMAGE", "Push the docker image."
+    long_desc Help.text("docker:push")
+    option :push, type: :boolean, default: false
+    def push
+      pusher = Kubes::Docker::Push.new(options)
+      pusher.run
+    end
+  end
+end

data/lib/kubes/cli/get.rb

@@ -0,0 +1,8 @@
+class Kubes::CLI
+  class Get < Base
+    def run
+      Compile.new(@options).run unless @options[:compile] == false
+      Kubes::Kubectl.run(:get, @options)
+    end
+  end
+end

data/lib/kubes/cli/help.rb

@@ -0,0 +1,11 @@
+class Kubes::CLI
+  module Help
+    class << self
+      def text(namespaced_command)
+        path = namespaced_command.to_s.gsub(':','/')
+        path = File.expand_path("../help/#{path}.md", __FILE__)
+        IO.read(path) if File.exist?(path)
+      end
+    end
+  end
+end

data/lib/kubes/cli/help/completion.md

@@ -0,0 +1,20 @@
+## Examples
+
+    kubes completion
+
+Prints words for TAB auto-completion.
+
+    kubes completion
+    kubes completion hello
+    kubes completion hello name
+
+To enable, TAB auto-completion add the following to your profile:
+
+    eval $(kubes completion_script)
+
+Auto-completion example usage:
+
+    kubes [TAB]
+    kubes hello [TAB]
+    kubes hello name [TAB]
+    kubes hello name --[TAB]

data/lib/kubes/cli/help/completion_script.md

@@ -0,0 +1,3 @@
+To use, add the following to your `~/.bashrc` or `~/.profile`
+
+    eval $(kubes completion_script)

data/lib/kubes/cli/help/deploy.md

@@ -0,0 +1,10 @@
+## Examples
+
+Deploy all resources in .kubes/resources/web
+
+    kubes deploy web
+
+Deploy specific resource, like .kubes/resources/web/deployment.rb
+
+    kubes deploy web deployment
+    kubes deploy web service

data/lib/kubes/cli/init.rb

@@ -0,0 +1,69 @@
+class Kubes::CLI
+  class Init < Sequence
+    def self.options
+      [
+        [:app, aliases: ["a"], required: true, desc: "Docker repo name. Example: web. Generates .kubes/APP/resources folder"],
+        [:force, type: :boolean, desc: "Bypass overwrite are you sure prompt for existing files"],
+        [:type, aliases: ["t"], default: "yaml", desc: "Type: dsl or yaml"],
+        [:repo, required: true, desc: "Docker repo name. Example: user/repo. Configures .kubes/config.rb"],
+      ]
+    end
+
+    options.each { |args| class_option(*args) }
+
+  private
+    # Needs to be a method to its available for templates/.kubes/resources/%app%
+    def app
+      @options[:app]
+    end
+
+  public
+    def create_dockefile
+      return if File.exist?("Dockerfile")
+      set_source("docker")
+      directory ".", "."
+    end
+
+    def create_base_files
+      set_source("base")
+      directory ".", "."
+    end
+
+    def create_dsl_files
+      return unless @options[:type] == "dsl"
+      set_source("dsl")
+      directory ".", "."
+    end
+
+    def create_yaml_files
+      return if @options[:type] == "dsl"
+      set_source("yaml")
+      directory ".", "."
+    end
+
+    def message
+      logger.info "Initialized .kubes folder"
+    end
+
+    def adjust_gitignore
+      ignores = %w[
+        .kubes/output
+        .kubes/state
+      ]
+      if File.exist?(".gitignore")
+        lines = IO.readlines(".gitignore")
+        if lines.detect { |l| l.include?('.kubes/output') }
+          return # early
+        else
+          lines += ignores
+        end
+      else
+        lines = ignores
+      end
+
+      text = lines.join("\n") + "\n"
+      IO.write(".gitignore", text)
+      puts "Updated .gitignore"
+    end
+  end
+end

data/lib/kubes/cli/sequence.rb

@@ -0,0 +1,27 @@
+require 'thor'
+
+class Kubes::CLI
+  class Sequence < Thor::Group
+    include Thor::Actions
+
+  private
+    def logger
+      Kubes.logger
+    end
+
+    def set_source(type)
+      override_source_paths(File.expand_path("../../templates/#{type}", __dir__))
+    end
+
+    def override_source_paths(*paths)
+      # https://github.com/erikhuda/thor/blob/34df888d721ecaa8cf0cea97d51dc6c388002742/lib/thor/actions.rb#L128
+      instance_variable_set(:@source_paths, nil) # unset instance variable cache
+      # Using string with instance_eval because block doesnt have access to path at runtime.
+      self.class.instance_eval %{
+        def self.source_paths
+          #{paths.flatten.inspect}
+        end
+      }
+    end
+  end
+end

data/lib/kubes/command.rb

@@ -0,0 +1,100 @@
+require "thor"
+
+# Override thor's long_desc identation behavior
+# https://github.com/erikhuda/thor/issues/398
+class Thor
+  module Shell
+    class Basic
+      def print_wrapped(message, options = {})
+        message = "\n#{message}" unless message[0] == "\n"
+        stdout.puts message
+      end
+    end
+  end
+end
+
+# Gets rid of the c_l_i extra commands in the help menu. Seems like thor_classes_in is only used
+# for this purpose. More details: https://gist.github.com/tongueroo/ee92ec28a4d3eed301d88e8ccdd2fe10
+module ThorPrepend
+  module Util
+    def thor_classes_in(klass)
+      klass.name.include?("CLI") ? [] : super
+    end
+  end
+end
+Thor::Util.singleton_class.prepend(ThorPrepend::Util)
+
+module Kubes
+  class Command < Thor
+    class << self
+      def dispatch(m, args, options, config)
+        # Allow calling for help via:
+        #   kubes command help
+        #   kubes command -h
+        #   kubes command --help
+        #   kubes command -D
+        #
+        # as well thor's normal way:
+        #
+        #   kubes help command
+        help_flags = Thor::HELP_MAPPINGS + ["help"]
+        if args.length > 1 && !(args & help_flags).empty?
+          args -= help_flags
+          args.insert(-2, "help")
+        end
+
+        #   kubes version
+        #   kubes --version
+        #   kubes -v
+        version_flags = ["--version", "-v"]
+        if args.length == 1 && !(args & version_flags).empty?
+          args = ["version"]
+        end
+
+        super
+      end
+
+      # Override command_help to include the description at the top of the
+      # long_description.
+      def command_help(shell, command_name)
+        meth = normalize_command_name(command_name)
+        command = all_commands[meth]
+        alter_command_description(command)
+        super
+      end
+
+      def alter_command_description(command)
+        return unless command
+
+        # Add description to beginning of long_description
+        long_desc = if command.long_description
+            "#{command.description}\n\n#{command.long_description}"
+          else
+            command.description
+          end
+
+        # add reference url to end of the long_description
+        unless website.empty?
+          full_command = [command.ancestor_name, command.name].compact.join('-')
+          url = "#{website}/reference/kubes-#{full_command}"
+          long_desc += "\n\nHelp also available at: #{url}"
+        end
+
+        command.long_description = long_desc
+      end
+      private :alter_command_description
+
+      # meant to be overriden
+      def website
+        ""
+      end
+
+      # https://github.com/erikhuda/thor/issues/244
+      # Deprecation warning: Thor exit with status 0 on errors. To keep this behavior, you must define `exit_on_failure?` in `Lono::CLI`
+      # You can silence deprecations warning by setting the environment variable THOR_SILENCE_DEPRECATION.
+      def exit_on_failure?
+        true
+      end
+    end
+  end
+end

data/lib/kubes/compiler.rb

@@ -0,0 +1,71 @@
+module Kubes
+  class Compiler
+    include Kubes::Logging
+    include Kubes::Util::Consider
+
+    def initialize(options={})
+      @options = options
+    end
+
+    def run
+      results = resources.map do |path|
+        strategy = Strategy.new(@options.merge(path: path))
+        strategy.compile
+      end.compact
+
+      results.each do |result|
+        write(result)
+      end
+
+      puts "Compiled  .kubes/resources files to .kubes/output" if show_compiled_message?
+    end
+
+    def resources
+      paths = []
+      expr = "#{Kubes.root}/.kubes/resources/**/*"
+      Dir.glob(expr).each do |path|
+        next unless process?(path)
+        paths << path
+      end
+      paths
+    end
+
+    # Only considering files 2 layers deep. So:
+    #
+    #    Yes = web/deployment.yaml
+    #    No = web/deployment/dev.yaml
+    #
+    def process?(path)
+      if Kubes.kustomize?
+        File.file?(path)
+      else
+        consider?(path) && two_levels_deep?(path)
+      end
+    end
+
+    def two_levels_deep?(path)
+      rel_path = path.sub(%r{.*\.kubes/resources/},'')
+      rel_path.split('/').size == 2
+    end
+
+    def write(result)
+      result.write_decorate!
+      filename, content = result.filename, result.content
+      dest = "#{Kubes.root}/.kubes/output/#{filename}"
+
+      if result.io?
+        FileUtils.cp(filename, dest) # preserve permissions
+      else
+        FileUtils.mkdir_p(File.dirname(dest))
+        IO.write(dest, content)
+      end
+
+      pretty_dest = dest.sub("#{Kubes.root}/",'')
+      logger.debug "Compiled  #{pretty_dest}"
+    end
+
+    def show_compiled_message?
+      !%w[g ge get].include?(ARGV.first)
+    end
+  end
+end

data/lib/kubes/compiler/decorator.rb

@@ -0,0 +1,17 @@
+class Kubes::Compiler
+  module Decorator
+    @@md5s = {}
+    def store(name, md5)
+      @@md5s[name] = md5
+    end
+
+    def fetch(name)
+      @@md5s[name]
+    end
+
+    def md5s
+      @@md5s
+    end
+    extend self
+  end
+end

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

@@ -0,0 +1,16 @@
+module Kubes::Compiler::Decorator
+  class Base
+    def initialize(data)
+      @data = data
+    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
+      end
+      @data # important to return @data so we keep the original @data structure: Blocks or Hash
+    end
+  end
+end

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

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

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

@@ -0,0 +1,13 @@
+module Kubes::Compiler::Decorator::Resources
+  class Base
+    attr_reader :data
+    def initialize(data)
+      @data = data
+    end
+
+    def run
+      return @data unless Kubes.config.suffix_hash
+      perform
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+module Kubes::Compiler::Decorator::Resources
+  class Container
+    include Mapping
+
+    def initialize(data, kind:, fields_for:)
+      @data = data
+      # These methods are defined in Mapping
+      kind == "Deployment" ? deployment_keys : pod_keys
+      fields_for == "Secret" ? secrets_fields : configMaps_fields
+    end
+
+    def run
+      envFrom!
+      valueFrom!
+      volumes!
+      @data
+    end
+
+    # spec.envFrom.configMapRef
+    # spec.envFrom.secretRef
+    def envFrom!
+      return @data unless containers
+
+      containers.each do |container|
+        next unless envFrom_list = container.dig('envFrom') # intentional assignment
+
+        envFrom_list.each do |envFrom|
+          next unless name = envFrom.dig(@envFrom_field, 'name') # intentional assignment
+
+          md5 = Kubes::Compiler::Decorator.fetch(name)
+          envFrom[@envFrom_field]['name'] = [name, md5].compact.join('-')
+        end
+      end
+    end
+
+    # spec.valueFrom.configMapKeyRef
+    # spec.valueFrom.secretKeyRef
+    def valueFrom!
+      return @data unless containers
+
+      containers.each do |container|
+        next unless env_list = container.dig('env') # intentional assignment
+
+        env_list.each do |env|
+          next unless name = env.dig('valueFrom',@valueFrom_field,'name') # intentional assignment
+
+          md5 = Kubes::Compiler::Decorator.fetch(name)
+          env['valueFrom'][@valueFrom_field]['name'] = [name, md5].compact.join('-')
+        end
+      end
+    end
+
+    # spec.volumes.configMap.name
+    # spec.volumes.secret.secretName
+    def volumes!
+      volumes = @data.dig(*@volumes_key.split('.'))
+      return @data unless volumes
+
+      volumes.each do |volume|
+        # Example:
+        # next unless field = volume.dig('secret') # intentional assignment
+        # next unless name = field['secretName'] # intentional assignment
+        next unless field = volume.dig(@volume_field) # intentional assignment
+        next unless name = field[@volume_field_name] # intentional assignment
+
+        md5 = Kubes::Compiler::Decorator.fetch(name)
+        field[@volume_field_name] = [name, md5].compact.join('-')
+      end
+    end
+
+  private
+    def containers
+      @data.dig(*@containers_key.split('.'))
+    end
+  end
+end