k-tools 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0226a35539e64679a9aea7413be04b860ddba08fde82448467fb0bcb3222b97d
+  data.tar.gz: dc63a32c9eba1d110eca92bd1face84cee59243d049e4d17c7e3f9d7c0754c8b
+SHA512:
+  metadata.gz: 994b074e26c3d39ee9134438dea60b6e6085b1567d07169d7e9874c87f964b6ec92f04c1140689eacecef25c8fc3810096d184aaf58e0eeb6b619494b229dbce
+  data.tar.gz: 5a9a1746418a318674f6ecb1980ab670144972e39459223a7724ff654f5461acc2fe1b8a541577ea99336efe55ccf1b2f03c6bc30ed19311bebd2609a54a63b9

data/bin/kt

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'ktools'
+
+ktools = KTools::Application.new(ARGV)
+ktools.start

data/lib/ktools.rb

@@ -0,0 +1,34 @@
+require 'colorize'
+require 'pry'
+require 'fileutils'
+require 'oj'
+
+require 'ktools/application'
+require 'ktools/configuration'
+require 'ktools/kdb'
+require 'ktools/setup'
+require 'ktools/sh'
+require 'ktools/version'
+
+require 'ktools/tools/deliver'
+require 'ktools/tools/help'
+require 'ktools/tools/spy'
+require 'ktools/tools/swap'
+
+module KTools
+  class << self
+    attr_writer :configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.reset
+    @configuration = Configuration.new
+  end
+
+  def self.configure
+    yield configuration
+  end
+end

data/lib/ktools/application.rb

@@ -0,0 +1,32 @@
+module KTools
+  class Application
+    def initialize(args)
+      Setup.perform unless Setup.done?
+
+      @config = Setup.load
+      @command = args[0]
+      @tail = drop_first_arg(args)
+    end
+
+    def start
+      case @command
+      when 'spy'
+        Tools::Spy.start(@tail)
+      when 'deliver'
+        Tools::Deliver.start(@tail)
+      when 'swap'
+        Tools::Swap.start(@tail)
+      when 'setup'
+        Setup.perform
+      else
+        Tools::Help.display
+      end
+    end
+
+    private
+
+    def drop_first_arg(args)
+      args.drop(1)
+    end
+  end
+end

data/lib/ktools/configuration.rb

@@ -0,0 +1,13 @@
+module KTools
+  LIB_PATH = File.expand_path('../../', __FILE__)
+
+  class Configuration
+    attr_accessor :kpath, :config_file, :kube_path
+
+    def initialize
+      @kpath = "#{Dir.home}/.ktools"
+      @kube_path = "#{Dir.home}/.kube"
+      @config_file = "#{@kpath}/config.json"
+    end
+  end
+end

data/lib/ktools/kdb.rb

@@ -0,0 +1,36 @@
+module KTools
+  class KDB
+    attr_accessor :config_file, :kpath
+
+    def self.read
+      config_file = self.new.config_file
+      return false unless File.exist?(config_file)
+
+      data = File.read(config_file)
+      Oj.load(data)
+    end
+
+    def self.write(data)
+      kdb = self.new
+      kdb.create_path
+
+      File.open(kdb.config_file, 'w') do |f|
+        f.write(Oj.dump(data))
+      end
+    end
+
+    def self.update(current, entry)
+      self.write(current.merge(entry))
+    end
+
+    def initialize
+      @config_file = KTools.configuration.config_file
+      @kpath = KTools.configuration.kpath
+    end
+
+    def create_path
+      return true if File.exist?(@config_file)
+      FileUtils.mkdir_p(@kpath)
+    end
+  end
+end

data/lib/ktools/setup.rb

@@ -0,0 +1,52 @@
+module KTools
+  class Setup
+    def self.done?
+      KDB.read ? true : false
+    end
+
+    def self.load
+      KDB.read
+    end
+
+    def self.perform
+      secrets_path = self.new.get_secrets_path
+      KDB.write({"secrets" => secrets_path})
+
+      puts "Your 'secrets' path was saved as:"
+      puts secrets_path
+
+      puts ""
+      puts "For redefining it you can run:"
+      puts "$ kt setup"
+      puts ""
+
+      exit
+    end
+
+    def initialize; end
+
+    def get_secrets_path
+      path = String.new
+
+      loop do
+        puts "Insert the path for your 'secrets' repository:"
+        puts ""
+        print "#{Dir.home}/"
+
+        input = STDIN.gets.chomp.chomp('/')
+        path = "#{Dir.home}/#{input}"
+        ima_secret_path = "#{path}/.ima_secret"
+
+        puts ""
+
+        if File.file?(ima_secret_path)
+          break
+        else
+          puts "That's a invalid path, try again."
+        end
+      end
+
+      path
+    end
+  end
+end

