kuber_kit 0.1.9 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b7fcc957995bcc680107ef41f95ef77d5ee20dda2c0063d31e21bf339ccdae2d
-  data.tar.gz: 80561e6e2562b9f195e6725c9dfcd785d36d741b4cf1779c7ccf1d071193c5ec
+  metadata.gz: 88cc2d5d20c0f1bc958f8ecd8682ff66069cd95867b44e717c29adde0378c0c2
+  data.tar.gz: a3ebb9fd30393f45fab0f0ddfcd6aa8569777655a6a407bfe4df653b94e31123
 SHA512:
-  metadata.gz: bd95c6391e1880cbe6e92eb43fc13278da1cef2bcf47c0bd0e2aab66932c640bf8c709dae8df5b36961baf19d41acd6c846907f27cab237a7d37113642d6b8ee
-  data.tar.gz: 433d47c04f1a8f61e55e6dd664ab0818c0e687769cd29e9985acd74886abd2e5f4a2dacede60839c85797d71fa887e1196c61076837f6813c4fb55ac00fc25c2
+  metadata.gz: 275c26b658b4f0739a364bbbc58e1ec03bc45bbeeb7d4dec8988ff8f2f7c598ef43e96a15991f0201c271259380a3949b48dccd6f5f3ab6a88c541f3f38f5a68
+  data.tar.gz: 7f3780629d0836443d20914551b427ce557e35f336c7640a4da6c70eee0380616a4fbeefab23154306254bf6c86693f44388c527ed7e2490139f5210353a2357

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    kuber_kit (0.1.9)
+    kuber_kit (0.2.4)
       cli-ui
       contracts-lite
       dry-auto_inject
@@ -26,7 +26,7 @@ GEM
     dry-container (0.7.2)
       concurrent-ruby (~> 1.0)
       dry-configurable (~> 0.1, >= 0.1.3)
-    dry-core (0.4.9)
+    dry-core (0.4.10)
       concurrent-ruby (~> 1.0)
     dry-equalizer (0.3.0)
     method_source (1.0.0)

data/README.md

@@ -17,13 +17,13 @@ gem 'kuber_kit'
 ### Launch compilation
 
 ```
-bin/kit compile ruby_app,ruby_app2 --path=./example
+bundle exec bin/kit compile ruby_app,ruby_app2 --path=./example
 ```
 
 ### Launch deployment
 
 ```
-bin/kit compile -s ruby_app,ruby_app2 --path=./example
+bundle exec bin/kit compile -s ruby_app,ruby_app2 --path=./example
 ```
 
 

data/TODO.md

@@ -1,3 +1,8 @@
+- find a way to launch job on each run, e.g. for migrations
+- allow setting default configuration for kuberkit using env variable
+- add ability to set container health  checks
+- implement interactive shell.exec!
+- allow deploying only services enabled for specific configuration
 - list services and require confirmation before deployment
 - add build vars support (use images instead of containers)
 - template should be able to set default attributes

data/bin/kit

@@ -2,7 +2,6 @@
 # -*- encoding: utf-8 -*-
 
 require 'rubygems'
-require 'bundler/setup'
 require "kuber_kit"
 
 KuberKit::CLI.start(ARGV)

data/example/services/env_file.rb

@@ -1,6 +1,7 @@
 KuberKit
   .define_service(:env_file)
   .template(:env_file)
+  .tags("env_file")
   .attributes(
     deployment_restart_enabled: false
   )

data/example/services/ruby_app.rb

@@ -1,4 +1,5 @@
 KuberKit
   .define_service(:ruby_app)
   .template(:service)
-  .images(:ruby_app)
+  .images(:ruby_app)
+  .tags("app")

data/lib/kuber_kit.rb

@@ -157,6 +157,7 @@ module KuberKit
     autoload :ServiceDeployer, 'actions/service_deployer'
     autoload :ConfigurationLoader, 'actions/configuration_loader'
     autoload :KubectlApplier, 'actions/kubectl_applier'
+    autoload :KubectlAttacher, 'actions/kubectl_attacher'
   end
 
   module Extensions

data/lib/kuber_kit/actions/configuration_loader.rb

@@ -65,13 +65,17 @@ class KuberKit::Actions::ConfigurationLoader
       configuration_name ||= :_default_
     end
 
