kuber_kit 0.5.4 → 0.5.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e99c1ae700ec8b59f9a832d3c9131e85c7d05a60548d8bca032d4ce2c9178b2
-  data.tar.gz: e4233e8cf40a7980477d85f341320536725efd169ac4120e74de6c7ad651e436
+  metadata.gz: fa75f8b61926a3178d1592ceb81a35945a073b38d34c80c246872bae6b357d1f
+  data.tar.gz: fc41c9917961f9bff18ac03a60a16a77f094deae51abc6e28d80524fab793968
 SHA512:
-  metadata.gz: 10a3f4b72a0d3a09c9a49842642e6f7a0457a5cb243d0c469c9792c7fcc70ff483b9ffbd6ecc7c278d20b3b7e22f603e45ad3360e701b1a9cf9696cff64d46ce
-  data.tar.gz: f857ce1a307375486c51cfaa67c22a929826b54a1ad572dc5a5ac64fb4febfe680fa27f3adddadf2d2b3d68325cd5dee7ba47facdf672c427640d048c23c950f
+  metadata.gz: 7cb947b2cf303ef0f04a77364c0b6ea4043b2cf6f2b29cea0da1cd5d2808c7f2103799ad711e191e859bce59177372ac795460a1ed13589a6f62f536f4b23eb0
+  data.tar.gz: 324b1de9e8e762a5bce7bebf29ff9cc0317814f924be886fd10434f2ed2ffc8376025200f7ed2e35e2300bbbb2968061775c6e1f1c07f4a0ad2a61038225e66f

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+**0.5.9**
+- Added an ability to set custom user
+- Allow setting environment variable in docker strategy
+- Properly stop deployment if image compilation is failed
+
+**0.5.8**
+- Update gemspec to support ruby 2.5
+
+**0.5.7**
+- Look for kuber_kit root path in parent folders, so kit command will work in sub-folders
+
+**0.5.6**
+- Pre-process env file if it has .erb extension
+- Allow attaching env file from configuration to docker container
+- Change default data paths to use home directory
+- Add env groups support to combine multiple env files
+
+**0.5.5**
+- Added ability to skip services during deployment using -S option
+
 **0.5.4**
 - Added disabled services support
 

data/Gemfile.lock

@@ -1,10 +1,11 @@
 PATH
   remote: .
   specs:
-    kuber_kit (0.5.4)
+    kuber_kit (0.5.9)
       cli-ui
       contracts-lite
-      dry-auto_inject
+      dry-auto_inject (~> 0.7.0)
+      dry-container (~> 0.7.2)
       net-ssh
       thor
       tty-prompt
@@ -12,9 +13,9 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    cli-ui (1.4.0)
+    cli-ui (1.5.1)
     coderay (1.1.3)
-    concurrent-ruby (1.1.8)
+    concurrent-ruby (1.1.9)
     contracts-lite (0.15.0)
     diff-lcs (1.4.4)
     docile (1.3.2)
@@ -26,7 +27,7 @@ GEM
     dry-container (0.7.2)
       concurrent-ruby (~> 1.0)
       dry-configurable (~> 0.1, >= 0.1.3)
-    dry-core (0.5.0)
+    dry-core (0.6.0)
       concurrent-ruby (~> 1.0)
     method_source (1.0.0)
     net-ssh (6.1.0)
@@ -58,7 +59,7 @@ GEM
     thor (1.1.0)
     tty-color (0.6.0)
     tty-cursor (0.7.1)
-    tty-prompt (0.23.0)
+    tty-prompt (0.23.1)
       pastel (~> 0.8)
       tty-reader (~> 0.8)
     tty-reader (0.9.0)

data/example/app_data/service.yml

@@ -3,7 +3,8 @@ apiVersion: apps/v1
 kind: Deployment
 metadata:
   labels:
-    app: <%= service_uri %>
+    app:  <%= service_uri %>
+    user: <%= KuberKit.user %>
   name: <%= service_uri %>
 spec:
   replicas: 1

data/example/images/failing_app/Dockerfile

@@ -0,0 +1,5 @@
+FROM <%= image_url(:ruby) %>
+
+RUN not_existing_command
+
+CMD ["tail", "-f", "/dev/null"]

data/example/images/failing_app/image.rb

@@ -0,0 +1,4 @@
+KuberKit
+  .define_image(:failing_app)
+  .registry(:default)
+  .depends_on(:ruby, :app_sources)

data/example/services/docker_app.rb

@@ -7,6 +7,7 @@ KuberKit
       detached:         false,
       image_name:       :ruby_app,
       container_name:   "test_docker_app",
-      delete_if_exists: true
+      delete_if_exists: true,
+      env_file_names:   [:test]
     }
   )

data/example/services/env_file.rb

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

data/example/services/failing_app.rb

@@ -0,0 +1,6 @@
+KuberKit
+  .define_service(:failing_app)
+  .depends_on(:env_file)
+  .template(:service)
+  .images(:failing_app)
+  .tags("app", "minimal")

data/example/services/ruby_app.rb

@@ -3,4 +3,4 @@ KuberKit
   .depends_on(:env_file)
   .template(:service)
   .images(:ruby_app)
-  .tags("app")
+  .tags("app", "minimal")

data/kuber_kit.gemspec

@@ -24,11 +24,12 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "contracts-lite"
-  spec.add_dependency "dry-auto_inject"
+  spec.add_dependency "dry-auto_inject", "~> 0.7.0"
   spec.add_dependency "thor"
   spec.add_dependency "cli-ui"
   spec.add_dependency "net-ssh"
   spec.add_dependency "tty-prompt"
+  spec.add_dependency "dry-container", "~> 0.7.2"
 
   spec.add_development_dependency "bundler", "~> 1.17"
   spec.add_development_dependency "rake", "~> 10.0"

