kuber_kit 0.2.8 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4caab78fa6712fb2e509f29078f209fe491f35973a973a941143feed08f41d1c
-  data.tar.gz: 4aa7e98355e2e961d963026c640422a4d90deb802a0ffadfd4d938781527ab7f
+  metadata.gz: ae284766e125c54579032cd54c29d602848f95a9a91e07c357ab1b985632a9d1
+  data.tar.gz: 9a9c7a194893cdc39c7629fbda8e03bb7da6b77583899995c14a511f3b152943
 SHA512:
-  metadata.gz: '08ad78c315e7e7900f668707f96ea61e9a200f90c5ae7f9d94a54835540a697549e763692c73734631f03df2d76c53d9eef7bff4e019a003b23b63baf3499902'
-  data.tar.gz: e347e3b630580b7476fa67a4434ef870b897979d2322a73e32027346933be12f37b7f1212426e9e806833074e7c3cb655b5bed930c6556c30f1288ec49dec45d
+  metadata.gz: 3cbef254939ce54ff789fcde11ca3db500bfc552f75768bb9424dbdef682830eceed216b046f5930b95e45c8985c2b77e6ce2947e277951e718b1f38df62af29
+  data.tar.gz: bb571f10d8f4e41612c31e1616138e45a54134b92b4b8f9a9577083fc175982e3e5f1a77f1ec564a160ce88f46f76d57d143a8968b8282c92d66f4cb2e2f4220

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    kuber_kit (0.2.8)
+    kuber_kit (0.3.3)
       cli-ui
       contracts-lite
       dry-auto_inject
@@ -35,23 +35,25 @@ GEM
       coderay (~> 1.1)
       method_source (~> 1.0)
     rake (10.5.0)
-    rspec (3.9.0)
-      rspec-core (~> 3.9.0)
-      rspec-expectations (~> 3.9.0)
-      rspec-mocks (~> 3.9.0)
-    rspec-core (3.9.3)
-      rspec-support (~> 3.9.3)
-    rspec-expectations (3.9.3)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.0)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.9.0)
-    rspec-mocks (3.9.1)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.9.0)
-    rspec-support (3.9.4)
-    simplecov (0.19.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.0)
+    simplecov (0.20.0)
       docile (~> 1.1)
       simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
     simplecov-html (0.12.3)
+    simplecov_json_formatter (0.1.2)
     thor (1.0.1)
 
 PLATFORMS

data/TODO.md

@@ -1,9 +1,8 @@
-- 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
-- add build vars support (use images instead of containers)
+- kit attach should list available deployments/pods, and ask for specific container if it has multiple containers
+- add kit logs support, should work similar to kit attach
+- allow deploying only services enabled for specific configuration
+- find a way to always deploy some service, e.g. for migrations and env_files
+- add ability to set container health checks
 - template should be able to set default attributes
 - template should be able to depend on image?

data/example/app_data/docker_compose.yml

@@ -0,0 +1,6 @@
+version: "3.3"
+services:
+  <%= service_name %>:
+    container_name: <%= service_name %>
+    hostname: <%= service_name %>
+    image: <%= image_url(attribute(:image_name, default: service_name.to_sym)) %>

data/example/configurations/review.rb

@@ -2,4 +2,4 @@ KuberKit
   .define_configuration(:review)
   .use_registry(:review_default, as: :default)
   .use_artifact(:kuber_kit_repo, as: :kuber_kit_repo)
-  .use_build_server(:remote_bs)
+  #.use_build_server(:remote_bs)

data/example/images/ruby_app/Dockerfile

@@ -8,4 +8,4 @@ COPY README.md README.md
 
 RUN ruby /app/source.rb
 
-COPY example_file.txt example_file.txt
+COPY example_file.txt <%= build_vars.example_file_name %>

data/example/images/ruby_app/image.rb

@@ -2,6 +2,9 @@ KuberKit
   .define_image(:ruby_app)
   .registry(:default)
   .depends_on(:ruby, :app_sources)
+  .build_vars({
+    example_file_name: "example.txt"
+  })
   .before_build do |context_helper, build_dir|
     # copy file: local artifact
     source_path = context_helper.artifact_path(:kuber_kit_example_data, "test.txt")

data/example/infrastructure/build_servers.rb

