kuberun 0.1.0

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'kuberun'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/kuberun

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+lib_path = File.expand_path('../lib', __dir__)
+$LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
+require 'kuberun/cli'
+require 'kuberun'
+
+Signal.trap('INT') do
+  warn("\n#{caller.join("\n")}: interrupted")
+  exit(1)
+end
+
+begin
+  Kuberun::CLI.start
+rescue Kuberun::CLI::Error => err
+  puts "ERROR: #{err.message}"
+  exit 1
+end

data/kuberun.gemspec

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kuberun/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'kuberun'
+  spec.license       = 'MIT'
+  spec.version       = Kuberun::VERSION
+  spec.authors       = ['kruczjak']
+  spec.email         = ['jakub.kruczek@boostcom.no']
+
+  spec.summary       = 'CLI to run pods based on deployments'
+  spec.description   = 'CLI to run pods based on deployments'
+  spec.homepage      = 'https://boostcom.com'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'pastel', '~> 0.7.2'
+  spec.add_dependency 'thor', '~> 0.20.0'
+  spec.add_dependency 'tty-color', '~> 0.4.2'
+  spec.add_dependency 'tty-command', '~> 0.8.0'
+  spec.add_dependency 'tty-config', '~> 0.2.0'
+  spec.add_dependency 'tty-cursor', '~> 0.5.0'
+  spec.add_dependency 'tty-editor', '~> 0.4.0'
+  spec.add_dependency 'tty-file', '~> 0.6.0'
+  spec.add_dependency 'tty-font', '~> 0.2.0'
+  spec.add_dependency 'tty-markdown', '~> 0.4.0'
+  spec.add_dependency 'tty-pager', '~> 0.11.0'
+  spec.add_dependency 'tty-platform', '~> 0.1.0'
+  spec.add_dependency 'tty-progressbar', '~> 0.15.0'
+  spec.add_dependency 'tty-prompt', '~> 0.16.1'
+  spec.add_dependency 'tty-screen', '~> 0.6.4'
+  spec.add_dependency 'tty-spinner', '~> 0.8.0'
+  spec.add_dependency 'tty-table', '~> 0.10.0'
+  spec.add_dependency 'tty-tree', '~> 0.1.0'
+  spec.add_dependency 'tty-which', '~> 0.3.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '~> 0.58.0'
+end

data/lib/kuberun.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'kuberun/version'
+
+require 'pastel'
+require 'tty-command'
+require 'tty-prompt'
+
+require 'kuberun/kubectl'
+require 'json'
+
+module Kuberun
+  Kubectl = ::Kubectl.new
+  Pastel = ::Pastel.new
+  # Your code goes here...
+end

data/lib/kuberun/cli.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'thor'
+
+module Kuberun
+  # Handle the application command line parsing
+  # and the dispatch to various command objects
+  #
+  # @api public
+  class CLI < Thor
+    DEFAULT_OPTIONS_FOR_KUBECTL_OPTIONS = { type: :string, default: '', desc: 'See kubectl options' }
+    BASE_KUBECTL_OPTIONS = {
+      'certificate-authority': {},
+      'client-certificate': {},
+      'client-key': {},
+      'cluster': {},
+      'context': {},
+      'insecure-skip-tls-verify': {},
+      'kubeconfig': {},
+      'namespace': { aliases: :'-n' },
+      'token': {},
+      'v': { type: :numeric, default: 0, desc: 'Log level, also passed to kubectl' },
+    }
+    BASE_KUBECTL_OPTIONS.each do |option_name, hash|
+      class_option option_name, DEFAULT_OPTIONS_FOR_KUBECTL_OPTIONS.merge(hash)
+    end
+
+    # Error raised by this runner
+    Error = Class.new(StandardError)
+
+    desc 'version', 'kuberun version'
+    def version
+      require_relative 'version'
+      puts "v#{Kuberun::VERSION}"
+    end
+    map %w[--version -v] => :version
+
+    desc 'run_pod DEPLOYMENT_NAME', 'Starts pod for command'
+    method_option :help, aliases: '-h', type: :boolean,
+                         desc: 'Display usage information'
+    def run_pod(deployment_name)
+      if options[:help]
+        invoke :help, ['run_pod']
+      else
+        require_relative 'commands/run_pod'
+        Kuberun::Commands::RunPod.new(deployment_name, options).execute
+      end
+    end
+  end
+end