data/lib/kuber_kit.rb

@@ -54,6 +54,7 @@ module KuberKit
       autoload :EnvFileStore, 'core/env_files/env_file_store'
       autoload :AbstractEnvFile, 'core/env_files/abstract_env_file'
       autoload :ArtifactFile, 'core/env_files/artifact_file'
+      autoload :EnvGroup, 'core/env_files/env_group'
     end
 
     module ContextHelper
@@ -81,6 +82,7 @@ module KuberKit
     autoload :FilePresenceChecker, 'tools/file_presence_checker'
     autoload :LoggerFactory, 'tools/logger_factory'
     autoload :ProcessCleaner, 'tools/process_cleaner'
+    autoload :WorkdirDetector, 'tools/workdir_detector'
   end
 
   module Shell
@@ -127,10 +129,13 @@ module KuberKit
   module EnvFileReader
     autoload :ActionHandler, 'env_file_reader/action_handler'
     autoload :Reader, 'env_file_reader/reader'
+    autoload :EnvFileParser, 'env_file_reader/env_file_parser'
+    autoload :EnvFileTempfileCreator, 'env_file_reader/env_file_tempfile_creator'
 
     module Strategies
       autoload :Abstract, 'env_file_reader/strategies/abstract'
       autoload :ArtifactFile, 'env_file_reader/strategies/artifact_file'
+      autoload :EnvGroup, 'env_file_reader/strategies/env_group'
     end
   end
 
@@ -165,6 +170,7 @@ module KuberKit
   end
 
   module Actions
+    autoload :ActionResult, 'actions/action_result'
     autoload :ImageCompiler, 'actions/image_compiler'
     autoload :EnvFileReader, 'actions/env_file_reader'
     autoload :TemplateReader, 'actions/template_reader'
@@ -270,6 +276,11 @@ module KuberKit
       KuberKit::Core::ContextHelper::BaseHelper.class_exec(&proc)
     end
 
+    def set_user(value)
+      @user    = value
+      @user_id = nil
+    end
+
     def user
       @user ||= ENV["KUBER_KIT_USERNAME"] || `whoami`.chomp
     end

data/lib/kuber_kit/actions/action_result.rb

@@ -0,0 +1,32 @@
+class KuberKit::Actions::ActionResult
+  attr_reader :finished_tasks, :result, :error
+
+  def initialize()
+    @results         = {}
+    @started_tasks   = []
+    @finished_tasks  = []
+    @mutex = Mutex.new
+  end
+
+  def start_task(task)
+    @mutex.synchronize do
+      @started_tasks.push(task)
+    end
+  end
+
+  def finish_task(task, result)
+    @mutex.synchronize do
+      @started_tasks.delete(task)
+      @finished_tasks.push(task)
+      @results[task] = result
+    end
+  end
+
+  def failed!(error)
+    @error = error
+  end
+
+  def succeeded?
+    @error.nil? && @started_tasks.empty?
+  end
+end

data/lib/kuber_kit/actions/configuration_loader.rb

@@ -4,6 +4,7 @@ class KuberKit::Actions::ConfigurationLoader
     "core.image_store",
     "core.service_store",
     "core.configuration_store",
+    "tools.workdir_detector",
     "artifacts_sync.artifacts_updater",
     "shell.local_shell",
     "ui",
@@ -12,7 +13,7 @@ class KuberKit::Actions::ConfigurationLoader
 
   Contract Hash => Any
   def call(options)
-    root_path     = options[:path] || File.join(Dir.pwd, configs.kuber_kit_dirname)
+    root_path     = workdir_detector.call(options)
     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)

data/lib/kuber_kit/actions/image_compiler.rb

@@ -10,38 +10,40 @@ class KuberKit::Actions::ImageCompiler
 
   Contract ArrayOf[Symbol], Hash => Any
   def call(image_names, options)
+    compilation_result = KuberKit::Actions::ActionResult.new()
+
     build_id = generate_build_id
     build_server_pool = build_server_pool_factory.create()
 
-    compiled_images = []
-    compilation_result = {}
     image_dependency_resolver.each_with_deps(image_names) do |dep_image_names|
       ui.print_debug("ImageCompiler", "Scheduling to compile: #{dep_image_names.inspect}. Limit: #{configs.compile_simultaneous_limit}")
-      result = compile_simultaneously(dep_image_names, build_id, build_server_pool)
-      compiled_images += dep_image_names
-      compilation_result = compilation_result.merge(result)
+
+      if compilation_result.succeeded?
+        compile_simultaneously(dep_image_names, build_id, build_server_pool, compilation_result)
+      end
     end
 
     build_server_pool.disconnect_all
 
-    { images: compiled_images, compilation: compilation_result }
+    compilation_result
   rescue KuberKit::Error => e
     ui.print_error("Error", e.message)
 
+    compilation_result.failed!(e.message)
+
     false
   end
 
   private
-    def compile_simultaneously(image_names, build_id, build_server_pool)
+    def compile_simultaneously(image_names, build_id, build_server_pool, compilation_result)
       task_group = ui.create_task_group
-      compiler_result = {}
       image_names.map do |image_name|
 
         ui.print_debug("ImageCompiler", "Started compiling: #{image_name.to_s.green}")
         task_group.add("Compiling #{image_name.to_s.yellow}") do |task|
-          shell = build_server_pool.get_shell
-          
-          compiler_result[image_name] = image_compiler.call(shell, image_name, build_id)
+          compilation_result.start_task(image_name)
+          image_result = compile_one(image_name, build_id, build_server_pool)
+          compilation_result.finish_task(image_name, image_result)
 
           task.update_title("Compiled #{image_name.to_s.green}")
           ui.print_debug("ImageCompiler", "Finished compiling: #{image_name}")