+    all_configurations = configuration_store.all_definitions.values
     if configuration_store.count == 1 && configuration_name.nil?
-      first_configurations = configuration_store.all_definitions.values.first
+      first_configurations = all_configurations.first
       configuration_name   = first_configurations.configuration_name
     end
 
     if configuration_store.count > 1 && configuration_name.nil?
-      raise KuberKit::Error, "Please set configuration name using -C option"
+      options = all_configurations.map(&:configuration_name).map(&:to_s)
+      ui.prompt("Please select configuration name (or set it using -C option)", options) do |selection|
+        configuration_name = selection
+      end
     end
 
     KuberKit.set_configuration_name(configuration_name)

data/lib/kuber_kit/actions/kubectl_applier.rb

@@ -7,9 +7,10 @@ class KuberKit::Actions::KubectlApplier
 
   Contract String, Hash => Any
   def call(file_path, options)
-    kubeconfig_path = KuberKit.current_configuration.kubeconfig_path
+    kubeconfig_path  = KuberKit.current_configuration.kubeconfig_path
+    deploy_namespace = KuberKit.current_configuration.deploy_namespace
     ui.create_task("Applying file: #{file_path}") do |task|
-      kubectl_commands.apply_file(local_shell, file_path, kubeconfig_path: kubeconfig_path)
+      kubectl_commands.apply_file(local_shell, file_path, kubeconfig_path: kubeconfig_path, namespace: deploy_namespace)
       task.update_title("Applied file: #{file_path}")
     end
 

data/lib/kuber_kit/actions/kubectl_attacher.rb

@@ -0,0 +1,26 @@
+class KuberKit::Actions::KubectlAttacher
+  include KuberKit::Import[
+    "shell.kubectl_commands",
+    "shell.local_shell",
+    "ui"
+  ]
+
+  Contract String, Hash => Any
+  def call(pod_name, options)
+    kubeconfig_path = KuberKit.current_configuration.kubeconfig_path
+    deploy_namespace = KuberKit.current_configuration.deploy_namespace
+
+    kubectl_commands.exec(
+      local_shell, pod_name, "bash", args: "-it", 
+      kubeconfig_path: kubeconfig_path, 
+      interactive: true,
+      namespace: deploy_namespace
+    )
+
+    true
+  rescue KuberKit::Error => e
+    ui.print_error("Error", e.message)
+    
+    false
+  end
+end

data/lib/kuber_kit/actions/service_deployer.rb

@@ -14,6 +14,10 @@ class KuberKit::Actions::ServiceDeployer
     tags:       Maybe[ArrayOf[String]],
   ] => Any
   def call(services:, tags:)