@@ -1,8 +1,8 @@
 ENV['SSH_TEST_HOST'] ||= "indocker.artstn.ninja"
 ENV['SSH_TEST_USER'] ||= "kuber_kit"
 
-KuberKit.add_build_server(
-  KuberKit::Core::BuildServers::BuildServer
-    .new(:remote_bs)
-    .setup(host: ENV['SSH_TEST_HOST'], user: ENV['SSH_TEST_USER'], port: 22)
-)
+# KuberKit.add_build_server(
+#   KuberKit::Core::BuildServers::BuildServer
+#     .new(:remote_bs)
+#     .setup(host: ENV['SSH_TEST_HOST'], user: ENV['SSH_TEST_USER'], port: 22)
+# )

data/example/infrastructure/templates.rb

@@ -6,4 +6,9 @@ KuberKit.add_template(
 KuberKit.add_template(
   KuberKit::Core::Templates::ArtifactFile
     .new(:env_file, artifact_name: :kuber_kit_example_data, file_path: "env_file.yml")
+)
+
+KuberKit.add_template(
+  KuberKit::Core::Templates::ArtifactFile
+    .new(:docker_compose, artifact_name: :kuber_kit_example_data, file_path: "docker_compose.yml")
 )

data/example/services/compose_app.rb

@@ -0,0 +1,10 @@
+KuberKit
+  .define_service(:compose_app)
+  .template(:docker_compose)
+  .images(:ruby_app)
+  .tags(:compose)
+  .deployer_strategy(:docker_compose)
+  .attributes(
+    image_name: :ruby_app,
+    deployer_interactive: true
+  )

data/example/services/env_file.rb

@@ -3,5 +3,5 @@ KuberKit
   .template(:env_file)
   .tags("env_file")
   .attributes(
-    deployment_restart_enabled: false
+    deployer_restart_enabled: false
   )

data/lib/kuber_kit.rb

@@ -57,7 +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'
+      autoload :ContextVars, 'core/context_helper/context_vars'
     end
 
     module Registries
@@ -88,6 +88,7 @@ module KuberKit
     module Commands
       autoload :BashCommands, 'shell/commands/bash_commands'
       autoload :DockerCommands, 'shell/commands/docker_commands'
+      autoload :DockerComposeCommands, 'shell/commands/docker_compose_commands'
       autoload :GitCommands, 'shell/commands/git_commands'
       autoload :RsyncCommands, 'shell/commands/rsync_commands'
       autoload :KubectlCommands, 'shell/commands/kubectl_commands'
@@ -145,8 +146,9 @@ module KuberKit
 
     module Strategies
       autoload :Abstract, 'service_deployer/strategies/abstract'
+      autoload :Docker, 'service_deployer/strategies/docker'
+      autoload :DockerCompose, 'service_deployer/strategies/docker_compose'
       autoload :Kubernetes, 'service_deployer/strategies/kubernetes'
-      autoload :KubernetesRunner, 'service_deployer/strategies/kubernetes_runner'
     end
   end
 
@@ -209,6 +211,10 @@ module KuberKit
       !!@debug_mode
     end
 
+    def deprecation_warnings_disabled?
+      Container["configs"].deprecation_warnings_disabled
+    end
+
     def current_configuration
       if @configuration_name.nil?
         raise "Please set configuration name before calling current_configuration"
@@ -217,7 +223,7 @@ module KuberKit
     end
 
     def global_build_vars
-      KuberKit::Core::ContextHelper::ContextArgs.new(current_configuration.global_build_vars)
+      KuberKit::Core::ContextHelper::ContextVars.new(current_configuration.global_build_vars)
     end
 
     def add_registry(registry)

data/lib/kuber_kit/actions/configuration_loader.rb

@@ -27,7 +27,7 @@ class KuberKit::Actions::ConfigurationLoader
     services_path = options[:services_path] || File.join(root_path, configs.services_dirname)
     infra_path    = options[:infra_path]  || File.join(root_path, configs.infra_dirname)
     configurations_path  = options[:configurations_path]  || File.join(root_path, configs.configurations_dirname)
-    configuration_name   = options[:configuration]
+    configuration_name   = ENV["KUBER_KIT_CONFIGURATION"] || options[:configuration]
 
     logger.info "Launching kuber_kit with:"
     logger.info "  Root path: #{root_path.to_s.yellow}"
@@ -56,6 +56,11 @@ class KuberKit::Actions::ConfigurationLoader
 
     ui.create_task("Loading image definitions") do |task|
       files = image_store.load_definitions(images_path)
+
+      configs.additional_images_paths.each do |path|
+        files += image_store.load_definitions(path)
+      end
+
       task.update_title("Loaded #{files.count} image definitions")
     end
 

data/lib/kuber_kit/actions/kubectl_applier.rb

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

data/lib/kuber_kit/actions/kubectl_attacher.rb

@@ -8,13 +8,13 @@ class KuberKit::Actions::KubectlAttacher
   Contract String, Hash => Any
   def call(pod_name, options)
     kubeconfig_path = KuberKit.current_configuration.kubeconfig_path
-    deploy_namespace = KuberKit.current_configuration.deploy_namespace
+    deployer_namespace = KuberKit.current_configuration.deployer_namespace
 
     kubectl_commands.exec(
       local_shell, pod_name, "bash", args: "-it", 
       kubeconfig_path: kubeconfig_path, 
       interactive: true,
-      namespace: deploy_namespace
+      namespace: deployer_namespace
     )
 
     true

data/lib/kuber_kit/configs.rb

@@ -4,7 +4,8 @@ class KuberKit::Configs
   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
+    :artifact_clone_dir, :service_config_dir, :deployer_strategy, :compile_simultaneous_limit,
+    :additional_images_paths, :deprecation_warnings_disabled
   ]
   DOCKER_IGNORE_LIST = [
     'Dockerfile',
@@ -46,8 +47,10 @@ class KuberKit::Configs
     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 :deployer_strategy,         :kubernetes
     set :compile_simultaneous_limit, 5
+    set :additional_images_paths, []
+    set :deprecation_warnings_disabled, false
   end
 
   def items

data/lib/kuber_kit/container.rb

@@ -117,6 +117,10 @@ class KuberKit::Container
     KuberKit::Shell::Commands::DockerCommands.new
   end
 
+  register "shell.docker_compose_commands" do
+    KuberKit::Shell::Commands::DockerComposeCommands.new
+  end
+
   register "shell.git_commands" do
     KuberKit::Shell::Commands::GitCommands.new
   end
@@ -229,8 +233,12 @@ class KuberKit::Container
     KuberKit::ServiceDeployer::Strategies::Kubernetes.new
   end
 
-  register "service_deployer.strategies.kubernetes_runner" do
-    KuberKit::ServiceDeployer::Strategies::KubernetesRunner.new
+  register "service_deployer.strategies.docker" do
+    KuberKit::ServiceDeployer::Strategies::Docker.new
+  end
+
+  register "service_deployer.strategies.docker_compose" do
+    KuberKit::ServiceDeployer::Strategies::DockerCompose.new
   end
 
   register "service_reader.action_handler" do

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, :deploy_namespace, :services_attributes, :build_servers,
+              :deployer_strategy, :deployer_namespace, :services_attributes, :build_servers,
               :global_build_vars
 
   Contract KeywordArgs[
@@ -10,14 +10,14 @@ class KuberKit::Core::Configuration
     env_files:       Hash,
     templates:       Hash,
     kubeconfig_path: Maybe[String],
-    deploy_strategy:  Symbol,
-    deploy_namespace: Maybe[Symbol],
+    deployer_strategy:  Symbol,
+    deployer_namespace: Maybe[Symbol],
     services_attributes: HashOf[Symbol => Hash],
     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:, 
+                 deployer_strategy:, deployer_namespace:, services_attributes:, build_servers:, 
                  global_build_vars:)
     @name             = name
     @artifacts        = artifacts
@@ -25,8 +25,8 @@ class KuberKit::Core::Configuration
     @env_files        = env_files
     @templates        = templates
     @kubeconfig_path  = kubeconfig_path
-    @deploy_strategy  = deploy_strategy
-    @deploy_namespace = deploy_namespace
+    @deployer_strategy  = deployer_strategy
+    @deployer_namespace = deployer_namespace
     @build_servers    = build_servers
     @services_attributes  = services_attributes
     @global_build_vars    = global_build_vars
@@ -35,4 +35,11 @@ class KuberKit::Core::Configuration
   def service_attributes(service_name)
     services_attributes[service_name.to_sym] || {}
   end
+
+  def global_build_args
+    unless KuberKit.deprecation_warnings_disabled?
+      puts "DEPRECATION: global_build_args is deprecated, please use global_build_vars instead"
+    end
+    global_build_vars
+  end
 end

data/lib/kuber_kit/core/configuration_definition.rb

@@ -23,8 +23,8 @@ class KuberKit::Core::ConfigurationDefinition
       env_files:        @env_files,
       templates:        @templates,
       kubeconfig_path:  @kubeconfig_path,
-      deploy_strategy:  @deploy_strategy,
-      deploy_namespace: @deploy_namespace,
+      deployer_strategy:  @deployer_strategy,
+      deployer_namespace: @deployer_namespace,
       enabled_services: @enabled_services,
       build_servers:    @build_servers,
       services_attributes:  @services_attributes,
@@ -82,22 +82,35 @@ class KuberKit::Core::ConfigurationDefinition
     self
   end
 
-  def deploy_namespace(namespace)
-    @deploy_namespace = namespace
+  def deployer_namespace(namespace)
+    @deployer_namespace = namespace
 
     self
   end
 
-  def deploy_strategy(path)
-    @deploy_strategy = path
+  def deployer_strategy(path)
+    @deployer_strategy = path
 
     self
   end
 
-  def enabled_services(services_hash)
-    @enabled_services += services_hash.keys.map(&:to_sym)
-    @services_attributes = @services_attributes.merge(services_hash)
+  def enabled_services(services)
+    if services.is_a?(Hash)
+      @enabled_services += services.keys.map(&:to_sym)
+      @services_attributes = @services_attributes.merge(services)
+      return self
+    end
+
+    if services.is_a?(Array)
+      @enabled_services += services.map(&:to_sym)
+      return self
+    end
+
+    raise KuberKit::Error, "#enabled_services method accepts only Array or Hash"
+  end
 
+  def service_attributes(services)
+    @services_attributes = @services_attributes.merge(services)
     self
   end
 

data/lib/kuber_kit/core/configuration_factory.rb

@@ -20,15 +20,15 @@ class KuberKit::Core::ConfigurationFactory
     build_servers = fetch_build_servers(configuration_attrs.build_servers)
 
     KuberKit::Core::Configuration.new(
-      name:             configuration_attrs.name,
-      artifacts:        artifacts,
-      registries:       registries,
-      env_files:        env_files,
-      templates:        templates,
-      kubeconfig_path:  configuration_attrs.kubeconfig_path,
-      deploy_strategy:  configuration_attrs.deploy_strategy || configs.deploy_strategy,
-      deploy_namespace: configuration_attrs.deploy_namespace,
-      build_servers:    build_servers,
+      name:               configuration_attrs.name,
+      artifacts:          artifacts,
+      registries:         registries,
+      env_files:          env_files,
+      templates:          templates,
+      kubeconfig_path:    configuration_attrs.kubeconfig_path,
+      deployer_strategy:  configuration_attrs.deployer_strategy || configs.deployer_strategy,
+      deployer_namespace: configuration_attrs.deployer_namespace,
+      build_servers:      build_servers,
       services_attributes:  configuration_attrs.services_attributes,
       global_build_vars:    configuration_attrs.global_build_vars || {},
     )

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

@@ -5,12 +5,13 @@ class KuberKit::Core::ContextHelper::ContextHelperFactory
     env_file_reader: "env_file_reader.action_handler"
   ]
 