@@ -49,7 +51,11 @@ class KuberKit::Actions::ImageCompiler
         
       end
       task_group.wait
-      compiler_result
+    end
+
+    def compile_one(image_name, build_id, build_server_pool)
+      shell = build_server_pool.get_shell
+      image_compiler.call(shell, image_name, build_id)
     end
 
     def generate_build_id

data/lib/kuber_kit/actions/service_deployer.rb

@@ -14,21 +14,27 @@ class KuberKit::Actions::ServiceDeployer
   Contract KeywordArgs[
     services:             Maybe[ArrayOf[String]],
     tags:                 Maybe[ArrayOf[String]],
+    skip_services:        Maybe[ArrayOf[String]],
     skip_compile:         Maybe[Bool],
     require_confirmation: Maybe[Bool],
   ] => Any
-  def call(services:, tags:, skip_compile: false, require_confirmation: false)
+  def call(services:, tags:, skip_services: nil, skip_compile: false, require_confirmation: false)
+    deployment_result     = KuberKit::Actions::ActionResult.new()
     current_configuration = KuberKit.current_configuration
 
     if services.empty? && tags.empty?
       services, tags = show_tags_selection
     end
 
+
+    disabled_services = current_configuration.disabled_services.map(&:to_s)
+    disabled_services += skip_services if skip_services
+
     service_names = service_list_resolver.resolve(
       services:         services || [],
       tags:             tags || [],
       enabled_services:   current_configuration.enabled_services.map(&:to_s),
-      disabled_services:  current_configuration.disabled_services.map(&:to_s)
+      disabled_services:  disabled_services
     ).map(&:to_sym)
 
     # Return the list of services with all dependencies.
@@ -54,39 +60,41 @@ class KuberKit::Actions::ServiceDeployer
     images_names = services.map(&:images).flatten.uniq
 
     unless skip_compile
-      compile_result = compile_images(images_names)
-      return false unless compile_result
+      compilation_result = compile_images(images_names)
+
+      return false unless compilation_result && compilation_result.succeeded?
     end
 
-    deployed_services = []
-    deployment_result = {}
     service_dependency_resolver.each_with_deps(service_names) do |dep_service_names|
       ui.print_debug("ServiceDeployer", "Scheduling to compile: #{dep_service_names.inspect}. Limit: #{configs.deploy_simultaneous_limit}")
-      result = deploy_simultaneously(dep_service_names)
-      deployed_services += dep_service_names
-      deployment_result = deployment_result.merge(result)
+
+      if deployment_result.succeeded?
+        deploy_simultaneously(dep_service_names, deployment_result)
+      end
     end
 
-    { services: all_service_names, deployment: deployment_result }
+    deployment_result
   rescue KuberKit::Error => e
     ui.print_error("Error", e.message)
 
+    compilation_result.failed!(e.message)
+
     false
   rescue Interrupt => e
     process_cleaner.clean
   end
 
   private
-    def deploy_simultaneously(service_names)
+    def deploy_simultaneously(service_names, deployment_result)
       task_group = ui.create_task_group
 
-      deployer_result = {}
-
       service_names.each do |service_name|
 
         ui.print_debug("ServiceDeployer", "Started deploying: #{service_name.to_s.green}")
         task_group.add("Deploying #{service_name.to_s.yellow}") do |task|
-          deployer_result[service_name] = service_deployer.call(local_shell, service_name.to_sym)
+          deployment_result.start_task(service_name)
+          service_result = service_deployer.call(local_shell, service_name.to_sym)
+          deployment_result.finish_task(service_name, service_result)
 
           task.update_title("Deployed #{service_name.to_s.green}")
           ui.print_debug("ServiceDeployer", "Finished deploying: #{service_name.to_s.green}")
@@ -94,12 +102,10 @@ class KuberKit::Actions::ServiceDeployer
       end
 
       task_group.wait
-
-      deployer_result
     end
 
     def compile_images(images_names)
-      return true if images_names.empty?
+      return KuberKit::Actions::ActionResult.new if images_names.empty?
       image_compiler.call(images_names, {})
     end
 

data/lib/kuber_kit/cli.rb

@@ -10,6 +10,7 @@ class KuberKit::CLI < Thor
   class_option :ui, :type => :string, :desc => "UI mode (interactive|debug|simple)"
   class_option :debug, :type => :boolean, aliases: ["-d"]
   class_option :configuration, :type => :string, aliases: ["-C"]
+  class_option :user, :type => :string, aliases: ["-u"]
 
   desc "compile IMAGE_NAMES", "Compile image with IMAGE_NAMES (comma-separated)"
   def compile(image_names_str)
@@ -19,12 +20,15 @@ class KuberKit::CLI < Thor
     image_names = image_names_str.split(",").map(&:strip).map(&:to_sym)
 
     if KuberKit::Container['actions.configuration_loader'].call(options)
-      result = KuberKit::Container['actions.image_compiler'].call(image_names, options)
+      action_result = KuberKit::Container['actions.image_compiler'].call(image_names, options)
     end
 
-    if result
+    if action_result && action_result.succeeded?
       time = (Time.now.to_i - started_at)
-      print_result("Image compilation finished! (#{time}s)", result: result)
+      print_result("Image compilation finished! (#{time}s)", result: {
+        images:       action_result.finished_tasks,
+        compilation:  action_result.result
+      })
     else
       exit 1
     end
@@ -33,6 +37,7 @@ class KuberKit::CLI < Thor
   desc "deploy -t TAG_NAME", "Deploy CONTEXT_NAME with kubectl"
   method_option :services,              :type => :array,    aliases: ["-s"], repeatable: true
   method_option :tags,                  :type => :array,    aliases: ["-t"], repeatable: true
