kuber_kit 0.2.3 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3acad6e0224702a4f70ae02d93c16bc766e1e36d75ee33cbc5d2fb15118d35e
-  data.tar.gz: 8903414dfacb859f883298b21ac2d30dd08e93597044e325b253c0f5cd5c8709
+  metadata.gz: 4caab78fa6712fb2e509f29078f209fe491f35973a973a941143feed08f41d1c
+  data.tar.gz: 4aa7e98355e2e961d963026c640422a4d90deb802a0ffadfd4d938781527ab7f
 SHA512:
-  metadata.gz: e5c368de0b96bfd89f80004d1c4fa0a0a5355c6116768fd0b86d7eb0191719ba11b646b1e202f40c08276d06bfb50d423659cb49a488f9573788a51638273cdc
-  data.tar.gz: c0da8c721a80b02b41ee4c6430c175678f792271c3e9f10fba55784e7ea7f8013ffd09b989c043a723c234350340347176ab5c59541e3e1b9b98ebb60f6800dc
+  metadata.gz: '08ad78c315e7e7900f668707f96ea61e9a200f90c5ae7f9d94a54835540a697549e763692c73734631f03df2d76c53d9eef7bff4e019a003b23b63baf3499902'
+  data.tar.gz: e347e3b630580b7476fa67a4434ef870b897979d2322a73e32027346933be12f37b7f1212426e9e806833074e7c3cb655b5bed930c6556c30f1288ec49dec45d

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    kuber_kit (0.2.3)
+    kuber_kit (0.2.8)
       cli-ui
       contracts-lite
       dry-auto_inject

data/TODO.md

@@ -1,5 +1,6 @@
-- find a way to launch job on each run, e.g. for migrations
+- find a way to always deploy some service, e.g. for migrations and env_files
 - 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

data/example/config.rb

@@ -0,0 +1,3 @@
+KuberKit.configure do |config|
+  config.kuber_kit_min_version = "0.2.0"
+end

data/lib/kuber_kit.rb

@@ -57,6 +57,7 @@ module KuberKit
       autoload :ImageHelper, 'core/context_helper/image_helper'
       autoload :ServiceHelper, 'core/context_helper/service_helper'
       autoload :ContextHelperFactory, 'core/context_helper/context_helper_factory'
+      autoload :ContextArgs, 'core/context_helper/context_args'
     end
 
     module Registries
@@ -127,9 +128,13 @@ module KuberKit
   end
 
   module TemplateReader
+    autoload :ActionHandler, 'template_reader/action_handler'
     autoload :Reader, 'template_reader/reader'
-    autoload :AbstractTemplateReader, 'template_reader/abstract_template_reader'
-    autoload :ArtifactFileReader, 'template_reader/artifact_file_reader'
+
+    module Strategies
+      autoload :Abstract, 'template_reader/strategies/abstract'
+      autoload :ArtifactFile, 'template_reader/strategies/artifact_file'
+    end
   end
 
   module ServiceDeployer
@@ -141,6 +146,7 @@ module KuberKit
     module Strategies
       autoload :Abstract, 'service_deployer/strategies/abstract'
       autoload :Kubernetes, 'service_deployer/strategies/kubernetes'
+      autoload :KubernetesRunner, 'service_deployer/strategies/kubernetes_runner'
     end
   end
 
@@ -169,9 +175,9 @@ module KuberKit
     autoload :Simple, 'ui/simple'
   end
 
-  autoload :Configs, 'configs'
   autoload :CLI, 'cli'
   autoload :Container, 'container'
+  autoload :Configs, 'configs'
 
   Import = Dry::AutoInject(Container)
 
@@ -210,6 +216,10 @@ module KuberKit
       @current_configuration ||= Container['core.configuration_store'].get_configuration(@configuration_name)
     end
 
+    def global_build_vars
+      KuberKit::Core::ContextHelper::ContextArgs.new(current_configuration.global_build_vars)
+    end
+
     def add_registry(registry)
       Container["core.registry_store"].add(registry)
     end
@@ -233,6 +243,10 @@ module KuberKit
     def build_helper(&proc)
       KuberKit::Core::ContextHelper::BaseHelper.class_exec(&proc)
     end
+
+    def configure(&proc)
+      yield(Container["configs"])
+    end
   end
 end
 

data/lib/kuber_kit/actions/configuration_loader.rb

@@ -1,4 +1,6 @@
 class KuberKit::Actions::ConfigurationLoader