-  def build_image_context(shell)
+  def build_image_context(shell, image)
     KuberKit::Core::ContextHelper::ImageHelper.new(
       image_store:      image_store,
       artifact_store:   artifact_store,
       shell:            shell,
-      env_file_reader:  env_file_reader
+      env_file_reader:  env_file_reader,
+      image:            image
     )
   end
 

data/lib/kuber_kit/core/context_helper/{context_args.rb → context_vars.rb}

@@ -1,8 +1,8 @@
-class KuberKit::Core::ContextHelper::ContextArgs
+class KuberKit::Core::ContextHelper::ContextVars
   attr_reader :parent, :parent_name
 
-  def initialize(context_args, parent_name = nil, parent = nil)
-    @context_args = context_args
+  def initialize(context_vars, parent_name = nil, parent = nil)
+    @context_vars = context_vars
     @parent_name  = parent_name
     @parent = parent
   end
@@ -12,8 +12,8 @@ class KuberKit::Core::ContextHelper::ContextArgs
       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}")
+    value = @context_vars.fetch(name) do
+      raise(KuberKit::Error, "build arg '#{format_arg(name)}' is not defined, available args: #{@context_vars.inspect}")
     end
 
     if value.is_a?(Hash)

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

@@ -1,2 +1,19 @@
 class KuberKit::Core::ContextHelper::ImageHelper < KuberKit::Core::ContextHelper::BaseHelper