data/lib/ktools/sh.rb

@@ -0,0 +1,84 @@
+module KTools
+  class Sh
+    # Secure mode, asks for confirmation.
+    # Shows command.
+    # Shows output.
+    def self.ell(cmd)
+      puts "Confirmation required."
+      puts ""
+      puts "Command:"
+      puts cmd
+      puts ""
+
+      print "Y/n: "
+      if "Y" == STDIN.gets.chomp
+        puts ""
+        puts "Running..."
+        puts `#{cmd}`
+      else
+        puts ""
+        puts "Aborted."
+      end
+    end
+
+    # Forced mode, won't ask confirmation.
+    # Shows command.
+    # Shows output.
+    def self.ell!(cmd)
+      puts cmd
+      puts `#{cmd}`
+    end
+
+    # Forced mode, won't ask confirmation.
+    # Won't show command.
+    # Won't show output.
+    # Returns output.
+    def self.elld!(cmd)
+      `#{cmd}`
+    end
+
+    # Forced mode, won't ask confirmation.
+    # Won't show command.
+    # Shows the output.
+    def self.ellb!(cmd)
+      puts `#{cmd}`
+    end
+
+    # Forced mode, won't ask confirmation.
+    # Shows command.
+    # Shows output.
+    # Loops into the output.
+    def self.ell_in!(cmd)
+      puts cmd
+      IO.popen(cmd) do |io|
+        while (line = io.gets) do
+          puts line
+        end
+      end
+    end
+
+    # Forced mode, won't ask confirmation.
+    # It's the meta-shell, or kt-shell mode.
+    # It emulates a shell over Ruby's $stdin/$stdout.
+    def self.ell_meta(cmd)
+      $stdout.print 'Press enter...'
+      started = false
+
+      $stdin.each_line do |line|
+        if started
+          pid = fork {
+            exec line
+          }
+        else
+          started = true
+          pid = fork {
+            exec cmd
+          }
+        end
+
+        Process.wait pid
+        $stdout.print 'kt:shell$ '
+      end
+    end
+  end
+end

data/lib/ktools/tools/deliver.rb

@@ -0,0 +1,84 @@
+module KTools
+  module Tools
+    class Deliver
+      def self.start(args)
+        self.new(args).start
+      end
+
+      def initialize(args)
+        @action = "#{args[0]} #{args[1]}"
+        @subject = args[2]
+        @argument = args[3]
+      end
+
+      def start
+        case @action
+        when 'force deploy'
+          dockerfile = "./Dockerfile"
+          do_fail("Dockerfile?") unless File.exist?(dockerfile)
+
+          registry = "registry.gitlab.com/"
+          origin = Sh.elld!("git config --get remote.origin.url")
+          do_fail("It is a Git repo?") unless origin
+
+          project = origin[/(?<=:)([^.]*)/]
+          do_fail("Can't find your project name.") if project.empty?
+
+          image_tag = "forcedAt#{Time.now.to_i}"
+          image = "#{registry}#{project}:#{image_tag}"
+
+          puts "Forcing deployment..."
+          puts "Project: #{project}"
+          puts "Deployment Name: #{@subject}"
+          puts "Docker Image: #{image}"
+
+          puts ""
+          puts "Ctrl-C to cancel in 5 seconds..."
+          sleep 5
+          puts "Starting..."
+
+          Sh.ell_in!("docker build -t #{image} .")
+          Sh.ell_in!("docker push #{image}")
+
+          Sh.ell_in!("./kdeliver force deploy #{@subject} #{image}")
+        when 'get bash'
+          puts "Opening live Bash..."
+          puts ""
+
+          pod = get_pod
+          container = "#{@subject}-container"
+
+          pod_cmd = "kubectl exec -ti -n default #{pod}"
+          bash_cmd = "-c #{container} /bin/bash"
+
+          Sh.ell_meta("#{pod_cmd} #{bash_cmd}")
+        when 'get logs'
+          puts "Opening live logs..."
+          puts ""
+
+          pod = get_pod
+
+          if @argument == "--tail"
+            Sh.ell_in!("kubectl logs -f #{pod}")
+          else
+            Sh.ell_in!("kubectl logs #{pod}")
+          end
+        else
+          Help.display
+        end
+      end
+
+      private
+
+      def do_fail(cause)
+        puts cause
+        exit 1
+      end
+
+      def get_pod
+        pods = Sh.elld!("kubectl get pods | grep #{@subject}")
+        pods[/(^\S*)/]
+      end
+    end
+  end
+end