data/lib/kuberun/command.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Kuberun
+  class Command
+    extend Forwardable
+
+    def_delegators :command, :run
+
+    def initialize(options)
+      Kuberun::Kubectl.load_options(options)
+    end
+
+    # Execute this command
+    #
+    # @api public
+    def execute(*)
+      raise(
+        NotImplementedError,
+        "#{self.class}##{__method__} must be implemented"
+      )
+    end
+
+    # The external commands runner
+    #
+    # @see http://www.rubydoc.info/gems/tty-command
+    #
+    # @api public
+    def command(**options)
+      require 'tty-command'
+      TTY::Command.new(options)
+    end
+
+    # The cursor movement
+    #
+    # @see http://www.rubydoc.info/gems/tty-cursor
+    #
+    # @api public
+    def cursor
+      require 'tty-cursor'
+      TTY::Cursor
+    end
+
+    # Open a file or text in the user's preferred editor
+    #
+    # @see http://www.rubydoc.info/gems/tty-editor
+    #
+    # @api public
+    def editor
+      require 'tty-editor'
+      TTY::Editor
+    end
+
+    # File manipulation utility methods
+    #
+    # @see http://www.rubydoc.info/gems/tty-file
+    #
+    # @api public
+    def generator
+      require 'tty-file'
+      TTY::File
+    end
+
+    # Terminal output paging
+    #
+    # @see http://www.rubydoc.info/gems/tty-pager
+    #
+    # @api public
+    def pager(**options)
+      require 'tty-pager'
+      TTY::Pager.new(options)
+    end
+
+    # Terminal platform and OS properties
+    #
+    # @see http://www.rubydoc.info/gems/tty-pager
+    #
+    # @api public
+    def platform
+      require 'tty-platform'
+      TTY::Platform.new
+    end
+
+    # The interactive prompt
+    #
+    # @see http://www.rubydoc.info/gems/tty-prompt
+    #
+    # @api public
+    def prompt(**options)
+      require 'tty-prompt'
+      TTY::Prompt.new(options)
+    end
+
+    # Get terminal screen properties
+    #
+    # @see http://www.rubydoc.info/gems/tty-screen
+    #
+    # @api public
+    def screen
+      require 'tty-screen'
+      TTY::Screen
+    end
+
+    # The unix which utility
+    #
+    # @see http://www.rubydoc.info/gems/tty-which
+    #
+    # @api public
+    def which(*args)
+      require 'tty-which'
+      TTY::Which.which(*args)
+    end
+
+    # Check if executable exists
+    #
+    # @see http://www.rubydoc.info/gems/tty-which
+    #
+    # @api public
+    def exec_exist?(*args)
+      require 'tty-which'
+      TTY::Which.exist?(*args)
+    end
+  end
+end

data/lib/kuberun/commands/.gitkeep

@@ -0,0 +1 @@
+#

data/lib/kuberun/commands/run_pod.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative '../command'
+
+module Kuberun
+  module Commands
+    class RunPod < Kuberun::Command
+      NEW_POD = 'Start new one'
+
+      def initialize(deployment_name, options)
+        @deployment_name = deployment_name
+        @options = options
+        super(options)
+      end
+
+      def execute(input: $stdin, output: $stdout)
+        output.puts(Kuberun::Pastel.yellow('Checking access to needed commands...'))
+        Kuberun::Kubectl.auth_check('create', resource: 'pods')
+        Kuberun::Kubectl.auth_check('exec', resource: 'pods')
+        output.puts(Kuberun::Pastel.green('You have all permissions needed.'))
+
+        output.puts(Kuberun::Pastel.yellow('Searching for existing pods'))
+        existing_pods = Kuberun::Kubectl.get(resource: 'pods', options: "-l kuberun-provisioned=true,kuberun-source=#{@deployment_name}")
+        if existing_pods['items'].size > 0
+          select = existing_pods['items'].map { |item| item.dig('metadata', 'name') }
+          select << NEW_POD
+
+          selection = prompt.select('I found some already running pods. Do you want to use one?', select)
+
+          if selection == NEW_POD
+            create_pod_from_deployment(output)
+          else
+            @generated_pod_name = selection
+          end
+        else
+          create_pod_from_deployment(output)
+        end
+
+        execute_command(input, output)
+
+        unless prompt.no?('Should I delete pod?')
+          Kuberun::Kubectl.delete(resource: 'pod', resource_name: generated_pod_name)
+        end
+
+        output.puts(Kuberun::Pastel.green('Done!'))
+      end
+
+      private
+
+      def create_pod_from_deployment(output)
+        deployment = Kuberun::Kubectl.get(resource: 'deployment', resource_name: @deployment_name, options: '--export')
+        pod_template = deployment['spec']['template']
+        prepare_pod_template(pod_template)
+
+        Kuberun::Kubectl.create(configuration: pod_template)
+        wait_while do
+          pod = Kuberun::Kubectl.get(resource: 'pod', resource_name: generated_pod_name)
+          pod.dig('status', 'phase') == 'Running'
+        end
+
+        output.puts(Kuberun::Pastel.green('Pod is running!'))
+      end
+
+      def prepare_pod_template(pod_template)
+        pod_template['apiVersion'] = 'v1'
+        pod_template['kind'] = 'Pod'
+        pod_template['metadata']['name'] = generated_pod_name
+
+        pod_template['metadata']['labels'] = {
+          'kuberun' => Kuberun::VERSION.to_s,
+          'kuberun-provisioned' => 'true',
+          'kuberun-source' => @deployment_name,
+        }
+
+        pod_template['spec']['containers'][0].delete('livenessProbe')
+        pod_template['spec']['containers'][0].delete('readinessProbe')
+        pod_template['spec'].delete('affinity')
+      end
+
+      def wait_while
+        loop do
+          begin
+            status = yield
+            raise 'Not ok' unless status
+            break
+          rescue
+            sleep(1)
+          end
+        end
+      end
+
+      def generated_pod_name
+        @generated_pod_name ||= "kuberun-#{@deployment_name}-#{Time.now.to_i}"
+      end
+
+      def execute_command(_input, output)
+        output.puts(Kuberun::Pastel.green('Executing command'))
+
+        Kuberun::Kubectl.exec(pod: generated_pod_name, command: '-it /bin/sh')
+
+        output.puts(Kuberun::Pastel.green('Kubectl exec exited'))
+      end
+
+      def prompt
+        TTY::Prompt.new
+      end
+    end
+  end
+end