+  def initialize(image_store:, artifact_store:, shell:, env_file_reader:, image:)
+    super(
+      image_store:      image_store, 
+      artifact_store:   artifact_store, 
+      shell:            shell,
+      env_file_reader:  env_file_reader
+    )
+    @image = image
+  end
+
+  def image_name
+    @image.name.to_s
+  end
+
+  def build_vars
+    KuberKit::Core::ContextHelper::ContextVars.new(@image.build_vars)
+  end
 end

data/lib/kuber_kit/core/image.rb

@@ -33,7 +33,9 @@ class KuberKit::Core::Image
   end
 
   def build_args
-    puts "WARNING: build_args is deprecated, please use build_vars instead"
+    unless KuberKit.deprecation_warnings_disabled?
+      puts "WARNING: build_args is deprecated, please use build_vars instead"
+    end
     build_vars
   end
 end

data/lib/kuber_kit/core/image_definition.rb

@@ -44,7 +44,9 @@ class KuberKit::Core::ImageDefinition
   end
 
   def build_args(value = nil, &block)
-    puts "WARNING: build_args is deprecated, please use build_vars instead"
+    unless KuberKit.deprecation_warnings_disabled?
+      puts "WARNING: build_args is deprecated, please use build_vars instead"
+    end
     build_vars(value, *block)
   end
 