+    if services.empty? && tags.empty?
+      services, tags = show_tags_selection
+    end
+
     service_names = service_list_resolver.resolve(
       services: services || [],
       tags:     tags || []
@@ -59,4 +63,41 @@ class KuberKit::Actions::ServiceDeployer
   def compile_images(images_names)
     image_compiler.call(images_names, {}) if images_names.any?
   end
+
+  def show_tags_selection()
+    specific_service_option = "deploy specific service"
+
+    tags = [specific_service_option]
+    tags += service_store
+      .all_definitions
+      .values
+      .map(&:to_service_attrs)
+      .map(&:tags)
+      .flatten
+      .uniq
+      .sort
+      .map(&:to_s)
+
+    ui.prompt("Please select which tag to deploy", tags) do |selected_tag|
+      if selected_tag == specific_service_option
+        show_service_selection
+      else
+        return [[], [selected_tag]]
+      end
+    end
+  end
+
+  def show_service_selection()
+    services = service_store
+      .all_definitions
+      .values
+      .map(&:service_name)
+      .uniq
+      .sort
+      .map(&:to_s)
+
+    ui.prompt("Please select which service to deploy", services) do |selected_service|
+      return [[selected_service], []]
+    end
+  end
 end

data/lib/kuber_kit/cli.rb

@@ -14,11 +14,12 @@ class KuberKit::CLI < Thor
     
     image_names = image_names_str.split(",").map(&:strip).map(&:to_sym)
 
-    KuberKit::Container['actions.configuration_loader'].call(options)
-    result = KuberKit::Container['actions.image_compiler'].call(image_names, options)
+    if KuberKit::Container['actions.configuration_loader'].call(options)
+      result = KuberKit::Container['actions.image_compiler'].call(image_names, options)
+    end
 
+    logger = KuberKit::Container['tools.logger']
     if result
-      logger = KuberKit::Container['tools.logger']
       logger.info("---------------------------")
       logger.info("Image compilation finished!")
       logger.info("---------------------------")
@@ -29,47 +30,74 @@ class KuberKit::CLI < Thor
     end
   end
 
+  desc "deploy CONTEXT_NAME", "Deploy CONTEXT_NAME with kubectl"
+  method_option :services,   :type => :array, aliases: ["-s"]
+  method_option :tags,       :type => :array, aliases: ["-t"]
+  def deploy
+    KuberKit.set_debug_mode(options[:debug])
+
+    if KuberKit::Container['actions.configuration_loader'].call(options)
+      result = KuberKit::Container['actions.service_deployer'].call(
+        services: options[:services] || [], 
+        tags:     options[:tags] || []
+      )
+    end
+
+    logger = KuberKit::Container['tools.logger']
+    if result
+      logger.info("---------------------------")
+      logger.info("Service deployment finished!")
+      logger.info("---------------------------")
+    else
+      logger.info("-------------------------".red)
+      logger.info("Service deployment failed!".red)
+      logger.info("-------------------------".red)
+    end
+  end
+
   desc "env ENV_FILE_NAME", "Return content of Env File ENV_FILE_NAME"
   def env(env_file_name)
     KuberKit.set_debug_mode(options[:debug])
 
-    KuberKit::Container['actions.configuration_loader'].call(options)
-    KuberKit::Container['actions.env_file_reader'].call(env_file_name.to_sym, options)
+    if KuberKit::Container['actions.configuration_loader'].call(options)
+      KuberKit::Container['actions.env_file_reader'].call(env_file_name.to_sym, options)
+    end
   end
 
   desc "template TEMPLATE_NAME", "Return content of Template TEMPLATE_NAME"
   def template(template_name)
     KuberKit.set_debug_mode(options[:debug])
 
-    KuberKit::Container['actions.configuration_loader'].call(options)
-    KuberKit::Container['actions.template_reader'].call(template_name.to_sym, options)
+    if KuberKit::Container['actions.configuration_loader'].call(options)
+      KuberKit::Container['actions.template_reader'].call(template_name.to_sym, options)
+    end
   end
 
   desc "service SERVICE_NAME", "Return content of Service SERVICE_NAME"
   def service(service_name)
     KuberKit.set_debug_mode(options[:debug])
 
-    KuberKit::Container['actions.configuration_loader'].call(options)
-    KuberKit::Container['actions.service_reader'].call(service_name.to_sym, options)
+    if KuberKit::Container['actions.configuration_loader'].call(options)
+      KuberKit::Container['actions.service_reader'].call(service_name.to_sym, options)
+    end
   end
 
   desc "apply FILE_PATH", "Apply FILE_PATH with kubectl"
   def apply(file_path)
     KuberKit.set_debug_mode(options[:debug])
 
-    KuberKit::Container['actions.configuration_loader'].call(options)
-    KuberKit::Container['actions.kubectl_applier'].call(File.expand_path(file_path), options)
+    if KuberKit::Container['actions.configuration_loader'].call(options)
+      KuberKit::Container['actions.kubectl_applier'].call(File.expand_path(file_path), options)
+    end
   end
 
-  desc "deploy CONTEXT_NAME", "Deploy CONTEXT_NAME with kubectl"
-  method_option :services,   :type => :array, aliases: ["-s"]
-  method_option :tags,       :type => :array, aliases: ["-t"]
-  def deploy
+  desc "attach POD_NAME", "Attach to POD_NAME with kubectl"
+  def attach(pod_name)
     KuberKit.set_debug_mode(options[:debug])
 
-    KuberKit::Container['actions.configuration_loader'].call(options)
-
-    KuberKit::Container['actions.service_deployer'].call(services: options[:services], tags: options[:tags])
+    if KuberKit::Container['actions.configuration_loader'].call(options)
+      KuberKit::Container['actions.kubectl_attacher'].call(pod_name, options)
+    end
   end
 
   def self.exit_on_failure?

data/lib/kuber_kit/container.rb

@@ -29,6 +29,10 @@ class KuberKit::Container
     KuberKit::Actions::KubectlApplier.new
   end
 
+  register "actions.kubectl_attacher" do
+    KuberKit::Actions::KubectlAttacher.new
+  end
+
   register "configs" do
     KuberKit::Configs.new
   end

data/lib/kuber_kit/core/configuration.rb

@@ -1,6 +1,6 @@
 class KuberKit::Core::Configuration
   attr_reader :name, :artifacts, :registries, :env_files, :templates, :kubeconfig_path, 
-              :deploy_strategy, :services_attributes, :build_servers
+              :deploy_strategy, :deploy_namespace, :services_attributes, :build_servers
 
   Contract KeywordArgs[
     name:            Symbol,
@@ -9,12 +9,13 @@ class KuberKit::Core::Configuration
     env_files:       Hash,
     templates:       Hash,
     kubeconfig_path: Maybe[String],
-    deploy_strategy: Symbol,
+    deploy_strategy:  Symbol,
+    deploy_namespace: Maybe[Symbol],
     services_attributes: HashOf[Symbol => Hash],
     build_servers:   ArrayOf[KuberKit::Core::BuildServers::AbstractBuildServer]
   ] => Any
   def initialize(name:, artifacts:, registries:, env_files:, templates:, kubeconfig_path:, 
-                 deploy_strategy:, services_attributes:, build_servers:)
+                 deploy_strategy:, deploy_namespace:, services_attributes:, build_servers:)
     @name             = name
     @artifacts        = artifacts
     @registries       = registries