+  APP_CONFIG_FILENAME = "config.rb".freeze
+
   include KuberKit::Import[
     "core.registry_store",
     "core.image_store",
@@ -14,6 +16,13 @@ class KuberKit::Actions::ConfigurationLoader
   Contract Hash => Any
   def call(options)
     root_path     = options[:path] || File.join(Dir.pwd, configs.kuber_kit_dirname)
+
+    # require config file first, in case if other dirs are overriden in config
+    config_file_path = File.join(root_path, APP_CONFIG_FILENAME)
+    if File.exists?(config_file_path)
+      require config_file_path
+    end
+
     images_path   = options[:images_path] || File.join(root_path, configs.images_dirname)
     services_path = options[:services_path] || File.join(root_path, configs.services_dirname)
     infra_path    = options[:infra_path]  || File.join(root_path, configs.infra_dirname)
@@ -32,6 +41,10 @@ class KuberKit::Actions::ConfigurationLoader
       ui.print_warning "WARNING", "KuberKit root path #{root_path} doesn't exist. You may want to pass it --path parameter."
     end
 
+    if Gem::Version.new(KuberKit::VERSION) < Gem::Version.new(configs.kuber_kit_min_version)
+      raise KuberKit::Error, "The minimal required kuber_kit version is #{configs.kuber_kit_min_version}"
+    end
+
     load_configurations(configurations_path, configuration_name)
     load_infrastructure(infra_path)
 

data/lib/kuber_kit/actions/service_deployer.rb

@@ -68,7 +68,15 @@ class KuberKit::Actions::ServiceDeployer
     specific_service_option = "deploy specific service"
 
     tags = [specific_service_option]
-    tags += service_store.all_definitions.values.map(&:to_service_attrs).map(&:tags).flatten.uniq.map(&:to_s)
+    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
@@ -80,7 +88,13 @@ class KuberKit::Actions::ServiceDeployer
   end
 
   def show_service_selection()
-    services = service_store.all_definitions.values.map(&:service_name).uniq.map(&:to_s)
+    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], []]

data/lib/kuber_kit/actions/template_reader.rb

@@ -1,16 +1,13 @@
 class KuberKit::Actions::TemplateReader
   include KuberKit::Import[
-    "core.template_store",
-    "template_reader.reader",
     "shell.local_shell",
-    "ui"
+    "ui",
+    template_reader: "template_reader.action_handler",
   ]
 
   Contract Symbol, Hash => Any
   def call(template_name, options)
-    template = template_store.get(template_name)
-
-    result = reader.read(local_shell, template)
+    result = template_reader.call(local_shell, template_name)
 
     ui.print_info(template_name.to_s, result)
 

data/lib/kuber_kit/configs.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 class KuberKit::Configs
-  IMAGE_DOCKERFILE_NAME = "Dockerfile".freeze
-  IMAGE_BUILD_CONTEXT_DIR = "build_context".freeze
-  IMAGE_TAG = 'latest'.freeze
-  IMAGE_COMPILE_DIR = "/tmp/kuber_kit/image_builds"
+  AVAILABLE_CONFIGS = [
+    :image_dockerfile_name, :image_build_context_dir, :image_tag, :docker_ignore_list, :image_compile_dir, 
+    :kuber_kit_dirname, :kuber_kit_min_version, :images_dirname, :services_dirname, :infra_dirname, :configurations_dirname,
+    :artifact_clone_dir, :service_config_dir, :deploy_strategy, :compile_simultaneous_limit
+  ]
   DOCKER_IGNORE_LIST = [
     'Dockerfile',
     '.DS_Store',
@@ -14,35 +17,60 @@ class KuberKit::Configs
     'tmp',
     'logs'
   ]
-  KUBER_KIT_DIRNAME           = "kuber_kit".freeze
-  IMAGES_DIRNAME              = "images".freeze
-  SERVICES_DIRNAME            = "services".freeze
-  INFRA_DIRNAME               = "infrastructure".freeze
-  CONFIGURATIONS_DIRNAME      = "configurations".freeze
-  ARTIFACT_CLONE_DIR          = "/tmp/kuber_kit/artifacts"
-  SERVICE_CONFIG_DIR          = "/tmp/kuber_kit/services"
-  DEPLOY_STRATEGY             = :kubernetes
-  COMPILE_SIMULTANEOUS_LIMIT  = 5
-
-  attr_accessor :image_dockerfile_name, :image_build_context_dir, :image_tag,
-                :docker_ignore_list, :image_compile_dir, 
-                :kuber_kit_dirname, :images_dirname, :services_dirname, :infra_dirname, :configurations_dirname,
-                :artifact_clone_dir, :service_config_dir, :deploy_strategy, :compile_simultaneous_limit
+
+  AVAILABLE_CONFIGS.each do |config_name|
+    define_method(config_name) do
+      get(config_name.to_sym)
+    end
+
+    define_method(:"#{config_name}=") do |value|
+      set(config_name.to_sym, value)
+    end
+  end
 
   def initialize