@@ -66,14 +68,14 @@ class KuberKit::Core::ImageDefinition
     self
   end
 
-  def before_build(&block)
-    @before_build_callback = block
+  def before_build(lambda_arg = nil, &block)
+    @before_build_callback = lambda_arg || block
 
     self
   end
 
-  def after_build(&block)
-    @after_build_callback = block
+  def after_build(lambda_arg = nil, &block)
+    @after_build_callback = lambda_arg || block
 
     self
   end

data/lib/kuber_kit/core/service.rb

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

data/lib/kuber_kit/core/service_definition.rb

@@ -13,7 +13,7 @@ class KuberKit::Core::ServiceDefinition
       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),
+      deployer_strategy:  get_value(@deployer_strategy),
     )
   end
 
@@ -41,8 +41,8 @@ class KuberKit::Core::ServiceDefinition
     self
   end
 
-  def deploy_strategy(value = nil, &block)
-    @deploy_strategy = block_given? ? block : value
+  def deployer_strategy(value = nil, &block)
+    @deployer_strategy = block_given? ? block : value
 
     self
   end

data/lib/kuber_kit/core/service_factory.rb

@@ -12,12 +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,
-      deploy_strategy:  service_attrs.deploy_strategy,
+      name:               service_attrs.name,
+      template_name:      service_attrs.template_name,
+      tags:               service_attrs.tags,
+      images:             service_attrs.images,
+      attributes:         attributes,
+      deployer_strategy:  service_attrs.deployer_strategy,
     )
   end
 end

data/lib/kuber_kit/extensions/indocker_compat.rb

@@ -14,6 +14,10 @@ module KuberKit
     def build_configuration(configuration_name)
       define_configuration(configuration_name)
     end
+
+    def configuration
+      current_configuration
+    end
   end
 end
 Indocker = KuberKit

data/lib/kuber_kit/image_compiler/compiler.rb

@@ -9,7 +9,7 @@ class KuberKit::ImageCompiler::Compiler
   def compile(shell, image, builds_dir)
     image_build_dir = File.join(builds_dir, image.name.to_s)
 
-    context_helper = context_helper_factory.build_image_context(shell)
+    context_helper = context_helper_factory.build_image_context(shell, image)
     image_build_dir_creator.create(shell, image, image_build_dir, context_helper: context_helper)
 
     image_builder.build(shell, image, image_build_dir, context_helper: context_helper)

data/lib/kuber_kit/service_deployer/deployer.rb