data/lib/ktools/tools/help.rb

@@ -0,0 +1,38 @@
+module KTools
+  module Tools
+    class Help
+      def self.display
+        puts logo
+      end
+
+      def self.logo
+        ascii = <<~HEREDOC
+          .----.....``..----...:/``````
+              .----.....``..-----:/+++:....
+              -----.....``..::/++++++o+----
+          `````:+---...-:.`-/++++++++oo/`````
+          ````:++///-:++-./+++++++++oo:......
+          ::::+++++++++-```/o+++++oo+.```````
+          .../+/:/++++o+-.`:+++ooo+:-````````
+          ..:++/+//++oooo+++++++++++.........
+          `:++////++oooooooo+++++++o:........
+          ///:////++oooooooo++++++++o........
+          -:/-./++++++++oo++++++++++o/-------
+          :::..-+++++++++++++++++++++o-......
+          -:..../++++++++++++++++++++o+......
+          `......+++++++++++++++++++++o/:::::
+          .......:++++++++++++++++++++o/.....
+          ......../++++++++++++++++++++s:....
+          ........-++++++++++++//::++++-o:```
+          ........./++++//+/--.-----.:/+/+-..
+          `````````.:++o-.o---.-----.``-+/``-
+          ----------:/+/-:o:-------.````.:+/:
+          :::::::::::/o/-:/.``````.-------+//
+          :::::::::::+/..--........``````./::
+          ----------:+::::-........``````./::
+          ..........++:------------.`````./::
+        HEREDOC
+      end
+    end
+  end
+end

data/lib/ktools/tools/spy.rb

@@ -0,0 +1,109 @@
+module KTools
+  module Tools
+    class Spy
+      def self.start(args)
+        self.new(args).start
+      end
+
+      def initialize(args)
+        @args = args
+        @action = "#{args[0]} #{args[1]}"
+        @subject = args[2]
+        @env = args[3]
+        @cfg = KTools::KDB.read
+      end
+
+      def start
+        case @action
+        when 'drop registry'
+          puts "Deleting Docker Registry for #{@subject}..."
+          puts ""
+
+          registry_name = "#{@subject}-registry"
+
+          Sh.ell("kubectl delete secret #{registry_name}")
+        when 'create registry'
+          puts "Creating Docker Registry for #{@subject}..."
+          puts ""
+
+          registry_name = "#{@subject}-registry"
+          env_path = "#{@cfg["secrets"]}/#{@env}/#{@subject}"
+          env_file = "#{env_path}/registry.json"
+          envd = Oj.load(File.read(env_file))
+
+          kube_cmd = <<~HEREDOC
+            kubectl create secret docker-registry #{registry_name} \
+              --docker-server=#{envd["KSPY_DOCKER_SERVER"]} \
+              --docker-username=#{envd["KSPY_DOCKER_USER"]} \
+              --docker-password=#{envd["KSPY_DOCKER_PASSWORD"]}
+          HEREDOC
+
+          puts Sh.ellb!(kube_cmd)
+        when 'drop config'
+          puts "Deleting configMap for #{@subject}..."
+          puts ""
+
+          config_name = "#{@subject}-config-map"
+
+          Sh.ell("kubectl delete configMap #{config_name}")
+        when 'apply config'
+          puts "Updating/Creating configMap for #{@subject}..."
+
+          unless @env
+            puts ""
+            puts "Please, express the environment."
+            puts "It can be 'production' or 'staging', like:"
+            puts "$ kt spy apply config appslug staging"
+            exit 1
+          end
+
+          env_path = "#{@cfg["secrets"]}/#{@env}/#{@subject}"
+          config_map_file = "#{env_path}/config_map.yml"
+
+          Sh.ell("kubectl apply -f #{config_map_file}")
+        when 'drop ingress'
+          puts "Deleting ingress for #{@subject}..."
+          puts ""
+
+          ingress_name = "#{@subject}-ingress"
+
+          Sh.ell("kubectl delete ingress #{ingress_name}")
+        when 'apply ingress'
+          puts "Updating/Creating ingress for #{@subject}..."
+
+          unless @env
+            puts ""
+            puts "Please, express the environment."
+            puts "It can be 'production' or 'staging', like:"
+            puts "$ kt spy apply ingress appslug staging"
+            exit 1
+          end
+
+          env_path = "#{@cfg["secrets"]}/#{@env}/#{@subject}"
+          ingress_file = "#{env_path}/ingress.yml"
+
+          Sh.ell("kubectl apply -f #{ingress_file}")
+        when 'drop all'
+          puts "Deleting ALL Kubernetes resources of #{@subject}..."
+
+          puts ""
+          puts "Ctrl-C to cancel in 5 seconds..."
+          sleep 5
+          puts "Starting..."
+
+          drop_cmd = <<~HEREDOC
+            kubectl delete deployment #{@subject}-deployment &&
+            kubectl delete configMap #{@subject}-config-map &&
+            kubectl delete ingress #{@subject}-ingress &&
+            kubectl delete service #{@subject}-service &&
+            kubectl delete secret #{@subject}-registry
+          HEREDOC
+
+          Sh.ellb!(drop_cmd)
+        else
+          Help.display
+        end
+      end
+    end
+  end
+end