-    @image_dockerfile_name      = IMAGE_DOCKERFILE_NAME
-    @image_build_context_dir    = IMAGE_BUILD_CONTEXT_DIR
-    @image_tag                  = IMAGE_TAG
-    @image_compile_dir          = IMAGE_COMPILE_DIR
-    @docker_ignore_list         = DOCKER_IGNORE_LIST
-    @kuber_kit_dirname          = KUBER_KIT_DIRNAME
-    @images_dirname             = IMAGES_DIRNAME
-    @services_dirname           = SERVICES_DIRNAME
-    @infra_dirname              = INFRA_DIRNAME
-    @configurations_dirname     = CONFIGURATIONS_DIRNAME
-    @artifact_clone_dir         = ARTIFACT_CLONE_DIR
-    @service_config_dir         = SERVICE_CONFIG_DIR
-    @deploy_strategy            = DEPLOY_STRATEGY
-    @compile_simultaneous_limit = COMPILE_SIMULTANEOUS_LIMIT
+    add_default_configs unless items.any?
+  end
+
+  def add_default_configs
+    set :image_dockerfile_name,   "Dockerfile"
+    set :image_build_context_dir, "build_context"
+    set :image_tag,               'latest'
+    set :image_compile_dir,       "/tmp/kuber_kit/image_builds"
+    set :docker_ignore_list,      DOCKER_IGNORE_LIST
+    set :kuber_kit_dirname,       "kuber_kit"
+    set :kuber_kit_min_version,   KuberKit::VERSION
+    set :images_dirname,          "images"
+    set :services_dirname,        "services"
+    set :infra_dirname,           "infrastructure"
+    set :configurations_dirname,  "configurations"
+    set :artifact_clone_dir,      "/tmp/kuber_kit/artifacts"
+    set :service_config_dir,      "/tmp/kuber_kit/services"
+    set :deploy_strategy,         :kubernetes
+    set :compile_simultaneous_limit, 5
+  end
+
+  def items
+    @@items ||= {}
+  end
+
+  def set(key, value)
+    unless AVAILABLE_CONFIGS.include?(key)
+      raise ArgumentError, "#{key} is not a valid configuration key"
+    end
+
+    items[key] = value
+  end
+
+  def get(key)
+    unless AVAILABLE_CONFIGS.include?(key)
+      raise ArgumentError, "#{key} is not a valid configuration key"
+    end
+
+    items[key]
+  end
+
+  def reset!
+    @@items = {}
   end
 end

data/lib/kuber_kit/container.rb

@@ -197,12 +197,16 @@ class KuberKit::Container
     KuberKit::EnvFileReader::Strategies::ArtifactFile.new
   end
 
+  register "template_reader.action_handler" do
+    KuberKit::TemplateReader::ActionHandler.new
+  end
+
   register "template_reader.reader" do
     KuberKit::TemplateReader::Reader.new
   end
 
-  register "template_reader.artifact_file_reader" do
-    KuberKit::TemplateReader::ArtifactFileReader.new
+  register "template_reader.strategies.artifact_file" do
+    KuberKit::TemplateReader::Strategies::ArtifactFile.new
   end
 
   register "service_deployer.action_handler" do
@@ -225,6 +229,10 @@ class KuberKit::Container
     KuberKit::ServiceDeployer::Strategies::Kubernetes.new
   end
 
+  register "service_deployer.strategies.kubernetes_runner" do
+    KuberKit::ServiceDeployer::Strategies::KubernetesRunner.new
+  end
+
   register "service_reader.action_handler" do
     KuberKit::ServiceReader::ActionHandler.new
   end

data/lib/kuber_kit/core/configuration.rb

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

data/lib/kuber_kit/core/configuration_definition.rb