@@ -22,6 +23,7 @@ class KuberKit::Core::Configuration
     @templates        = templates
     @kubeconfig_path  = kubeconfig_path
     @deploy_strategy  = deploy_strategy
+    @deploy_namespace = deploy_namespace
     @services_attributes = services_attributes
     @build_servers    = build_servers
   end

data/lib/kuber_kit/core/configuration_definition.rb

@@ -24,9 +24,10 @@ class KuberKit::Core::ConfigurationDefinition
       templates:        @templates,
       kubeconfig_path:  @kubeconfig_path,
       deploy_strategy:  @deploy_strategy,
+      deploy_namespace: @deploy_namespace,
       enabled_services: @enabled_services,
       build_servers:    @build_servers,
-      services_attributes: @services_attributes
+      services_attributes: @services_attributes,
     )
   end
 
@@ -80,6 +81,12 @@ class KuberKit::Core::ConfigurationDefinition
     self
   end
 
+  def deploy_namespace(namespace)
+    @deploy_namespace = namespace
+
+    self
+  end
+
   def deploy_strategy(path)
     @deploy_strategy = path
 

data/lib/kuber_kit/core/configuration_factory.rb

@@ -27,6 +27,7 @@ class KuberKit::Core::ConfigurationFactory
       templates:        templates,
       kubeconfig_path:  configuration_attrs.kubeconfig_path,
       deploy_strategy:  configuration_attrs.deploy_strategy || configs.deploy_strategy,
+      deploy_namespace: configuration_attrs.deploy_namespace,
       services_attributes: configuration_attrs.services_attributes,
       build_servers:    build_servers
     )

data/lib/kuber_kit/core/service.rb

@@ -1,21 +1,23 @@
 class KuberKit::Core::Service
   AttributeNotSet = Class.new(Indocker::Error)
 
-  attr_reader :name, :template_name, :tags, :images, :attributes
+  attr_reader :name, :template_name, :tags, :images, :attributes, :deploy_strategy
 
   Contract KeywordArgs[
-    name:           Symbol,
-    template_name:  Symbol,
-    tags:           ArrayOf[Symbol],
-    images:         ArrayOf[Symbol],
-    attributes:     HashOf[Symbol => Any],
+    name:             Symbol,
+    template_name:    Symbol,
+    tags:             ArrayOf[Symbol],
+    images:           ArrayOf[Symbol],
+    attributes:       HashOf[Symbol => Any],
+    deploy_strategy:  Maybe[Symbol]
   ] => Any