data/lib/ktools/tools/swap.rb

@@ -0,0 +1,58 @@
+module KTools
+  module Tools
+    class Swap
+      def self.start(args)
+        self.new(args).start
+      end
+
+      def initialize(args)
+        @subject = args[0]
+        @kube_path = KTools.configuration.kube_path
+        @cfg = KTools::KDB.read
+      end
+
+      def start
+        unless @subject
+          files = Dir["#{@kube_path}/*.yml", "#{@kube_path}/*.yaml"]
+
+          files.each do |file|
+            name = File.basename(file).chomp(".yml").chomp(".yaml")
+            if name == @cfg["cluster"]
+              puts "-> #{name}".colorize(:yellow)
+            else
+              puts "- #{name}"
+            end
+          end
+        else
+          c_file = "#{@kube_path}/config"
+          File.delete(c_file) if File.exist?(c_file)
+
+          subject_file = check_subject_file
+          do_fail unless subject_file
+
+          FileUtils.cp(subject_file, c_file)
+          KTools::KDB.update(@cfg, {"cluster" => @subject})
+
+          puts "Swapped to #{@subject}."
+        end
+      end
+
+      private
+
+      def do_fail
+        puts "Can't find this config file."
+        exit 1
+      end
+
+      def check_subject_file
+        yml_file = "#{@kube_path}/#{@subject}.yml"
+        yaml_file = "#{@kube_path}/#{@subject}.yaml"
+
+        return yml_file if File.exist?(yml_file)
+        return yaml_file if File.exist?(yaml_file)
+
+        false
+      end
+    end
+  end
+end

data/lib/ktools/version.rb

@@ -0,0 +1,3 @@
+module KTools
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: k-tools
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Fernando Schuindt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-02-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+description: KTools is used to help manage, deploy and debug applications on Kubernetes
+  environments.
+email:
+- fernando@foxbox.co
+executables:
+- kt
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/kt
+- lib/ktools.rb
+- lib/ktools/application.rb
+- lib/ktools/configuration.rb
+- lib/ktools/kdb.rb
+- lib/ktools/setup.rb
+- lib/ktools/sh.rb
+- lib/ktools/tools/deliver.rb
+- lib/ktools/tools/help.rb
+- lib/ktools/tools/spy.rb
+- lib/ktools/tools/swap.rb
+- lib/ktools/version.rb
+homepage: https://github.com/foxbox-studios/ktools
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: A set of Bash-like tools to manage DO K8s clusters.
+test_files: []