@@ -4,7 +4,8 @@ class KuberKit::ServiceDeployer::Deployer
   include KuberKit::Import[
     "core.service_store",
     "service_deployer.strategies.kubernetes",
-    "service_deployer.strategies.kubernetes_runner"
+    "service_deployer.strategies.docker",
+    "service_deployer.strategies.docker_compose"
   ]
 
   def initialize(**injected_deps)
@@ -38,6 +39,7 @@ class KuberKit::ServiceDeployer::Deployer
   private
     def add_default_strategies
       register_strategy(:kubernetes, kubernetes)
-      register_strategy(:kubernetes_runner, kubernetes_runner)
+      register_strategy(:docker, docker)
+      register_strategy(:docker_compose, docker_compose)
     end
 end

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

@@ -0,0 +1,41 @@
+class KuberKit::ServiceDeployer::Strategies::Docker < KuberKit::ServiceDeployer::Strategies::Abstract
+  include KuberKit::Import[
+    "shell.docker_commands",
+    "core.image_store",
+    "configs",
+  ]
+
+  STRATEGY_OPTIONS = [
+    :container_name,
+    :image_name,
+    :docker_run_args,
+    :docker_run_command,
+    :delete_if_exists
+  ]
+
+  Contract KuberKit::Shell::AbstractShell, KuberKit::Core::Service => Any
+  def deploy(shell, service)
+    strategy_options = service.attribute(:deployer, default: {})
+    unknown_options  = strategy_options.keys.map(&:to_sym) - STRATEGY_OPTIONS
+    if unknown_options.any?
+      raise KuberKit::Error, "Unknow options for deploy strategy: #{unknown_options}. Available options: #{STRATEGY_OPTIONS}"
+    end
+    
+    container_name    = strategy_options.fetch(:container_name, service.uri)
+    docker_run_args   = strategy_options.fetch(:docker_run_args, nil)
+    docker_run_command = strategy_options.fetch(:docker_run_command, nil)
+
+    image_name = strategy_options.fetch(:image_name, nil)
+    if image_name.nil?
+      raise KuberKit::Error, "image_name is mandatory attribute for this deploy strategy"
+    end
+    image = image_store.get_image(image_name.to_sym)
+
+    delete_enabled = strategy_options.fetch(:delete_if_exists, false)
+    if delete_enabled && docker_commands.container_exists?(shell, container_name)
+      docker_commands.delete_container(shell, container_name)
+    end
+
+    docker_commands.run(shell, image.remote_registry_url, run_args: docker_run_args, run_command: docker_run_command)
+  end
+end

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

@@ -0,0 +1,33 @@
+class KuberKit::ServiceDeployer::Strategies::DockerCompose < KuberKit::ServiceDeployer::Strategies::Abstract
+  include KuberKit::Import[
+    "service_reader.reader",
+    "shell.docker_compose_commands",
+    "configs",
+  ]
+
+  STRATEGY_OPTIONS = [
+    :service_name, 
+    :command_name
+  ]
+
+  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)
+
+    strategy_options = service.attribute(:deployer, default: {})
+    unknown_options  = strategy_options.keys.map(&:to_sym) - STRATEGY_OPTIONS
+    if unknown_options.any?
+      raise KuberKit::Error, "Unknow options for deploy strategy: #{unknown_options}. Available options: #{STRATEGY_OPTIONS}"
+    end
+
+    service_name = strategy_options.fetch(:service_name, service.name.to_s)
+    command_name = strategy_options.fetch(:command_name, "bash")
+
+    docker_compose_commands.run(shell, config_path, 
+      service:      service_name, 
+      command:      command_name,
+    )
+  end
+end

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

@@ -5,21 +5,48 @@ class KuberKit::ServiceDeployer::Strategies::Kubernetes < KuberKit::ServiceDeplo
     "configs",
   ]
 
+  STRATEGY_OPTIONS = [
+    :resource_type,
+    :resource_name,
+    :delete_if_exists,
+    :restart_if_exists
+  ]
+
   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