data/lib/kuberun/kubectl.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'pty'
+
+class Kubectl
+  CAT_MULTILINE = 'EOFCONFIG'
+  KUBECTL_OPTIONS = Kuberun::CLI::BASE_KUBECTL_OPTIONS.keys.map(&:to_s)
+
+  def load_options(options)
+    self.kubectl_options = parsed_options(options)
+  end
+
+  def auth_check(verb, resource:, resource_name: nil)
+    cmd.run(kubectl_base_command("auth can-i #{verb}", resource: resource, resource_name: resource_name))
+  end
+
+  def get(resource:, resource_name: nil, options: nil)
+    options = "#{options} --output=json"
+    parsed_json do
+      cmd.run(kubectl_base_command('get', resource: resource, resource_name: resource_name, options: options)).out
+    end
+  end
+
+  def create(configuration:, options: nil)
+    cmd.run(kubectl_base_input_command('create', configuration: configuration, options: options))
+  end
+
+  def exec(pod:, command:)
+    old_state = `stty -g`
+
+    PTY.spawn("#{kubectl_base_command('exec', resource: pod)} #{command}") do |o, i, pid|
+      t_in = Thread.new do
+        until i.closed? do
+          input = $stdin.getch
+          i.write(input)
+          i.flush
+        end
+      end
+
+      t_out = Thread.new do
+        begin
+          until o.eof? do
+            $stdout.print(o.readchar)
+            $stdout.flush
+          end
+        rescue Errno::EIO, EOFError
+          nil
+        end
+      end
+
+      t_in.run
+
+      Process::waitpid(pid) rescue nil
+      # "rescue nil" is there in case process already ended.
+
+      t_out.join
+      t_in.kill
+      sleep 0.1
+    ensure
+      t_out&.kill
+      t_in&.kill
+      $stdout.puts
+      $stdout.flush
+      system "stty #{ old_state }"
+    end
+  end
+
+  def delete(resource:, resource_name:)
+    cmd.run(kubectl_base_command('delete', resource: resource, resource_name: resource_name))
+  end
+
+  private
+
+  attr_accessor :kubectl_options
+
+  def cmd(tty_options = {})
+    TTY::Command.new(tty_options)
+  end
+
+  def kubectl_base_command(verb, resource:, resource_name: nil, options: nil)
+    base = "#{kubectl} #{options} #{verb} #{resource}"
+    base = "#{base}/#{resource_name}" if resource_name
+    base
+  end
+
+  def kubectl_base_input_command(verb, configuration:, options:)
+    "cat << '#{CAT_MULTILINE}' | #{kubectl} #{options} #{verb} -f - 2>&1\n#{configuration.to_json}\n#{CAT_MULTILINE}"
+  end
+
+  def kubectl
+    "kubectl #{kubectl_options}"
+  end
+
+  def parsed_options(options)
+    options.each_with_object([]) do |(option_name, option_value), arr|
+      next if !KUBECTL_OPTIONS.include?(option_name) || option_value == ''
+
+      arr << "--#{option_name}=#{option_value}"
+    end.join(' ')
+  end
+
+  def parsed_json
+    JSON.load(yield)
+  end
+end