+  method_option :skip_services,         :type => :array,    aliases: ["-S"], repeatable: true
   method_option :skip_compile,          :type => :boolean,  aliases: ["-B"]
   method_option :require_confirmation,  :type => :boolean,  aliases: ["-r"]
   def deploy
@@ -43,24 +48,28 @@ class KuberKit::CLI < Thor
                              KuberKit.current_configuration.deployer_require_confirimation ||
                              false
       started_at = Time.now.to_i
-      result = KuberKit::Container['actions.service_deployer'].call(
+      action_result = KuberKit::Container['actions.service_deployer'].call(
         services:             (options[:services] || []).flatten.uniq, 
         tags:                 (options[:tags] || []).flatten.uniq,
+        skip_services:        (options[:skip_services] || []).flatten.uniq, 
         skip_compile:         options[:skip_compile] || false,
         require_confirmation: require_confirmation
       )
     end
 
-    if result
+    if action_result && action_result.succeeded?
       time = (Time.now.to_i - started_at)
-      print_result("Service deployment finished! (#{time}s)", result: result)
+      print_result("Service deployment finished! (#{time}s)", result: {
+        services:   action_result.finished_tasks, 
+        deployment: action_result.result
+      })
     else
       exit 1
     end
   end
 
-  desc "env ENV_FILE_NAME", "Return content of Env File ENV_FILE_NAME"
-  def env(env_file_name)
+  desc "envfile ENV_FILE_NAME", "Return content of Env File ENV_FILE_NAME"
+  def envfile(env_file_name)
     setup(options)
 
     if KuberKit::Container['actions.configuration_loader'].call(options)
@@ -176,8 +185,12 @@ class KuberKit::CLI < Thor
         KuberKit.set_ui_mode(options[:ui].to_sym)
       end
 
+      if options[:user]
+        KuberKit.set_user(options[:user])
+      end
+
       # We should load config before loading any bean, to make sure that bean won't be built with default config
-      root_path     = options[:path] || File.join(Dir.pwd, KuberKit::Container['configs'].kuber_kit_dirname)
+      root_path = KuberKit::Container['tools.workdir_detector'].call(options)
       config_file_path = File.join(root_path, APP_CONFIG_FILENAME)
       if File.exists?(config_file_path)
         require config_file_path
@@ -187,21 +200,4 @@ class KuberKit::CLI < Thor
     def print_result(message, data = {})
       KuberKit::Container['ui'].print_result(message, data)
     end
-
-    def cleanup_processes
-      # Stop all threads
-      Thread.list.each do |t| 
-        t.abort_on_exception   = false
-        t.report_on_exception  = false
-        Thread.kill(t) if t != Thread.current
-      end
-
-      # Find all system calls
-      child_pids_raw = `ps auxww | grep '[K]IT=#{Process.pid}' | awk '{print $2}'`
-      child_pids = child_pids_raw.to_s.split("\n").reject(&:empty?)
-      child_pids.each do |pid|
-        puts "Killing child process: #{pid}"
-        Process.kill("SIGHUP", pid.to_i)
-      end
-    end
 end

data/lib/kuber_kit/configs.rb

@@ -5,7 +5,7 @@ class KuberKit::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, :deployer_strategy, :compile_simultaneous_limit, :deploy_simultaneous_limit,
-    :additional_images_paths, :deprecation_warnings_disabled, :log_file_path
+    :additional_images_paths, :deprecation_warnings_disabled, :log_file_path, :env_file_compile_dir
   ]
   DOCKER_IGNORE_LIST = [
     'Dockerfile',
@@ -34,10 +34,12 @@ class KuberKit::Configs
   end
 
   def add_default_configs
+    home_kuber_kit_path = File.expand_path(File.join("~", ".kuber_kit"))
+    
     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 :image_compile_dir,       File.join(home_kuber_kit_path, "image_builds")
     set :docker_ignore_list,      DOCKER_IGNORE_LIST
     set :kuber_kit_dirname,       "kuber_kit"
     set :kuber_kit_min_version,   KuberKit::VERSION
@@ -45,14 +47,15 @@ class KuberKit::Configs
     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 :artifact_clone_dir,      File.join(home_kuber_kit_path, "artifacts")
+    set :service_config_dir,      File.join(home_kuber_kit_path, "services")
     set :deployer_strategy,         :kubernetes
     set :compile_simultaneous_limit, 5
     set :deploy_simultaneous_limit,  5
     set :additional_images_paths, []
     set :deprecation_warnings_disabled, false
-    set :log_file_path,           "/tmp/kuber_kit.log"
+    set :log_file_path,           File.join(home_kuber_kit_path, "deploy.log")
+    set :env_file_compile_dir,    File.join(home_kuber_kit_path, "env_files")
   end
 
   def items

data/lib/kuber_kit/container.rb

@@ -137,6 +137,10 @@ class KuberKit::Container
     KuberKit::Tools::ProcessCleaner.new
   end
 
+  register "tools.workdir_detector" do
+    KuberKit::Tools::WorkdirDetector.new
+  end
+
   register "shell.bash_commands" do
     KuberKit::Shell::Commands::BashCommands.new
   end
@@ -229,10 +233,22 @@ class KuberKit::Container
     KuberKit::EnvFileReader::Reader.new
   end
 
+  register "env_file_reader.env_file_parser" do
+    KuberKit::EnvFileReader::EnvFileParser.new
+  end
+
+  register "env_file_reader.env_file_tempfile_creator" do
+    KuberKit::EnvFileReader::EnvFileTempfileCreator.new
+  end
+
   register "env_file_reader.strategies.artifact_file" do
     KuberKit::EnvFileReader::Strategies::ArtifactFile.new
   end
 
+  register "env_file_reader.strategies.env_group" do
+    KuberKit::EnvFileReader::Strategies::EnvGroup.new
+  end
+
   register "template_reader.action_handler" do
     KuberKit::TemplateReader::ActionHandler.new
   end

data/lib/kuber_kit/core/artifacts/artifact_store.rb

@@ -3,6 +3,7 @@ class KuberKit::Core::Artifacts::ArtifactStore
     store.add(artifact.name, artifact)
   end
 
+  Contract Symbol => Maybe[KuberKit::Core::Artifacts::AbstractArtifact]
   def get(artifact_name)
     artifact = get_from_configuration(artifact_name) || 
                get_global(artifact_name)
@@ -10,10 +11,12 @@ class KuberKit::Core::Artifacts::ArtifactStore
     artifact
   end
 
+  Contract Symbol => Maybe[KuberKit::Core::Artifacts::AbstractArtifact]
   def get_global(artifact_name)
     store.get(artifact_name)
   end
 
+  Contract Symbol => Maybe[KuberKit::Core::Artifacts::AbstractArtifact]
   def get_from_configuration(artifact_name)
     artifacts = KuberKit.current_configuration.artifacts
     artifacts[artifact_name]

data/lib/kuber_kit/core/env_files/abstract_env_file.rb

@@ -6,4 +6,8 @@ class KuberKit::Core::EnvFiles::AbstractEnvFile
   def initialize(env_file_name)
     @name = env_file_name
   end
+
+  def uniq_name
+    @name.to_s
+  end
 end

data/lib/kuber_kit/core/env_files/artifact_file.rb

@@ -6,4 +6,8 @@ class KuberKit::Core::EnvFiles::ArtifactFile < KuberKit::Core::EnvFiles::Abstrac
     @artifact_name = artifact_name
     @file_path = file_path
   end
+
+  def uniq_name
+    [@artifact_name.to_s, @name.to_s].join("-")
+  end
 end

data/lib/kuber_kit/core/env_files/env_file_store.rb

@@ -3,6 +3,7 @@ class KuberKit::Core::EnvFiles::EnvFileStore
     store.add(env_file.name, env_file)
   end
 
+  Contract Symbol => Maybe[KuberKit::Core::EnvFiles::AbstractEnvFile]
   def get(env_file_name)
     env_file = get_from_configuration(env_file_name) || 
                get_global(env_file_name)
@@ -10,10 +11,12 @@ class KuberKit::Core::EnvFiles::EnvFileStore
     env_file
   end
 
+  Contract Symbol => Maybe[KuberKit::Core::EnvFiles::AbstractEnvFile]
   def get_global(env_file_name)
     store.get(env_file_name)
   end
 
+  Contract Symbol => Maybe[KuberKit::Core::EnvFiles::AbstractEnvFile]
   def get_from_configuration(env_file_name)
     env_files = KuberKit.current_configuration.env_files
     env_files[env_file_name]

data/lib/kuber_kit/core/env_files/env_group.rb

@@ -0,0 +1,12 @@
+class KuberKit::Core::EnvFiles::EnvGroup < KuberKit::Core::EnvFiles::AbstractEnvFile
+  attr_reader :env_files
+
+  def initialize(env_group_name, env_files:)
+    super(env_group_name)
+    @env_files = env_files
+  end
+
+  def uniq_name
+    "env-group-#{@name.to_s}"
+  end
+end

data/lib/kuber_kit/core/registries/registry_store.rb

@@ -3,6 +3,7 @@ class KuberKit::Core::Registries::RegistryStore
     store.add(registry.name, registry)
   end
 
+  Contract Symbol => Maybe[KuberKit::Core::Registries::AbstractRegistry]
   def get(registry_name)
     registry = get_from_configuration(registry_name) || 
                get_global(registry_name)
@@ -10,10 +11,12 @@ class KuberKit::Core::Registries::RegistryStore
     registry
   end
 
+  Contract Symbol => Maybe[KuberKit::Core::Registries::AbstractRegistry]
   def get_global(registry_name)
     store.get(registry_name)
   end
 
+  Contract Symbol => Maybe[KuberKit::Core::Registries::AbstractRegistry]
   def get_from_configuration(registry_name)
     registries = KuberKit.current_configuration.registries
     registries[registry_name]

data/lib/kuber_kit/core/templates/template_store.rb

@@ -3,6 +3,7 @@ class KuberKit::Core::Templates::TemplateStore
     store.add(template.name, template)
   end
 
+  Contract Symbol => Maybe[KuberKit::Core::Templates::AbstractTemplate]
   def get(template_name)
     template = get_from_configuration(template_name) || 
                get_global(template_name)
@@ -10,10 +11,12 @@ class KuberKit::Core::Templates::TemplateStore
     template
   end
 
+  Contract Symbol => Maybe[KuberKit::Core::Templates::AbstractTemplate]
   def get_global(template_name)
     store.get(template_name)
   end
 
+  Contract Symbol => Maybe[KuberKit::Core::Templates::AbstractTemplate]
   def get_from_configuration(template_name)
     templates = KuberKit.current_configuration.templates
     templates[template_name]

data/lib/kuber_kit/env_file_reader/env_file_parser.rb

@@ -0,0 +1,51 @@
+class KuberKit::EnvFileReader::EnvFileParser
+  # Parser is based on:
+  # https://github.com/bkeepers/dotenv/blob/master/lib/dotenv/parser.rb
+  LINE = /
+    (?:^|\A)              # beginning of line
+    \s*                   # leading whitespace
+    (?:export\s+)?        # optional export
+    ([\w\.]+)             # key
+    (?:\s*=\s*?|:\s+?)    # separator
+    (                     # optional value begin
+      \s*'(?:\\'|[^'])*'  #   single quoted value
+      |                   #   or
+      \s*"(?:\\"|[^"])*"  #   double quoted value
+      |                   #   or
+      [^\#\r\n]+          #   unquoted value
+    )?                    # value end
+    \s*                   # trailing whitespace
+    (?:\#.*)?             # optional comment
+    (?:$|\z)              # end of line
+  /x
+
+  Contract String => Hash
+  def call(string)
+    hash = {}
+    string.gsub(/\r\n?/, "\n").scan(LINE).each do |key, value|
+      hash[key] = parse_value(value || "")
+    end
+    hash
+  end
+
+  private
+
+  def parse_value(value)
+    # Remove surrounding quotes
+    value = value.strip.sub(/\A(['"])(.*)\1\z/m, '\2')
+
+    if Regexp.last_match(1) == '"'
+      value = unescape_characters(expand_newlines(value))
+    end
+
+    value
+  end
+
+  def unescape_characters(value)
+    value.gsub(/\\([^$])/, '\1')
+  end
+
+  def expand_newlines(value)
+    value.gsub('\n', "\n").gsub('\r', "\r")
+  end
+end

data/lib/kuber_kit/env_file_reader/env_file_tempfile_creator.rb

@@ -0,0 +1,17 @@
+class KuberKit::EnvFileReader::EnvFileTempfileCreator
+  include KuberKit::Import[
+    "env_file_reader.reader",
+    "configs"
+  ]
+
+  Contract KuberKit::Shell::AbstractShell, KuberKit::Core::EnvFiles::AbstractEnvFile => String
+  def call(shell, env_file)
+    env_file_hash = reader.read(shell, env_file)
+    env_file_raw  = env_file_hash.to_a.map{|k,v| "#{k}=#{v}"}.join("\r\n")
+    temp_file_path = File.join(configs.env_file_compile_dir, env_file.uniq_name)
+
+    shell.write(temp_file_path, env_file_raw)
+
+    temp_file_path
+  end
+end

data/lib/kuber_kit/env_file_reader/reader.rb

@@ -3,6 +3,7 @@ class KuberKit::EnvFileReader::Reader
 
   include KuberKit::Import[
     "env_file_reader.strategies.artifact_file",
+    "env_file_reader.strategies.env_group",
   ]
 
   def initialize(**injected_deps)
@@ -35,5 +36,6 @@ class KuberKit::EnvFileReader::Reader
   private
     def add_default_strategies
       use_reader(artifact_file, env_file_class: KuberKit::Core::EnvFiles::ArtifactFile)
+      use_reader(env_group, env_file_class: KuberKit::Core::EnvFiles::EnvGroup)
     end
 end

data/lib/kuber_kit/env_file_reader/strategies/artifact_file.rb

@@ -1,8 +1,12 @@
 class KuberKit::EnvFileReader::Strategies::ArtifactFile < KuberKit::EnvFileReader::Strategies::Abstract
   include KuberKit::Import[
-    "core.artifact_store"
+    "core.artifact_store",
+    "env_file_reader.env_file_parser",
+    "preprocessing.text_preprocessor"
   ]
 
+  PREPROCESS_EXTENSIONS = [".erb"]
+
   def read(shell, env_file)
     artifact = artifact_store.get(env_file.artifact_name)
 
@@ -16,71 +20,11 @@ class KuberKit::EnvFileReader::Strategies::ArtifactFile < KuberKit::EnvFileReade
     def read_file(shell, file_path)
       result = {}
       content = shell.read(file_path)
-      Parser.call(content)
-    end
-
-  # Parser is based on:
-  # https://github.com/bkeepers/dotenv/blob/master/lib/dotenv/parser.rb
-  class Parser
-    LINE = /
-      (?:^|\A)              # beginning of line
-      \s*                   # leading whitespace
-      (?:export\s+)?        # optional export
-      ([\w\.]+)             # key
-      (?:\s*=\s*?|:\s+?)    # separator
-      (                     # optional value begin
-        \s*'(?:\\'|[^'])*'  #   single quoted value
-        |                   #   or
-        \s*"(?:\\"|[^"])*"  #   double quoted value
-        |                   #   or
-        [^\#\r\n]+          #   unquoted value
-      )?                    # value end
-      \s*                   # trailing whitespace
-      (?:\#.*)?             # optional comment
-      (?:$|\z)              # end of line
-    /x
-
-    class << self
-      def call(string, is_load = false)
-        new(string, is_load).call
+      enable_preprocessing = PREPROCESS_EXTENSIONS.any?{ |e| e == File.extname(file_path) }
+      if enable_preprocessing
+        content = text_preprocessor.compile(content)
       end
-    end
 
-    def initialize(string, is_load = false)
-      @string = string
-      @hash = {}
-      @is_load = is_load
+      env_file_parser.call(content)
     end
-
-    def call
-      # Convert line breaks to same format
-      lines = @string.gsub(/\r\n?/, "\n")
-      # Process matches
-      lines.scan(LINE).each do |key, value|
-        @hash[key] = parse_value(value || "")
-      end
-      @hash
-    end
-
-    private
-
-    def parse_value(value)
-      # Remove surrounding quotes
-      value = value.strip.sub(/\A(['"])(.*)\1\z/m, '\2')
-
-      if Regexp.last_match(1) == '"'
-        value = unescape_characters(expand_newlines(value))
-      end
-
-      value
-    end
-
-    def unescape_characters(value)
-      value.gsub(/\\([^$])/, '\1')
-    end
-
-    def expand_newlines(value)
-      value.gsub('\n', "\n").gsub('\r', "\r")
-    end
-  end
 end

data/lib/kuber_kit/env_file_reader/strategies/env_group.rb

@@ -0,0 +1,21 @@
+class KuberKit::EnvFileReader::Strategies::EnvGroup < KuberKit::EnvFileReader::Strategies::Abstract
+  include KuberKit::Import[
+    "env_file_reader.strategies.artifact_file",
+    "core.env_file_store",
+  ]
+
+  def read(shell, env_group)
+    content = {}
+    env_group.env_files.each do |env_file_name|
+      env_file = env_file_store.get(env_file_name)
+
+      if env_file.is_a?(KuberKit::Core::EnvFiles::EnvGroup)
+        raise "EnvGroup inside another EnvGroup is not supported"
+      end
+
+      result   = artifact_file.read(shell, env_file)
+      content  = content.merge(result)
+    end
+    content
+  end
+end

data/lib/kuber_kit/service_deployer/service_list_resolver.rb

@@ -46,9 +46,9 @@ class KuberKit::ServiceDeployer::ServiceListResolver
 
   Contract Array => Array
   def split_by_inclusion(array)
-    excluded, included = array.partition{|e| e.start_with?('!') }
+    excluded, included = array.partition{|e| e.start_with?('^') }
 
-    excluded.map!{ |item| item.gsub(/^\!/, "") }
+    excluded.map!{ |item| item.gsub(/^\^/, "") }
 
     [included, excluded]
   end

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

@@ -1,6 +1,8 @@
 class KuberKit::ServiceDeployer::Strategies::Docker < KuberKit::ServiceDeployer::Strategies::Abstract
   include KuberKit::Import[
+    "env_file_reader.env_file_tempfile_creator",
     "shell.docker_commands",
+    "core.env_file_store",
     "core.image_store",
     "configs",
   ]
@@ -18,6 +20,8 @@ class KuberKit::ServiceDeployer::Strategies::Docker < KuberKit::ServiceDeployer:
     :networks,
     :expose,
     :publish,
+    :env_file_names,
+    :env_vars
   ]
 
   Contract KuberKit::Shell::AbstractShell, KuberKit::Core::Service => Any
@@ -28,16 +32,20 @@ class KuberKit::ServiceDeployer::Strategies::Docker < KuberKit::ServiceDeployer:
       raise KuberKit::Error, "Unknow options for deploy strategy: #{unknown_options}. Available options: #{STRATEGY_OPTIONS}"
     end
     
-    namespace      = strategy_options.fetch(:namespace, nil)
-    container_name = strategy_options.fetch(:container_name, [namespace, service.name].compact.join("_"))
-    command_name   = strategy_options.fetch(:command_name, nil)
-    env_file       = strategy_options.fetch(:env_file, nil)
-    custom_args    = strategy_options.fetch(:custom_args, nil)
-    networks       = strategy_options.fetch(:networks, [])
-    volumes        = strategy_options.fetch(:volumes, [])
-    expose_ports   = strategy_options.fetch(:expose, [])
-    publish_ports  = strategy_options.fetch(:publish, [])
-    hostname       = strategy_options.fetch(:hostname, container_name)
+    namespace       = strategy_options.fetch(:namespace, nil)
+    container_name  = strategy_options.fetch(:container_name, [namespace, service.name].compact.join("_"))
+    command_name    = strategy_options.fetch(:command_name, nil)
+    custom_env_file = strategy_options.fetch(:env_file, nil)
+    custom_args     = strategy_options.fetch(:custom_args, nil)
+    networks        = strategy_options.fetch(:networks, [])
+    volumes         = strategy_options.fetch(:volumes, [])
+    expose_ports    = strategy_options.fetch(:expose, [])
+    publish_ports   = strategy_options.fetch(:publish, [])
+    hostname        = strategy_options.fetch(:hostname, container_name)
+
+    env_file_names  = strategy_options.fetch(:env_file_names, [])
+    env_files       = prepare_env_files(shell, env_file_names)
+    env_vars        = strategy_options.fetch(:env_vars, {})
 
     image_name = strategy_options.fetch(:image_name, nil)
     if image_name.nil?
@@ -54,8 +62,8 @@ class KuberKit::ServiceDeployer::Strategies::Docker < KuberKit::ServiceDeployer:
     if container_name
       custom_args << "--name #{container_name}"
     end
-    if env_file
-      custom_args << "--env-file #{env_file}"
+    if custom_env_file
+      custom_args << "--env-file #{custom_env_file}"
     end
     if hostname
       custom_args << "--hostname #{hostname}"
@@ -75,6 +83,12 @@ class KuberKit::ServiceDeployer::Strategies::Docker < KuberKit::ServiceDeployer:
     Array(publish_ports).each do |publish_port|
       custom_args << "--publish #{publish_port}"
     end
+    Array(env_files).each do |env_file|
+      custom_args << "--env-file #{env_file}"
+    end
+    env_vars.each do |key, value|
+      custom_args << "--env #{key}=#{value}"
+    end
 
     docker_commands.run(
       shell, image.remote_registry_url, 
@@ -84,4 +98,14 @@ class KuberKit::ServiceDeployer::Strategies::Docker < KuberKit::ServiceDeployer:
       interactive:  !strategy_options[:detached]
     )
   end
+
+  private
+    def prepare_env_files(shell, env_file_names)
+      env_files = env_file_names.map do |env_file_name|
+        env_file_store.get(env_file_name)
+      end
+      env_files.map do |env_file|
+        env_file_tempfile_creator.call(shell, env_file)
+      end
+    end
 end

data/lib/kuber_kit/template_reader/strategies/artifact_file.rb

@@ -3,10 +3,10 @@ class KuberKit::TemplateReader::Strategies::ArtifactFile < KuberKit::TemplateRea
     "core.artifact_store"
   ]
 
-  def read(shell, env_file)
-    artifact = artifact_store.get(env_file.artifact_name)
+  def read(shell, template)
+    artifact = artifact_store.get(template.artifact_name)
 
-    file_parts = [artifact.cloned_path, env_file.file_path].compact
+    file_parts = [artifact.cloned_path, template.file_path].compact
     file_path  = File.join(*file_parts)
 
     shell.read(file_path)

data/lib/kuber_kit/tools/logger_factory.rb

@@ -1,4 +1,5 @@
 require 'logger'
+require 'fileutils'
 
 class KuberKit::Tools::LoggerFactory
   SEVERITY_COLORS_BY_LEVEL = {
@@ -14,6 +15,10 @@ class KuberKit::Tools::LoggerFactory
   ]
 
   def create(stdout = nil, level = nil)
+    if !stdout
+      prepare_log_file(configs.log_file_path)
+    end
+    
     logger = Logger.new(stdout || configs.log_file_path)
 
     logger.level = level || Logger::DEBUG
@@ -35,4 +40,13 @@ class KuberKit::Tools::LoggerFactory
 
     logger
   end
+
+  private
+    def prepare_log_file(file_path)
+      dir_path = File.dirname(file_path)
+      unless Dir.exists?(dir_path)
+        FileUtils.mkdir_p(dir_path)
+      end
+      FileUtils.touch(file_path)
+    end
 end

data/lib/kuber_kit/tools/workdir_detector.rb

@@ -0,0 +1,33 @@
+class KuberKit::Tools::WorkdirDetector
+  include KuberKit::Import[
+    "configs",
+    "tools.file_presence_checker"
+  ]
+
+  def call(options, current_dir: nil)
+    current_dir ||= Dir.pwd
+    default_dir   = File.join(current_dir, configs.kuber_kit_dirname)
+    workdir_path  = options[:path] || ENV['KUBER_KIT_PATH'] || default_dir
+
+    unless file_presence_checker.dir_exists?(workdir_path)
+      workdir_in_ancestors = find_workdir_in_ancestors(current_dir)
+      workdir_path = workdir_in_ancestors if workdir_in_ancestors
+    end
+
+    workdir_path
+  end
+
+  private
+    def find_workdir_in_ancestors(dir)
+      if dir == "/"
+        return nil
+      end
+
+      workdir_path = File.join(dir, configs.kuber_kit_dirname)
+      if file_presence_checker.dir_exists?(workdir_path)
+        return workdir_path
+      end
+
+      find_workdir_in_ancestors(File.dirname(dir))
+    end
+end

data/lib/kuber_kit/version.rb

@@ -1,3 +1,3 @@
 module KuberKit
-  VERSION = "0.5.4"
+  VERSION = "0.5.9"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kuber_kit
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.5.9
 platform: ruby
 authors:
 - Iskander Khaziev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-03-18 00:00:00.000000000 Z
+date: 2021-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: contracts-lite
@@ -28,16 +28,16 @@ dependencies:
   name: dry-auto_inject
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.7.0
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: dry-container
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.2
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -184,6 +198,8 @@ files:
 - example/images/app_sources/Dockerfile
 - example/images/app_sources/build_context/source.rb
 - example/images/app_sources/image.rb
+- example/images/failing_app/Dockerfile
+- example/images/failing_app/image.rb
 - example/images/ruby/Dockerfile
 - example/images/ruby/image.rb
 - example/images/ruby_app/Dockerfile
@@ -200,9 +216,11 @@ files:
 - example/services/compose_app.rb
 - example/services/docker_app.rb
 - example/services/env_file.rb
+- example/services/failing_app.rb
 - example/services/ruby_app.rb
 - kuber_kit.gemspec
 - lib/kuber_kit.rb
+- lib/kuber_kit/actions/action_result.rb
 - lib/kuber_kit/actions/configuration_loader.rb
 - lib/kuber_kit/actions/env_file_reader.rb
 - lib/kuber_kit/actions/image_compiler.rb
@@ -245,6 +263,7 @@ files:
 - lib/kuber_kit/core/env_files/abstract_env_file.rb
 - lib/kuber_kit/core/env_files/artifact_file.rb
 - lib/kuber_kit/core/env_files/env_file_store.rb
+- lib/kuber_kit/core/env_files/env_group.rb
 - lib/kuber_kit/core/image.rb
 - lib/kuber_kit/core/image_definition.rb
 - lib/kuber_kit/core/image_definition_factory.rb
@@ -263,9 +282,12 @@ files:
 - lib/kuber_kit/core/templates/artifact_file.rb
 - lib/kuber_kit/core/templates/template_store.rb
 - lib/kuber_kit/env_file_reader/action_handler.rb
+- lib/kuber_kit/env_file_reader/env_file_parser.rb
+- lib/kuber_kit/env_file_reader/env_file_tempfile_creator.rb
 - lib/kuber_kit/env_file_reader/reader.rb
 - lib/kuber_kit/env_file_reader/strategies/abstract.rb
 - lib/kuber_kit/env_file_reader/strategies/artifact_file.rb
+- lib/kuber_kit/env_file_reader/strategies/env_group.rb
 - lib/kuber_kit/extensions/colored_string.rb
 - lib/kuber_kit/extensions/contracts.rb
 - lib/kuber_kit/extensions/indocker_compat.rb
@@ -312,6 +334,7 @@ files:
 - lib/kuber_kit/tools/file_presence_checker.rb
 - lib/kuber_kit/tools/logger_factory.rb
 - lib/kuber_kit/tools/process_cleaner.rb
+- lib/kuber_kit/tools/workdir_detector.rb
 - lib/kuber_kit/ui.rb
 - lib/kuber_kit/ui/api.rb
 - lib/kuber_kit/ui/debug.rb