+    kubeconfig_path = KuberKit.current_configuration.kubeconfig_path
+    namespace       = KuberKit.current_configuration.deployer_namespace
+
+    strategy_options = service.attribute(:deployer, default: {})
+    unknown_options  = strategy_options.keys.map(&:to_sym) - STRATEGY_OPTIONS
+    if unknown_options.any?
+      raise KuberKit::Error, "Unknow options for deploy strategy: #{unknown_options}. Available options: #{STRATEGY_OPTIONS}"
+    end
+    
+    resource_type = strategy_options.fetch(:resource_type, "deployment")
+    resource_name = strategy_options.fetch(:resource_name, service.uri)
+    
+    resource_exists = kubectl_commands.resource_exists?(
+      shell, resource_type, resource_name, kubeconfig_path: kubeconfig_path, namespace: namespace
+    )
+
+    delete_enabled = strategy_options.fetch(:delete_if_exists, false)
+    if delete_enabled && resource_exists
+      kubectl_commands.delete_resource(shell, resource_type, resource_name, kubeconfig_path: kubeconfig_path, namespace: namespace)
+    end
 
-    kubectl_commands.apply_file(shell, config_path, kubeconfig_path: kubeconfig_path, namespace: deploy_namespace)
+    kubectl_commands.apply_file(shell, config_path, kubeconfig_path: kubeconfig_path, namespace: 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, namespace: deploy_namespace)
+    restart_enabled = strategy_options.fetch(:restart_if_exists, true)
+    if restart_enabled && resource_exists
+      kubectl_commands.rolling_restart(
+        shell, resource_type, resource_name, 
+        kubeconfig_path: kubeconfig_path, namespace: 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)
-    service.deploy_strategy || KuberKit.current_configuration.deploy_strategy
+    service.deployer_strategy || KuberKit.current_configuration.deployer_strategy
   end
 end

data/lib/kuber_kit/shell/abstract_shell.rb

@@ -6,6 +6,10 @@ class KuberKit::Shell::AbstractShell
     raise KuberKit::NotImplementedError, "must be implemented"
   end
 
+  def interactive!(command)
+    raise KuberKit::NotImplementedError, "must be implemented"
+  end
+
   def read(file_path)
     raise KuberKit::NotImplementedError, "must be implemented"
   end

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