@@ -27,7 +27,8 @@ class KuberKit::Core::ConfigurationDefinition
       deploy_namespace: @deploy_namespace,
       enabled_services: @enabled_services,
       build_servers:    @build_servers,
-      services_attributes: @services_attributes,
+      services_attributes:  @services_attributes,
+      global_build_vars:    @global_build_vars,
     )
   end
 
@@ -99,4 +100,10 @@ class KuberKit::Core::ConfigurationDefinition
 
     self
   end
+
+  def global_build_vars(variables)
+    @global_build_vars = variables
+
+    self
+  end
 end

data/lib/kuber_kit/core/configuration_factory.rb

@@ -28,8 +28,9 @@ class KuberKit::Core::ConfigurationFactory
       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
+      build_servers:    build_servers,
+      services_attributes:  configuration_attrs.services_attributes,
+      global_build_vars:    configuration_attrs.global_build_vars || {},
     )
   end
 

data/lib/kuber_kit/core/context_helper/base_helper.rb

@@ -29,6 +29,10 @@ class KuberKit::Core::ContextHelper::BaseHelper
     KuberKit.current_configuration.name
   end
 
+  def global_build_vars
+    KuberKit.global_build_vars
+  end
+
   def get_binding
     binding
   end

data/lib/kuber_kit/core/context_helper/context_args.rb

@@ -0,0 +1,39 @@
+class KuberKit::Core::ContextHelper::ContextArgs
+  attr_reader :parent, :parent_name
+
+  def initialize(context_args, parent_name = nil, parent = nil)
+    @context_args = context_args
+    @parent_name  = parent_name
+    @parent = parent
+  end
+
+  def method_missing(name, *args)
+    if args.size > 0
+      raise ArgumentError.new("context args does not accept any arguments")
+    end
+
+    value = @context_args.fetch(name) do
+      raise(KuberKit::Error, "build arg '#{format_arg(name)}' is not defined, available args: #{@context_args.inspect}")
+    end
+
+    if value.is_a?(Hash)
+      return self.class.new(value, name, self)
+    end
+
+    value
+  end
+
+  private
+
+  def format_arg(name)
+    string = [@parent_name, name].compact.join(".")
+    parent = @parent
+
+    while parent do
+      string = [parent.parent_name, string].compact.join(".")
+      parent = parent.parent
+    end
+
+    string
+  end
+end

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/env_file_reader/reader.rb

@@ -5,6 +5,11 @@ class KuberKit::EnvFileReader::Reader
     "env_file_reader.strategies.artifact_file",
   ]
 
+  def initialize(**injected_deps)
+    super(injected_deps)
+    add_default_strategies
+  end
+
   def use_reader(env_file_reader, env_file_class:)
     @@readers ||= {}
 
@@ -16,8 +21,6 @@ class KuberKit::EnvFileReader::Reader
   end
 
   def read(shell, env_file)
-    add_default_readers
-
     reader = @@readers[env_file.class]
 
     raise ReaderNotFoundError, "Can't find reader for env file #{env_file}" if reader.nil?
@@ -25,11 +28,12 @@ class KuberKit::EnvFileReader::Reader
     reader.read(shell, env_file)
   end
 
-  def add_default_readers
-    use_reader(artifact_file, env_file_class: KuberKit::Core::EnvFiles::ArtifactFile)
-  end
-
   def reset!
     @@readers = {}
   end
+
+  private
+    def add_default_strategies
+      use_reader(artifact_file, env_file_class: KuberKit::Core::EnvFiles::ArtifactFile)
+    end
 end

data/lib/kuber_kit/service_deployer/deployer.rb

@@ -3,9 +3,15 @@ class KuberKit::ServiceDeployer::Deployer
 
   include KuberKit::Import[
     "core.service_store",
-    "service_deployer.strategies.kubernetes"
+    "service_deployer.strategies.kubernetes",
+    "service_deployer.strategies.kubernetes_runner"
   ]
 
+  def initialize(**injected_deps)
+    super(injected_deps)
+    add_default_strategies
+  end
+
   def register_strategy(strategy_name, strategy)
     @@strategies ||= {}
 
@@ -18,8 +24,6 @@ class KuberKit::ServiceDeployer::Deployer
 
   Contract KuberKit::Shell::AbstractShell, KuberKit::Core::Service, Symbol => Any
   def deploy(shell, service, strategy_name)
-    add_default_strategies
-
     deployer = @@strategies[strategy_name]
 
     raise StrategyNotFoundError, "Can't find strategy with name #{strategy_name}" if deployer.nil?