-  def initialize(name:, template_name:, tags:, images:, attributes:)
+  def initialize(name:, template_name:, tags:, images:, attributes:, deploy_strategy:)
     @name = name
     @template_name = template_name
     @tags = tags
     @images = images
     @attributes = attributes
+    @deploy_strategy = deploy_strategy
   end
 
   def uri

data/lib/kuber_kit/core/service_definition.rb

@@ -8,11 +8,12 @@ class KuberKit::Core::ServiceDefinition
 
   def to_service_attrs
     OpenStruct.new(
-      name:           @service_name,
-      template_name:  get_value(@template_name),
-      tags:           Array(get_value(@tags)).map(&:to_sym),
-      images:         Array(get_value(@images)).map(&:to_sym),
-      attributes:     get_value(@attributes),
+      name:             @service_name,
+      template_name:    get_value(@template_name),
+      tags:             Array(get_value(@tags)).map(&:to_sym),
+      images:           Array(get_value(@images)).map(&:to_sym),
+      attributes:       get_value(@attributes),
+      deploy_strategy:  get_value(@deploy_strategy),
     )
   end
 
@@ -40,6 +41,12 @@ class KuberKit::Core::ServiceDefinition
     self
   end
 
+  def deploy_strategy(value = nil, &block)
+    @deploy_strategy = block_given? ? block : value
+
+    self
+  end
+
   private
     def get_value(variable)
       variable.is_a?(Proc) ? variable.call : variable

data/lib/kuber_kit/core/service_factory.rb

@@ -12,11 +12,12 @@ class KuberKit::Core::ServiceFactory
     attributes = (service_attrs.attributes || {}).merge(configuration_attributes)
 
     KuberKit::Core::Service.new(
-      name:           service_attrs.name,
-      template_name:  service_attrs.template_name,
-      tags:           service_attrs.tags,
-      images:         service_attrs.images,
-      attributes:     attributes
+      name:             service_attrs.name,
+      template_name:    service_attrs.template_name,
+      tags:             service_attrs.tags,
+      images:           service_attrs.images,
+      attributes:       attributes,
+      deploy_strategy:  service_attrs.deploy_strategy,
     )
   end
 end

data/lib/kuber_kit/image_compiler/build_server_pool.rb

@@ -4,12 +4,15 @@ class KuberKit::ImageCompiler::BuildServerPool
   def initialize(local_shell:, build_servers:, ssh_shell_class:)
     @local_shell     = local_shell
     @ssh_shell_class = ssh_shell_class
-    @ssh_shells      = connect_to_ssh_shells(build_servers)
+    @build_servers   = build_servers
+    @ssh_shells      = []
   end
 
   def get_shell
-    if @ssh_shells.any?
-      @ssh_shells.sample
+    if @build_servers.any?
+      shell = connect_to_ssh_shell(@build_servers.sample)
+      @ssh_shells << shell
+      shell
     else
       @local_shell
     end
@@ -20,11 +23,9 @@ class KuberKit::ImageCompiler::BuildServerPool
   end
 
   private
-    def connect_to_ssh_shells(build_servers)
-      build_servers.map do |bs|
-        shell = @ssh_shell_class.new
-        shell.connect(host: bs.host, user: bs.user, port: bs.port)
-        shell
-      end
+    def connect_to_ssh_shell(bs)
+      shell = @ssh_shell_class.new
+      shell.connect(host: bs.host, user: bs.user, port: bs.port)
+      shell
     end
 end

data/lib/kuber_kit/service_deployer/strategies/kubernetes.rb

@@ -11,13 +11,15 @@ class KuberKit::ServiceDeployer::Strategies::Kubernetes < KuberKit::ServiceDeplo
     config_path    = "#{configs.service_config_dir}/#{service.name}.yml"
     shell.write(config_path, service_config)
 
-    kubeconfig_path = KuberKit.current_configuration.kubeconfig_path
-    kubectl_commands.apply_file(shell, config_path, kubeconfig_path: kubeconfig_path)
+    kubeconfig_path  = KuberKit.current_configuration.kubeconfig_path
+    deploy_namespace = KuberKit.current_configuration.deploy_namespace
+
+    kubectl_commands.apply_file(shell, config_path, kubeconfig_path: kubeconfig_path, namespace: deploy_namespace)
 
     deployment_restart_enabled = service.attribute(:deployment_restart_enabled, default: true)
     deployment_restart_name    = service.attribute(:deployment_restart_name, default: service.uri)
     if deployment_restart_enabled