@@ -13,4 +13,37 @@ class KuberKit::Shell::Commands::DockerCommands
   def push(shell, tag_name)
     shell.exec!(%Q{docker push #{tag_name}})
   end
+
+  def run(shell, image_name, run_args: nil, run_command: nil)
+    command_parts = []
+    command_parts << "docker run"
+    command_parts << run_args if run_args
+    command_parts << image_name
+    command_parts << run_command if run_command
+
+    shell.exec!(command_parts.join(" "))
+  end
+
+  def container_exists?(shell, container_name)
+    result = get_container_id(shell, container_name)
+    result && result != ""
+  end
+
+  def delete_container(shell, container_name)
+    shell.exec!(%Q{docker rm -f #{container_name}})
+  end
+
+  def get_container_id(shell, container_name, only_healthy: false, status: "running")
+    command_parts = []
+    command_parts << "docker ps -a -q"
+
+    if only_healthy
+      command_parts << "--filter=\"health=healthy\""
+    end
+
+    command_parts << "--filter=\"status=#{status}\""
+    command_parts << "--filter=\"name=#{container_name}\""
+
+    shell.exec!(command_parts.join(" "))
+  end
 end

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

@@ -0,0 +1,17 @@
+class KuberKit::Shell::Commands::DockerComposeCommands
+  def run(shell, path, service:, command:, interactive: false)
+    command_parts = [
+      "docker-compose",
+      "-f #{path}",
+      "run",
+      service,
+      command
+    ]
+    
+    if interactive
+      shell.interactive!(command_parts.join(" "))
+    else
+      shell.exec!(command_parts.join(" "))
+    end
+  end
+end

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

@@ -16,9 +16,8 @@ class KuberKit::Shell::Commands::KubectlCommands
 
     command_parts += Array(command_list)
 
-    # TODO: investigate how to do it with shell.
     if interactive
-      system(command_parts.join(" "))
+      shell.interactive!(command_parts.join(" "))
     else
       shell.exec!(command_parts.join(" "))
     end
@@ -58,8 +57,16 @@ class KuberKit::Shell::Commands::KubectlCommands
     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, {
+  def patch_resource(shell, resource_type, resource_name, specs, kubeconfig_path: nil, namespace: nil)
+    specs_json = JSON.dump(specs).gsub('"', '\"')
+
+    command = %Q{patch #{resource_type} #{resource_name} -p "#{specs_json}"}
+
+    kubectl_run(shell, command, kubeconfig_path: kubeconfig_path, namespace: namespace)
+  end
+
+  def rolling_restart(shell, resource_type, resource_name, kubeconfig_path: nil, namespace: nil)
+    patch_resource(shell, resource_type, resource_name, {
       spec: {
         template: {
           metadata: {
@@ -71,12 +78,4 @@ class KuberKit::Shell::Commands::KubectlCommands
       }
     }, kubeconfig_path: kubeconfig_path, namespace: namespace)
   end
-
-  def patch_deployment(shell, deployment_name, specs, kubeconfig_path: nil, namespace: nil)
-    specs_json = JSON.dump(specs).gsub('"', '\"')
-
-    command = %Q{patch deployment #{deployment_name} -p "#{specs_json}"}
-
-    kubectl_run(shell, command, kubeconfig_path: kubeconfig_path, namespace: namespace)
-  end
 end

data/lib/kuber_kit/shell/local_shell.rb

@@ -30,6 +30,20 @@ class KuberKit::Shell::LocalShell < KuberKit::Shell::AbstractShell
     result
   end
 
+  def interactive!(command, log_command: true)
+    command_number = command_counter.get_number.to_s.rjust(2, "0")
+    
+    if log_command
+      logger.info("Interactive: [#{command_number}]: #{command.to_s.cyan}")
+    end
+
+    result = system(command)
+
+    if !$?.success?
+      raise ShellError, "Shell command failed: #{command}\r\n#{result}"
+    end
+  end
+
   def sync(local_path, remote_path, exclude: nil, delete: true)
     rsync_commands.rsync(self, local_path, remote_path, exclude: exclude, delete: delete)
   end

data/lib/kuber_kit/shell/ssh_shell.rb

@@ -38,6 +38,10 @@ class KuberKit::Shell::SshShell < KuberKit::Shell::LocalShell
     raise ShellError.new(e.message)
   end
 
+  def interactive!(command, log_command: true)
+    raise "Currently interactive run is not supported for ssh shell."
+  end
+
   def sync(local_path, remote_path, exclude: nil, delete: true)
     rsync_commands.rsync(
       local_shell, local_path, remote_path, 

data/lib/kuber_kit/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kuber_kit
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.3.3
 platform: ruby
 authors:
 - Iskander Khaziev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-07 00:00:00.000000000 Z
+date: 2020-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: contracts-lite
@@ -140,8 +140,8 @@ description: Docker Containers Build & Deployment
 email:
 - gvalmon@gmail.com
 executables:
-- console
 - kit
+- kit_console
 extensions: []
 extra_rdoc_files: []
 files:
@@ -156,8 +156,9 @@ files:
 - README.md
 - Rakefile
 - TODO.md
-- bin/console
 - bin/kit
+- bin/kit_console
+- example/app_data/docker_compose.yml
 - example/app_data/env_file.yml
 - example/app_data/service.yml
 - example/app_data/test.env
@@ -180,6 +181,7 @@ files:
 - example/infrastructure/env_files.rb
 - example/infrastructure/registries.rb
 - example/infrastructure/templates.rb
+- example/services/compose_app.rb
 - example/services/env_file.rb
 - example/services/ruby_app.rb
 - kuber_kit.gemspec
@@ -212,8 +214,8 @@ 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/context_vars.rb
 - lib/kuber_kit/core/context_helper/image_helper.rb
 - lib/kuber_kit/core/context_helper/service_helper.rb
 - lib/kuber_kit/core/env_files/abstract_env_file.rb
@@ -258,8 +260,9 @@ files:
 - lib/kuber_kit/service_deployer/deployer.rb
 - lib/kuber_kit/service_deployer/service_list_resolver.rb
 - lib/kuber_kit/service_deployer/strategies/abstract.rb
+- lib/kuber_kit/service_deployer/strategies/docker.rb
+- lib/kuber_kit/service_deployer/strategies/docker_compose.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
@@ -267,6 +270,7 @@ files:
 - lib/kuber_kit/shell/command_counter.rb
 - lib/kuber_kit/shell/commands/bash_commands.rb
 - lib/kuber_kit/shell/commands/docker_commands.rb
+- lib/kuber_kit/shell/commands/docker_compose_commands.rb
 - lib/kuber_kit/shell/commands/git_commands.rb
 - lib/kuber_kit/shell/commands/kubectl_commands.rb
 - lib/kuber_kit/shell/commands/rsync_commands.rb

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

@@ -1,35 +0,0 @@
-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