@@ -27,11 +31,13 @@ class KuberKit::ServiceDeployer::Deployer
     deployer.deploy(shell, service)
   end
 
-  def add_default_strategies
-    register_strategy(:kubernetes, kubernetes)
-  end
-
   def reset!
     @@strategies = {}
   end
+
+  private
+    def add_default_strategies
+      register_strategy(:kubernetes, kubernetes)
+      register_strategy(:kubernetes_runner, kubernetes_runner)
+    end
 end

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

@@ -0,0 +1,35 @@
+class KuberKit::ServiceDeployer::Strategies::KubernetesRunner < KuberKit::ServiceDeployer::Strategies::Abstract
+  include KuberKit::Import[
+    "service_reader.reader",
+    "shell.kubectl_commands",
+    "configs",
+  ]
+
+  Contract KuberKit::Shell::AbstractShell, KuberKit::Core::Service => Any
+  def deploy(shell, service)
+    service_config = reader.read(shell, service)
+    config_path    = "#{configs.service_config_dir}/#{service.name}.yml"
+    shell.write(config_path, service_config)
+
+    kubeconfig_path  = KuberKit.current_configuration.kubeconfig_path
+    deploy_namespace = KuberKit.current_configuration.deploy_namespace
+
+    deployment_resource_name  = service.attribute(:deployment_resource_name, default: service.uri)
+    deployment_resource_type  = service.attribute(:deployment_resource_type, default: "job")
+
+    deployment_delete_enabled = service.attribute(:deployment_delete_enabled, default: true)
+    if deployment_delete_enabled
+      delete_resource_if_exists(shell, deployment_resource_type, deployment_resource_name, kubeconfig_path: kubeconfig_path, namespace: deploy_namespace)
+    end
+
+    kubectl_commands.apply_file(shell, config_path, kubeconfig_path: kubeconfig_path, namespace: deploy_namespace)
+  end
+
+  private
+    def delete_resource_if_exists(shell, resource_type, resource_name, kubeconfig_path:, namespace: )
+      unless kubectl_commands.resource_exists?(shell, resource_type, resource_name, kubeconfig_path: kubeconfig_path, namespace: namespace)
+        return false
+      end
+      kubectl_commands.delete_resource(shell, resource_type, resource_name, kubeconfig_path: kubeconfig_path, namespace: namespace)
+    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

@@ -41,6 +41,23 @@ class KuberKit::Shell::Commands::KubectlCommands
     kubectl_run(shell, command_parts, kubeconfig_path: kubeconfig_path, interactive: interactive, namespace: namespace)
   end
 