-      kubectl_commands.rolling_restart(shell, deployment_restart_name, kubeconfig_path: kubeconfig_path)
+      kubectl_commands.rolling_restart(shell, deployment_restart_name, kubeconfig_path: kubeconfig_path, namespace: deploy_namespace)
     end
   end
 end

data/lib/kuber_kit/service_deployer/strategy_detector.rb

@@ -1,6 +1,6 @@
 class KuberKit::ServiceDeployer::StrategyDetector
   Contract KuberKit::Core::Service => Symbol
   def call(service)
-    KuberKit.current_configuration.deploy_strategy
+    service.deploy_strategy || KuberKit.current_configuration.deploy_strategy
   end
 end

data/lib/kuber_kit/shell/commands/kubectl_commands.rb

@@ -2,18 +2,52 @@ require 'json'
 require 'shellwords'
 
 class KuberKit::Shell::Commands::KubectlCommands
-  def apply_file(shell, file_path, kubeconfig_path: nil)
+  def kubectl_run(shell, command_list, kubeconfig_path: nil, namespace: nil, interactive: false)
     command_parts = []
     if kubeconfig_path
       command_parts << "KUBECONFIG=#{kubeconfig_path}"
     end
 
-    command_parts << "kubectl apply -f #{file_path}"
+    command_parts << "kubectl"
 
-    shell.exec!(command_parts.join(" "))
+    if namespace
+      command_parts << "-n #{namespace}"
+    end
+
+    command_parts += Array(command_list)
+
+    # TODO: investigate how to do it with shell.
+    if interactive
+      system(command_parts.join(" "))
+    else
+      shell.exec!(command_parts.join(" "))
+    end
+  end
+  
+  def apply_file(shell, file_path, kubeconfig_path: nil, namespace: nil)
+    kubectl_run(shell, "apply -f #{file_path}", kubeconfig_path: kubeconfig_path, namespace: namespace)
   end
 
-  def rolling_restart(shell, deployment_name, kubeconfig_path: nil)
+  def exec(shell, pod_name, command, args: nil, kubeconfig_path: nil, interactive: false, namespace: nil)
+    command_parts = []
+    command_parts << "exec"
+
+    if args
+      command_parts << args
+    end
+
+    command_parts << pod_name
+    command_parts << "-- #{command}"
+    kubectl_run(shell, command_parts, kubeconfig_path: kubeconfig_path, interactive: interactive, namespace: namespace)
+  end
+
+  def delete_resource(shell, resource_type, resource_name, kubeconfig_path: nil, namespace: nil)
+    command = %Q{delete #{resource_type} #{resource_name}}
+
+    kubectl_run(shell, command, kubeconfig_path: kubeconfig_path, namespace: namespace)
+  end
+
+  def rolling_restart(shell, deployment_name, kubeconfig_path: nil, namespace: nil)
     patch_deployment(shell, deployment_name, {
       spec: {
         template: {
@@ -24,19 +58,14 @@ class KuberKit::Shell::Commands::KubectlCommands
           }
         }
       }
-    }, kubeconfig_path: kubeconfig_path)
+    }, kubeconfig_path: kubeconfig_path, namespace: namespace)
   end
 
-  def patch_deployment(shell, deployment_name, specs, kubeconfig_path: nil)
-    command_parts = []
-    if kubeconfig_path
-      command_parts << "KUBECONFIG=#{kubeconfig_path}"
-    end
-
+  def patch_deployment(shell, deployment_name, specs, kubeconfig_path: nil, namespace: nil)
     specs_json = JSON.dump(specs).gsub('"', '\"')
 