+  def resource_exists?(shell, resource_type, resource_name, kubeconfig_path: nil, namespace: nil)
+    result = find_resources(shell, resource_type, resource_name, kubeconfig_path: kubeconfig_path, namespace: namespace)
+    result && result != ""
+  end
+
+  def find_resources(shell, resource_type, resource_name, jsonpath: ".items[*].metadata.name", kubeconfig_path: nil, namespace: nil)
+    command = %Q{get #{resource_type} --field-selector=metadata.name=#{resource_name} -o jsonpath='{#{jsonpath}}'}
+
+    kubectl_run(shell, command, kubeconfig_path: kubeconfig_path, 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: {

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_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/template_reader/action_handler.rb

@@ -0,0 +1,13 @@
+class KuberKit::TemplateReader::ActionHandler
+  include KuberKit::Import[
+    "template_reader.reader",
+    "core.template_store",
+  ]
+
+  Contract KuberKit::Shell::AbstractShell, Symbol => Any
+  def call(shell, template_name)
+    template = template_store.get(template_name)
+
+    reader.read(shell, template)
+  end
+end

data/lib/kuber_kit/template_reader/reader.rb

@@ -2,22 +2,25 @@ class KuberKit::TemplateReader::Reader
   ReaderNotFoundError = Class.new(KuberKit::NotFoundError)
 
   include KuberKit::Import[
-    "template_reader.artifact_file_reader",
+    "template_reader.strategies.artifact_file",
   ]
 
+  def initialize(**injected_deps)
+    super(injected_deps)
+    add_default_strategies
+  end
+
   def use_reader(template_reader, template_class:)
     @@readers ||= {}
 
-    if !template_reader.is_a?(KuberKit::TemplateReader::AbstractTemplateReader)
-      raise ArgumentError.new("should be an instance of KuberKit::TemplateReader::AbstractTemplateReader, got: #{template_reader.inspect}")
+    if !template_reader.is_a?(KuberKit::TemplateReader::Strategies::Abstract)
+      raise ArgumentError.new("should be an instance of KuberKit::TemplateReader::Strategies::Abstract, got: #{template_reader.inspect}")
     end
 
     @@readers[template_class] = template_reader
   end
 
   def read(shell, template)
-    add_default_readers
-
     reader = @@readers[template.class]
 
     raise ReaderNotFoundError, "Can't find reader for template #{template}" if reader.nil?
@@ -25,11 +28,12 @@ class KuberKit::TemplateReader::Reader
     reader.read(shell, template)
   end
 
-  def add_default_readers
-    use_reader(artifact_file_reader, template_class: KuberKit::Core::Templates::ArtifactFile)
-  end
-
   def reset!
     @@readers = {}
   end
+
+  private
+    def add_default_strategies
+      use_reader(artifact_file, template_class: KuberKit::Core::Templates::ArtifactFile)
+    end
 end

data/lib/kuber_kit/template_reader/{abstract_template_reader.rb → strategies/abstract.rb}

@@ -1,4 +1,4 @@
-class KuberKit::TemplateReader::AbstractTemplateReader
+class KuberKit::TemplateReader::Strategies::Abstract
   def read(shell, template)
     raise KuberKit::NotImplementedError, "must be implemented"
   end

data/lib/kuber_kit/template_reader/{artifact_file_reader.rb → strategies/artifact_file.rb}

@@ -1,4 +1,4 @@
-class KuberKit::TemplateReader::ArtifactFileReader < KuberKit::TemplateReader::AbstractTemplateReader
+class KuberKit::TemplateReader::Strategies::ArtifactFile < KuberKit::TemplateReader::Strategies::Abstract
   include KuberKit::Import[
     "core.artifact_store"
   ]

data/lib/kuber_kit/version.rb

@@ -1,3 +1,3 @@
 module KuberKit
-  VERSION = "0.2.3"
+  VERSION = "0.2.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kuber_kit
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.8
 platform: ruby
 authors:
 - Iskander Khaziev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-01 00:00:00.000000000 Z
+date: 2020-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: contracts-lite
@@ -162,6 +162,7 @@ files:
 - example/app_data/service.yml
 - example/app_data/test.env
 - example/app_data/test.txt
+- example/config.rb
 - example/configurations/review.rb
 - example/images/app_sources/Dockerfile
 - example/images/app_sources/build_context/source.rb
@@ -211,6 +212,7 @@ files:
 - lib/kuber_kit/core/configuration_factory.rb
 - lib/kuber_kit/core/configuration_store.rb
 - lib/kuber_kit/core/context_helper/base_helper.rb
+- lib/kuber_kit/core/context_helper/context_args.rb
 - lib/kuber_kit/core/context_helper/context_helper_factory.rb
 - lib/kuber_kit/core/context_helper/image_helper.rb
 - lib/kuber_kit/core/context_helper/service_helper.rb
@@ -257,6 +259,7 @@ files:
 - lib/kuber_kit/service_deployer/service_list_resolver.rb
 - lib/kuber_kit/service_deployer/strategies/abstract.rb
 - lib/kuber_kit/service_deployer/strategies/kubernetes.rb
+- lib/kuber_kit/service_deployer/strategies/kubernetes_runner.rb
 - lib/kuber_kit/service_deployer/strategy_detector.rb
 - lib/kuber_kit/service_reader/action_handler.rb
 - lib/kuber_kit/service_reader/reader.rb
@@ -270,9 +273,10 @@ files:
 - lib/kuber_kit/shell/local_shell.rb
 - lib/kuber_kit/shell/ssh_session.rb
 - lib/kuber_kit/shell/ssh_shell.rb
-- lib/kuber_kit/template_reader/abstract_template_reader.rb
-- lib/kuber_kit/template_reader/artifact_file_reader.rb
+- lib/kuber_kit/template_reader/action_handler.rb
 - lib/kuber_kit/template_reader/reader.rb
+- lib/kuber_kit/template_reader/strategies/abstract.rb
+- lib/kuber_kit/template_reader/strategies/artifact_file.rb
 - lib/kuber_kit/tools/file_presence_checker.rb
 - lib/kuber_kit/tools/logger_factory.rb
 - lib/kuber_kit/ui.rb