-    command_parts << %Q{kubectl patch deployment #{deployment_name} -p "#{specs_json}"}
+    command = %Q{patch deployment #{deployment_name} -p "#{specs_json}"}
 
-    shell.exec!(command_parts.join(" "))
+    kubectl_run(shell, command, kubeconfig_path: kubeconfig_path, namespace: namespace)
   end
 end

data/lib/kuber_kit/shell/commands/rsync_commands.rb

@@ -1,5 +1,5 @@
 class KuberKit::Shell::Commands::RsyncCommands
-  def rsync(shell, source_path, target_path, target_host: nil, exclude: nil)
+  def rsync(shell, source_path, target_path, target_host: nil, exclude: nil, delete: true)
     # Add a trailing slash to directory to have behavior similar to CP command
     if path_is_directory?(source_path) && !source_path.end_with?("/")
       source_path = "#{source_path}/"
@@ -13,7 +13,13 @@ class KuberKit::Shell::Commands::RsyncCommands
 
     args = [source_path, destination]
     if exclude
-      args << "--exclude=#{exclude}"
+      Array(exclude).each do |e|
+        args << "--exclude=#{e}"
+      end
+    end
+
+    if delete
+      args << "--delete"
     end
 
     shell.exec!(%Q{rsync -a #{args.join(' ')}})

data/lib/kuber_kit/shell/local_shell.rb

@@ -30,8 +30,8 @@ class KuberKit::Shell::LocalShell < KuberKit::Shell::AbstractShell
     result
   end
 
-  def sync(local_path, remote_path, exclude: nil)
-    rsync_commands.rsync(self, local_path, remote_path, exclude: exclude)
+  def sync(local_path, remote_path, exclude: nil, delete: true)
+    rsync_commands.rsync(self, local_path, remote_path, exclude: exclude, delete: delete)
   end
 
   def read(file_path)

data/lib/kuber_kit/shell/ssh_session.rb

@@ -56,5 +56,7 @@ class KuberKit::Shell::SshSession
     end
 
     stdout_data
+  rescue Net::SSH::Exception => e
+    raise SshSessionError, "Shell command failed: #{command}\r\n#{e.message}"
   end
 end

data/lib/kuber_kit/shell/ssh_shell.rb

@@ -38,11 +38,12 @@ class KuberKit::Shell::SshShell < KuberKit::Shell::LocalShell
     raise ShellError.new(e.message)
   end
 
-  def sync(local_path, remote_path, exclude: nil)
+  def sync(local_path, remote_path, exclude: nil, delete: true)
     rsync_commands.rsync(
       local_shell, local_path, remote_path, 
       target_host: "#{ssh_session.user}@#{ssh_session.host}",
-      exclude:     exclude
+      exclude:     exclude,
+      delete:      delete
     )
   end
 

data/lib/kuber_kit/ui/interactive.rb

@@ -26,6 +26,14 @@ class KuberKit::UI::Interactive
     print_in_frame(title, text, color: :yellow)
   end
 
+  def prompt(text, options, &callback)
+    CLI::UI::Prompt.ask(text) do |handler|
+      options.each do |option|
+        handler.option(option, &callback)
+      end
+    end
+  end
+
   private
     def init
       @initialized = true

data/lib/kuber_kit/ui/simple.rb

@@ -68,6 +68,12 @@ class KuberKit::UI::Simple
     print_text(title, text, color: String::Colors::YELLOW)
   end
 
+  def prompt(text, options, &callback)
+    print_info("Select", text)
+    result = $stdin.gets.chomp
+    callback.call(result)
+  end
+
   private
     def print_text(title, text, color:)
       puts "#{title.colorize(color)}\r\n #{text.colorize(color)}"

data/lib/kuber_kit/version.rb

@@ -1,3 +1,3 @@
 module KuberKit
-  VERSION = "0.1.9"
-end
+  VERSION = "0.2.4"
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kuber_kit
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.2.4
 platform: ruby
 authors:
 - Iskander Khaziev
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-13 00:00:00.000000000 Z
+date: 2020-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: contracts-lite
@@ -187,6 +187,7 @@ files:
 - lib/kuber_kit/actions/env_file_reader.rb
 - lib/kuber_kit/actions/image_compiler.rb
 - lib/kuber_kit/actions/kubectl_applier.rb
+- lib/kuber_kit/actions/kubectl_attacher.rb
 - lib/kuber_kit/actions/service_deployer.rb
 - lib/kuber_kit/actions/service_reader.rb
 - lib/kuber_kit/actions/template_reader.rb
@@ -282,7 +283,7 @@ homepage: https://github.com/ArtStation/kuber_kit
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -298,7 +299,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.0.8
-signing_key:
+signing_key: 
 specification_version: 4
 summary: Docker Containers Build & Deployment
 test_files: []