kuber_kit 0.3.7 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e15ac135b8fd4fab45aee2797f1aa6c836e299e40175e6c518761af7d7557587
-  data.tar.gz: a998aa67c2389dad43604b610471f9b196456dffb100926d25e3acbf6782494f
+  metadata.gz: 88b8c2ffe3973bc966b245ceba37047030243d88119fd672db31efb002c67f86
+  data.tar.gz: 5fafd218e63a669da3951b723f7167700704902006d4dd4fef13541e8ad1559b
 SHA512:
-  metadata.gz: ac0c29ae11579f2431f8fc7972027b8551866d96cc212d4117eddfb91694d7680a73f0d6d867f955746475e404cd6136b8d4ad228e5489366df7f881cbba92be
-  data.tar.gz: d29aaa6aa028eef516f91a8f9081fd4a9d32c5c9f850755c7bea8583240c9b3bf2636dc2bab745fa778062c2a45334fc043d49d69d10963c574be4f26fc66044
+  metadata.gz: a1c79c0056820500948580504c533be1ba2f9ceafe282802a0bbe44021a34196706c23eb97b05e6905efc26f565719fd9a1c668ec99afdbda642261ad6e8b6e1
+  data.tar.gz: 3e4e33cc19ff7917ee5210dcdecae40ed22cb29d93f884bdb27adf3ec8565d3397ee8715ed8e89e75ae0316a0cf9192075d5afd66ba55caf3fe4f060064c88b9

data/.github/workflows/rspec.yml

@@ -0,0 +1,35 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: Rspec
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['2.5', '2.7']
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
+    # change this to (see https://github.com/ruby/setup-ruby#versioning):
+    # uses: ruby/setup-ruby@v1
+      uses: ruby/setup-ruby@473e4d8fe5dd94ee328fdfca9f8c9c7afc9dae5e
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Run tests
+      run: bundle exec rspec spec/

data/Gemfile.lock

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

data/README.md

@@ -1,6 +1,6 @@
 # KuberKit
 
-[![Codeship Status for ArtStation/kuber_kit](https://app.codeship.com/projects/1286f0a6-3f90-4c1b-b426-721ed8a6571b/status?branch=master)](https://app.codeship.com/projects/417264)
+[![Rspec](https://github.com/ArtStation/kuber_kit/workflows/Rspec/badge.svg)](https://github.com/ArtStation/kuber_kit/actions?query=workflow%3ARspec)
 
 Solution for building & deploying applications on Kubernetes, written in Ruby.
 

data/TODO.md

@@ -5,4 +5,5 @@
 - allow deploying only services enabled for specific configuration
 - find a way to always deploy some service, e.g. for migrations and env_files
 - template should be able to set default attributes
-- template should be able to depend on image?
+- template should be able to depend on image?
+- cleanup image builds older than some date

data/example/infrastructure/artifacts.rb

@@ -9,5 +9,5 @@ KuberKit.add_artifact(
 KuberKit.add_artifact(
   KuberKit::Core::Artifacts::Git
     .new(:kuber_kit_repo)
-    .setup(remote_url: "git@github.com:ArtStation/kuber_kit.git")
+    .setup(remote_url: "git@github.com:ArtStation/kuber_kit.git", branch: "main")
 )

data/example/services/docker_app.rb

@@ -0,0 +1,12 @@
+KuberKit
+  .define_service(:docker_app)
+  .images(:ruby_app)
+  .deployer_strategy(:docker)
+  .attributes(
+    deployer: {
+      detached:         true,
+      image_name:       :ruby_app,
+      container_name:   "test_docker_app",
+      delete_if_exists: true
+    }
+  )

data/lib/kuber_kit.rb

@@ -177,6 +177,8 @@ module KuberKit
   module UI
     autoload :Interactive, 'ui/interactive'
     autoload :Simple, 'ui/simple'
+    autoload :Debug, 'ui/debug'
+    autoload :Api, 'ui/api'
   end
 
   autoload :CLI, 'cli'
@@ -205,12 +207,12 @@ module KuberKit
       @current_configuration = nil
     end
 
-    def set_debug_mode(value)
-      @debug_mode = value
+    def set_ui_mode(value)
+      @ui_mode = value
     end
     
-    def debug_mode?
-      !!@debug_mode
+    def ui_mode
+      @ui_mode
     end
 
     def deprecation_warnings_disabled?

data/lib/kuber_kit/actions/configuration_loader.rb

@@ -1,13 +1,10 @@
 class KuberKit::Actions::ConfigurationLoader
-  APP_CONFIG_FILENAME = "config.rb".freeze
-
   include KuberKit::Import[
     "core.registry_store",
     "core.image_store",
     "core.service_store",
     "core.configuration_store",
     "artifacts_sync.artifacts_updater",
-    "tools.logger",
     "shell.local_shell",
     "ui",
     "configs"
@@ -16,29 +13,24 @@ 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)
     configurations_path  = options[:configurations_path]  || File.join(root_path, configs.configurations_dirname)
     configuration_name   = ENV["KUBER_KIT_CONFIGURATION"] || options[:configuration]
 
-    logger.info "Launching kuber_kit with:"
-    logger.info "  Root path: #{root_path.to_s.yellow}"
-    logger.info "  Images path: #{images_path.to_s.yellow}"
-    logger.info "  Services path: #{services_path.to_s.yellow}"
-    logger.info "  Infrastructure path: #{infra_path.to_s.yellow}"
-    logger.info "  Configurations path: #{configurations_path.to_s.yellow}"
-    logger.info "  Configuration name: #{configuration_name.to_s.yellow}"
+    ui.print_debug "ConfigurationLoader", "Launching kuber_kit with:"
+    ui.print_debug "ConfigurationLoader", "  Root path: #{root_path.to_s.yellow}"
+    ui.print_debug "ConfigurationLoader", "  Images path: #{images_path.to_s.yellow}"
+    ui.print_debug "ConfigurationLoader", "  Services path: #{services_path.to_s.yellow}"
+    ui.print_debug "ConfigurationLoader", "  Infrastructure path: #{infra_path.to_s.yellow}"
+    ui.print_debug "ConfigurationLoader", "  Configurations path: #{configurations_path.to_s.yellow}"
+    ui.print_debug "ConfigurationLoader", "  Configuration name: #{configuration_name.to_s.yellow}"
+
+    ui.print_info("Logs", "See logs at: #{configs.log_file_path}")
 
     unless File.exists?(root_path)
-      ui.print_warning "WARNING", "KuberKit root path #{root_path} doesn't exist. You may want to pass it --path parameter."
+      ui.print_warning "ConfigurationLoader", "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)
@@ -72,6 +64,7 @@ class KuberKit::Actions::ConfigurationLoader
     true
   rescue KuberKit::Error => e
     ui.print_error("Error", e.message)
+    
     false
   end
   
@@ -104,6 +97,6 @@ class KuberKit::Actions::ConfigurationLoader
       require(path)
     end
   rescue KuberKit::Shell::AbstractShell::DirNotFoundError
-    logger.warn("Directory with infrastructure not found: #{infra_path}")
+    ui.print_warning("ConfigurationLoader", "Directory with infrastructure not found: #{infra_path}")
   end
 end

data/lib/kuber_kit/actions/env_file_reader.rb

@@ -15,6 +15,7 @@ class KuberKit::Actions::EnvFileReader
     true
   rescue KuberKit::Error => e
     ui.print_error("Error", e.message)
+    
     false
   end
 end

data/lib/kuber_kit/actions/image_compiler.rb

@@ -3,7 +3,6 @@ class KuberKit::Actions::ImageCompiler
     "image_compiler.image_dependency_resolver",
     "image_compiler.build_server_pool_factory",
     "shell.local_shell",
-    "tools.logger",
     "ui",
     image_compiler: "image_compiler.action_handler",
   ]
@@ -13,14 +12,17 @@ class KuberKit::Actions::ImageCompiler
     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|
       result = compile_simultaneously(dep_image_names, build_id, build_server_pool)
-      abort unless result
+      compiled_images += dep_image_names
+      compilation_result = compilation_result.merge(result)
     end
 
     build_server_pool.disconnect_all
 
-    true
+    { images: compiled_images, compilation: compilation_result }
   rescue KuberKit::Error => e
     ui.print_error("Error", e.message)
 
@@ -30,20 +32,22 @@ class KuberKit::Actions::ImageCompiler
   private
     def compile_simultaneously(image_names, build_id, build_server_pool)
       task_group = ui.create_task_group
+      compiler_result = {}
       image_names.map do |image_name|
 
-        logger.info("Started compiling: #{image_name.to_s.green}")
+        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
           
-          image_compiler.call(shell, image_name, build_id)
+          compiler_result[image_name] = image_compiler.call(shell, image_name, build_id)
 
           task.update_title("Compiled #{image_name.to_s.green}")
-          logger.info("Finished compiling: #{image_name.to_s.green}")
+          ui.print_debug("ImageCompiler", "Finished compiling: #{image_name}")
         end
         
       end
       task_group.wait
+      compiler_result
     end
 
     def generate_build_id

data/lib/kuber_kit/actions/service_deployer.rb

@@ -4,7 +4,6 @@ class KuberKit::Actions::ServiceDeployer
     "service_deployer.service_list_resolver",
     "core.service_store",
     "shell.local_shell",
-    "tools.logger",
     "ui",
     service_deployer: "service_deployer.action_handler",
   ]
@@ -25,7 +24,7 @@ class KuberKit::Actions::ServiceDeployer
     )
 
     unless service_names.any?
-      ui.print_warning "WARNING", "No service found with given options, nothing will be deployed."
+      ui.print_warning "ServiceDeployer", "No service found with given options, nothing will be deployed."
     end
 
     services = service_names.map do |service_name|
@@ -35,9 +34,9 @@ class KuberKit::Actions::ServiceDeployer
     images_names = services.map(&:images).flatten.uniq
 
     compile_images(images_names) unless skip_compile
-    deploy_services(service_names)
+    deployment_result = deploy_services(service_names)
 
-    true
+    { services: service_names, deployment: deployment_result }
   rescue KuberKit::Error => e
     ui.print_error("Error", e.message)
 
@@ -47,18 +46,22 @@ class KuberKit::Actions::ServiceDeployer
   def deploy_services(service_names)
     task_group = ui.create_task_group
 
+    deployer_result = {}
+
     service_names.each do |service_name|
 
-      logger.info("Started deploying: #{service_name.to_s.green}")
+      ui.print_debug("ServiceDeployer", "Started deploying: #{service_name.to_s.green}")
       task_group.add("Deploying #{service_name.to_s.yellow}") do |task|
-        service_deployer.call(local_shell, service_name.to_sym)
+        deployer_result[service_name] = service_deployer.call(local_shell, service_name.to_sym)
 
         task.update_title("Deployed #{service_name.to_s.green}")
-        logger.info("Finished deploying: #{service_name.to_s.green}")
+        ui.print_debug("ServiceDeployer", "Finished deploying: #{service_name.to_s.green}")
       end
     end
 
     task_group.wait
+
+    deployer_result
   end
 
   def compile_images(images_names)

data/lib/kuber_kit/actions/template_reader.rb

@@ -14,6 +14,7 @@ class KuberKit::Actions::TemplateReader
     true
   rescue KuberKit::Error => e
     ui.print_error("Error", e.message)
+    
     false
   end
 end

data/lib/kuber_kit/artifacts_sync/artifacts_updater.rb

@@ -4,7 +4,8 @@ class KuberKit::ArtifactsSync::ArtifactsUpdater
   include KuberKit::Import[
     "artifacts_sync.git_artifact_resolver",
     "artifacts_sync.null_artifact_resolver",
-    "tools.logger"
+
+    "ui"
   ]
 
   def use_resolver(artifact_resolver, artifact_class:)
@@ -23,7 +24,7 @@ class KuberKit::ArtifactsSync::ArtifactsUpdater
     artifacts.each do |artifact|
       resolver = @@resolvers[artifact.class]
 
-      logger.info "Updating artifact #{artifact.name.to_s.green}"
+      ui.print_debug "ArtifactUpdater", "Updating artifact #{artifact.name.to_s.green}"
       
       raise ResolverNotFoundError, "Can't find resolver for artifact #{artifact}" if resolver.nil?
 

data/lib/kuber_kit/cli.rb

@@ -1,16 +1,19 @@
 require 'thor'
 
 class KuberKit::CLI < Thor
+  APP_CONFIG_FILENAME = "config.rb".freeze
+
   class_option :path, :type => :string
   class_option :images_path, :type => :string
   class_option :infra_path, :type => :string
   class_option :configurations_path, :type => :string
+  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"]
 
   desc "compile IMAGE_NAMES", "Compile image with IMAGE_NAMES (comma-separated)"
   def compile(image_names_str)
-    KuberKit.set_debug_mode(options[:debug])
+    setup(options)
     
     image_names = image_names_str.split(",").map(&:strip).map(&:to_sym)
 
@@ -18,15 +21,10 @@ class KuberKit::CLI < Thor
       result = KuberKit::Container['actions.image_compiler'].call(image_names, options)
     end
 
-    logger = KuberKit::Container['tools.logger']
     if result
-      logger.info("---------------------------")
-      logger.info("Image compilation finished!")
-      logger.info("---------------------------")
+      print_result("Image compilation finished!", result: result)
     else
-      logger.info("-------------------------".red)
-      logger.info("Image compilation failed!".red)
-      logger.info("-------------------------".red)
+      exit 1
     end
   end
 
@@ -35,7 +33,7 @@ class KuberKit::CLI < Thor
   method_option :tags,          :type => :array,    aliases: ["-t"]
   method_option :skip_compile,  :type => :boolean,  aliases: ["-B"]
   def deploy
-    KuberKit.set_debug_mode(options[:debug])
+    setup(options)
 
     if KuberKit::Container['actions.configuration_loader'].call(options)
       result = KuberKit::Container['actions.service_deployer'].call(
@@ -45,21 +43,16 @@ class KuberKit::CLI < Thor
       )
     end
 
-    logger = KuberKit::Container['tools.logger']
     if result
-      logger.info("---------------------------")
-      logger.info("Service deployment finished!")
-      logger.info("---------------------------")
+      print_result("Service deployment finished!", result: result)
     else
-      logger.info("-------------------------".red)
-      logger.info("Service deployment failed!".red)
-      logger.info("-------------------------".red)
+      exit 1
     end
   end
 
   desc "env ENV_FILE_NAME", "Return content of Env File ENV_FILE_NAME"
   def env(env_file_name)
-    KuberKit.set_debug_mode(options[:debug])
+    setup(options)
 
     if KuberKit::Container['actions.configuration_loader'].call(options)
       KuberKit::Container['actions.env_file_reader'].call(env_file_name.to_sym, options)
@@ -68,7 +61,7 @@ class KuberKit::CLI < Thor
 
   desc "template TEMPLATE_NAME", "Return content of Template TEMPLATE_NAME"
   def template(template_name)
-    KuberKit.set_debug_mode(options[:debug])
+    setup(options)
 
     if KuberKit::Container['actions.configuration_loader'].call(options)
       KuberKit::Container['actions.template_reader'].call(template_name.to_sym, options)
@@ -77,7 +70,7 @@ class KuberKit::CLI < Thor
 
   desc "service SERVICE_NAME", "Return content of Service SERVICE_NAME"
   def service(service_name)
-    KuberKit.set_debug_mode(options[:debug])
+    setup(options)
 
     if KuberKit::Container['actions.configuration_loader'].call(options)
       KuberKit::Container['actions.service_reader'].call(service_name.to_sym, options)
@@ -86,7 +79,7 @@ class KuberKit::CLI < Thor
 
   desc "apply FILE_PATH", "Apply FILE_PATH with kubectl"
   def apply(file_path)
-    KuberKit.set_debug_mode(options[:debug])
+    setup(options)
 
     if KuberKit::Container['actions.configuration_loader'].call(options)
       KuberKit::Container['actions.kubectl_applier'].call(File.expand_path(file_path), options)
@@ -95,26 +88,26 @@ class KuberKit::CLI < Thor
 
   desc "attach POD_NAME", "Attach to POD_NAME using kubectl"
   def attach(pod_name = nil)
-    KuberKit.set_debug_mode(options[:debug])
+    setup(options)
 
     if KuberKit::Container['actions.configuration_loader'].call(options)
       KuberKit::Container['actions.kubectl_attacher'].call(pod_name, options)
     end
   end
 
-  desc "launch console in POD_NAME", "Attach to POD_NAME using kubectl & launch bin/console"
+  desc "console POD_NAME", "Attach to POD_NAME using kubectl & launch bin/console"
   def console(pod_name = nil)
-    KuberKit.set_debug_mode(options[:debug])
+    setup(options)
 
     if KuberKit::Container['actions.configuration_loader'].call(options)
       KuberKit::Container['actions.kubectl_console'].call(pod_name, options)
     end
   end
 
-  desc "show logs for POD_NAME", "Show logs for POD_NAME using kubectl"
+  desc "logs POD_NAME", "Show logs for POD_NAME using kubectl"
   method_option :follow,  :type => :boolean,  aliases: ["-f"]
   def logs(pod_name = nil)
-    KuberKit.set_debug_mode(options[:debug])
+    setup(options)
 
     if KuberKit::Container['actions.configuration_loader'].call(options)
       KuberKit::Container['actions.kubectl_logs'].call(pod_name, options)
@@ -129,4 +122,24 @@ class KuberKit::CLI < Thor
   def self.exit_on_failure?
     true
   end
+
+  private
+    def setup(options)
+      if options[:debug]
+        KuberKit.set_ui_mode(:debug)
+      elsif options[:ui]
+        KuberKit.set_ui_mode(options[:ui].to_sym)
+      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)
+      config_file_path = File.join(root_path, APP_CONFIG_FILENAME)
+      if File.exists?(config_file_path)
+        require config_file_path
+      end
+    end
+
+    def print_result(message, data = {})
+      KuberKit::Container['ui'].print_result(message, data)
+    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,
-    :additional_images_paths, :deprecation_warnings_disabled
+    :additional_images_paths, :deprecation_warnings_disabled, :log_file_path
   ]
   DOCKER_IGNORE_LIST = [
     'Dockerfile',
@@ -51,6 +51,7 @@ class KuberKit::Configs
     set :compile_simultaneous_limit, 5
     set :additional_images_paths, []
     set :deprecation_warnings_disabled, false
+    set :log_file_path,           "/tmp/kuber_kit.log"
   end
 
   def items

data/lib/kuber_kit/container.rb

@@ -114,7 +114,7 @@ class KuberKit::Container
   end
 
   register "tools.logger" do
-    KuberKit::Container["tools.logger_factory"].create("/tmp/kuber_kit.log")
+    KuberKit::Container["tools.logger_factory"].create()
   end
 
   register "shell.bash_commands" do
@@ -258,8 +258,12 @@ class KuberKit::Container
   end
 
   register "ui" do
-    if KuberKit.debug_mode?
+    if KuberKit.ui_mode == :debug
+      KuberKit::UI::Debug.new
+    elsif KuberKit.ui_mode == :simple
       KuberKit::UI::Simple.new
+    elsif KuberKit.ui_mode == :api
+      KuberKit::UI::Api.new
     else
       KuberKit::UI::Interactive.new
     end

data/lib/kuber_kit/core/configuration_store.rb

@@ -3,7 +3,7 @@ class KuberKit::Core::ConfigurationStore
     "core.configuration_factory",
     "core.configuration_definition_factory",
     "shell.local_shell",
-    "tools.logger"
+    "ui"
   ]
 
   def define(configuration_name)
@@ -33,7 +33,7 @@ class KuberKit::Core::ConfigurationStore
       load_definition(path)
     end
   rescue KuberKit::Shell::AbstractShell::DirNotFoundError
-    logger.warn("Directory with configurations not found: #{dir_path}")
+    ui.print_warning("ConfigurationStore", "Directory with configurations not found: #{dir_path}")
     []
   end
 

data/lib/kuber_kit/core/image_store.rb

@@ -3,7 +3,7 @@ class KuberKit::Core::ImageStore
     "core.image_factory",
     "core.image_definition_factory",
     "shell.local_shell",
-    "tools.logger"
+    "ui"
   ]
 
   def define(image_name, image_dir = nil)
@@ -33,7 +33,7 @@ class KuberKit::Core::ImageStore
       load_definition(path)
     end
   rescue KuberKit::Shell::AbstractShell::DirNotFoundError
-    logger.warn("Directory with images not found: #{dir_path}")
+    ui.print_warning("ImageStore", "Directory with images not found: #{dir_path}")
     []
   end
 

data/lib/kuber_kit/core/service.rb

@@ -4,11 +4,11 @@ class KuberKit::Core::Service
   attr_reader :name, :template_name, :tags, :images, :attributes, :deployer_strategy
 
   Contract KeywordArgs[
-    name:             Symbol,
-    template_name:    Symbol,
-    tags:             ArrayOf[Symbol],
-    images:           ArrayOf[Symbol],
-    attributes:       HashOf[Symbol => Any],
+    name:               Symbol,
+    template_name:      Maybe[Symbol],
+    tags:               ArrayOf[Symbol],
+    images:             ArrayOf[Symbol],
+    attributes:         HashOf[Symbol => Any],
     deployer_strategy:  Maybe[Symbol]
   ] => Any
   def initialize(name:, template_name:, tags:, images:, attributes:, deployer_strategy:)

data/lib/kuber_kit/core/service_factory.rb

@@ -1,13 +1,7 @@
 class KuberKit::Core::ServiceFactory
-  AttributeNotSetError = Class.new(KuberKit::Error)
-
   def create(definition)
     service_attrs = definition.to_service_attrs
 
-    if service_attrs.template_name.nil?
-      raise AttributeNotSetError, "Please set template for service using #template method"
-    end
-
     configuration_attributes = KuberKit.current_configuration.service_attributes(service_attrs.name)
     attributes = (service_attrs.attributes || {}).merge(configuration_attributes)
 

data/lib/kuber_kit/core/service_store.rb

@@ -3,7 +3,7 @@ class KuberKit::Core::ServiceStore
     "core.service_factory",
     "core.service_definition_factory",
     "shell.local_shell",
-    "tools.logger"
+    "ui",
   ]
 
   def define(service_name)
@@ -33,7 +33,7 @@ class KuberKit::Core::ServiceStore
       load_definition(path)
     end
   rescue KuberKit::Shell::AbstractShell::DirNotFoundError
-    logger.warn("Directory with services not found: #{dir_path}")
+    ui.print_warning("ServiceStore", "Directory with services not found: #{dir_path}")
     []
   end
 

data/lib/kuber_kit/image_compiler/compiler.rb

@@ -12,7 +12,9 @@ class KuberKit::ImageCompiler::Compiler
     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)
+    result = image_builder.build(shell, image, image_build_dir, context_helper: context_helper)
     image_build_dir_creator.cleanup(shell, image_build_dir)
+
+    result
   end
 end

data/lib/kuber_kit/image_compiler/image_builder.rb

@@ -10,7 +10,13 @@ class KuberKit::ImageCompiler::ImageBuilder
   def build(shell, image, build_dir, context_helper: nil)
     image.before_build_callback.call(context_helper, build_dir) if image.before_build_callback
 
-    docker_commands.build(shell, build_dir, ["-t=#{image.registry_url}"])
+    build_options = ["-t=#{image.registry_url}"]
+    # use quite option for api mode ui, so it will only return built image id
+    if KuberKit.ui_mode == :api
+      build_options << "-q"
+    end
+
+    build_result = docker_commands.build(shell, build_dir, build_options)
 
     version_tag = version_tag_builder.get_version
     docker_commands.tag(shell, image.registry_url, version_tag)
@@ -21,5 +27,7 @@ class KuberKit::ImageCompiler::ImageBuilder
     end
 
     image.after_build_callback.call(context_helper, build_dir) if image.after_build_callback
+
+    build_result
   end
 end

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

@@ -8,8 +8,9 @@ class KuberKit::ServiceDeployer::Strategies::Docker < KuberKit::ServiceDeployer:
   STRATEGY_OPTIONS = [
     :container_name,
     :image_name,
-    :docker_run_args,
-    :docker_run_command,
+    :detached,
+    :command_name,
+    :command_args,
     :delete_if_exists
   ]
 
@@ -21,9 +22,9 @@ class KuberKit::ServiceDeployer::Strategies::Docker < KuberKit::ServiceDeployer:
       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)
+    container_name = strategy_options.fetch(:container_name, service.uri)
+    command_name   = strategy_options.fetch(:command_name, "bash")
+    command_args   = strategy_options.fetch(:command_args, nil)
 
     image_name = strategy_options.fetch(:image_name, nil)
     if image_name.nil?
@@ -36,11 +37,16 @@ class KuberKit::ServiceDeployer::Strategies::Docker < KuberKit::ServiceDeployer:
       docker_commands.delete_container(shell, container_name)
     end
 
+    command_args = Array(command_args)
+    if container_name
+      command_args << "--name #{container_name}"
+    end
+
     docker_commands.run(
       shell, image.remote_registry_url, 
-      run_args:     docker_run_args, 
-      run_command:  docker_run_command,
-      detached:     !!strategy_options[:detached]
+      command:    command_name,
+      args:       command_args, 
+      detached:   !!strategy_options[:detached]
     )
   end
 end

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

@@ -7,7 +7,9 @@ class KuberKit::ServiceDeployer::Strategies::DockerCompose < KuberKit::ServiceDe
 
   STRATEGY_OPTIONS = [
     :service_name, 
-    :command_name
+    :command_name,
+    :command_args,
+    :detached
   ]
 
   Contract KuberKit::Shell::AbstractShell, KuberKit::Core::Service => Any
@@ -24,10 +26,12 @@ class KuberKit::ServiceDeployer::Strategies::DockerCompose < KuberKit::ServiceDe
 
     service_name = strategy_options.fetch(:service_name, service.name.to_s)
     command_name = strategy_options.fetch(:command_name, "bash")
+    command_args = strategy_options.fetch(:command_args, nil)
 
     docker_compose_commands.run(shell, config_path, 
       service:  service_name, 
       command:  command_name,
+      args:     command_args, 
       detached: !!strategy_options[:detached]
     )
   end

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

@@ -39,7 +39,7 @@ class KuberKit::ServiceDeployer::Strategies::Kubernetes < KuberKit::ServiceDeplo
       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: namespace)
+    apply_result = kubectl_commands.apply_file(shell, config_path, kubeconfig_path: kubeconfig_path, namespace: namespace)
 
     restart_enabled = strategy_options.fetch(:restart_if_exists, true)
     if restart_enabled && resource_exists
@@ -48,5 +48,7 @@ class KuberKit::ServiceDeployer::Strategies::Kubernetes < KuberKit::ServiceDeplo
         kubeconfig_path: kubeconfig_path, namespace: namespace
       )
     end
+    
+    apply_result
   end
 end

data/lib/kuber_kit/service_reader/reader.rb

@@ -6,8 +6,14 @@ class KuberKit::ServiceReader::Reader
     "preprocessing.text_preprocessor"
   ]
 
+  AttributeNotSetError = Class.new(KuberKit::Error)
+
   Contract KuberKit::Shell::AbstractShell, KuberKit::Core::Service => Any
   def read(shell, service)
+    if service.template_name.nil?
+      raise AttributeNotSetError, "Please set template for service using #template method"
+    end
+
     template = template_store.get(service.template_name)
 
     context_helper = context_helper_factory.build_service_context(shell, service)

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

@@ -3,7 +3,7 @@ class KuberKit::Shell::Commands::DockerCommands
     default_args = ["--rm=true"]
     args_list = (default_args + args).join(" ")
 
-    shell.exec!(%Q{docker build #{build_dir} #{args_list}})
+    shell.exec!(%Q{docker image build #{build_dir} #{args_list}})
   end
 
   def tag(shell, image_name, tag_name)
@@ -14,19 +14,23 @@ class KuberKit::Shell::Commands::DockerCommands
     shell.exec!(%Q{docker push #{tag_name}})
   end
 
-  def run(shell, image_name, run_args: nil, run_command: nil, detached: false)
+  def run(shell, image_name, args: nil, command: nil, detached: false, interactive: false)
     command_parts = []
     command_parts << "docker run"
     command_parts << "-d" if detached
-    command_parts << run_args if run_args
+    command_parts << Array(args).join(" ") if args
     command_parts << image_name
-    command_parts << run_command if run_command
+    command_parts << command if command
 
-    shell.exec!(command_parts.join(" "))
+    if interactive
+      shell.interactive!(command_parts.join(" "))
+    else
+      shell.exec!(command_parts.join(" "))
+    end
   end
 
-  def container_exists?(shell, container_name)
-    result = get_container_id(shell, container_name)
+  def container_exists?(shell, container_name, status: nil)
+    result = get_container_id(shell, container_name, status: status)
     result && result != ""
   end
 
@@ -34,15 +38,16 @@ class KuberKit::Shell::Commands::DockerCommands
     shell.exec!(%Q{docker rm -f #{container_name}})
   end
 
-  def get_container_id(shell, container_name, only_healthy: false, status: "running")
+  def get_container_id(shell, container_name, only_healthy: false, status: nil)
     command_parts = []
     command_parts << "docker ps -a -q"
 
     if only_healthy
       command_parts << "--filter=\"health=healthy\""
     end
-
-    command_parts << "--filter=\"status=#{status}\""
+    if status
+      command_parts << "--filter=\"status=#{status}\""
+    end
     command_parts << "--filter=\"name=#{container_name}\""
 
     shell.exec!(command_parts.join(" "))

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

@@ -1,17 +1,16 @@
 class KuberKit::Shell::Commands::DockerComposeCommands
-  def run(shell, path, service:, command:, interactive: false, detached: false)
+  def run(shell, path, service:, args: nil, command: nil, detached: false, interactive: false)
     command_parts = [
       "docker-compose",
-      "run",
       "-f #{path}",
+      "run",
     ]
     
-    if detached
-      command_parts << "-d"
-    end
 
+    command_parts << "-d" if detached
+    command_parts << Array(args).join(" ") if args
     command_parts << service
-    command_parts << command
+    command_parts << command if command
     
     if interactive
       shell.interactive!(command_parts.join(" "))

data/lib/kuber_kit/shell/local_shell.rb

@@ -2,16 +2,16 @@ require 'fileutils'
 
 class KuberKit::Shell::LocalShell < KuberKit::Shell::AbstractShell
   include KuberKit::Import[
-    "tools.logger",
     "shell.command_counter",
     "shell.rsync_commands",
+    "ui",
   ]
 
   def exec!(command, log_command: true)
     command_number = command_counter.get_number.to_s.rjust(2, "0")
     
     if log_command
-      logger.info("Execute: [#{command_number}]: #{command.to_s.cyan}")
+      ui.print_debug("LocalShell", "Execute: [#{command_number}]: #{command.to_s.cyan}")
     end
 
     result = nil
@@ -20,7 +20,7 @@ class KuberKit::Shell::LocalShell < KuberKit::Shell::AbstractShell
     end
 
     if result && result != "" && log_command
-      logger.info("Finished [#{command_number}] with result: \n#{result.grey}")
+      ui.print_debug("LocalShell", "Finished [#{command_number}] with result: \n  ----\n#{result.grey}\n  ----")
     end
 
     if $?.exitstatus != 0
@@ -34,7 +34,7 @@ class KuberKit::Shell::LocalShell < KuberKit::Shell::AbstractShell
     command_number = command_counter.get_number.to_s.rjust(2, "0")
     
     if log_command
-      logger.info("Interactive: [#{command_number}]: #{command.to_s.cyan}")
+      ui.print_debug("LocalShell", "Interactive: [#{command_number}]: #{command.to_s.cyan}")
     end
 
     result = system(command)
@@ -57,7 +57,7 @@ class KuberKit::Shell::LocalShell < KuberKit::Shell::AbstractShell
 
     File.write(file_path, content)
 
-    logger.info("Created file #{file_path.to_s.cyan}\r\n#{content.grey}")
+    ui.print_debug("LocalShell", "Created file #{file_path.to_s.cyan}\r\n  ----\r\n#{content.grey}\r\n  ----")
 
     true
   end
@@ -76,7 +76,7 @@ class KuberKit::Shell::LocalShell < KuberKit::Shell::AbstractShell
 
   def recursive_list_files(path, name: nil)
     command = %Q{find -L #{path}  -type f}
-    command += " -name #{name}" if name
+    command += " -name '#{name}'" if name
     exec!(command).split(/[\r\n]+/)
   rescue => e
     if e.message.include?("No such file or directory")

data/lib/kuber_kit/shell/ssh_shell.rb

@@ -2,7 +2,7 @@ require 'tempfile'
 
 class KuberKit::Shell::SshShell < KuberKit::Shell::LocalShell
   include KuberKit::Import[
-    "tools.logger",
+    "ui",
     "shell.command_counter",
     "shell.rsync_commands",
     "shell.local_shell"
@@ -24,13 +24,13 @@ class KuberKit::Shell::SshShell < KuberKit::Shell::LocalShell
     command_number = command_counter.get_number.to_s.rjust(2, "0")
     
     if log_command
-      logger.info("#{ssh_session.host.green} > Execute: [#{command_number}]: #{command.to_s.cyan}")
+      ui.print_debug("SshShell", "#{ssh_session.host.green} > Execute: [#{command_number}]: #{command.to_s.cyan}")
     end
 
     result = ssh_session.exec!(command)
 
     if result && result != "" && log_command
-      logger.info("#{ssh_session.host.green} > Finished [#{command_number}] with result: \n#{result.grey}")
+      ui.print_debug("SshShell", "#{ssh_session.host.green} > Finished [#{command_number}] with result: \n#{result.grey}")
     end
 
     result
@@ -62,7 +62,7 @@ class KuberKit::Shell::SshShell < KuberKit::Shell::LocalShell
       sync(file.path, file_path)
     end
 
-    logger.info("Created file #{file_path.to_s.cyan}\r\n#{content.grey}")
+    ui.print_debug("SshShell", "Created file #{file_path.to_s.cyan}\r\n  ----\r\n#{content.grey}\r\n  ----")
 
     true
   end

data/lib/kuber_kit/tools/logger_factory.rb

@@ -9,8 +9,12 @@ class KuberKit::Tools::LoggerFactory
     Logger::FATAL  => String::Colors::PURPLE,
   }
 
-  def create(stdout, level = nil)
-    logger = Logger.new(stdout)
+  include KuberKit::Import[
+    "configs",
+  ]
+
+  def create(stdout = nil, level = nil)
+    logger = Logger.new(stdout || configs.log_file_path)
 
     logger.level = level || Logger::DEBUG
 
@@ -22,7 +26,7 @@ class KuberKit::Tools::LoggerFactory
       severity_text  = severity.to_s
       severity_text  = severity_text.colorize(severity_color) if severity_color
 
-      if level == Logger::INFO
+      if level == Logger::DEBUG
         "#{datetime.strftime("%Y/%m/%d %H:%M:%S").grey} #{msg}\n"
       else
         "#{datetime.strftime("%Y/%m/%d %H:%M:%S").grey} #{severity_text.downcase}: #{msg}\n"

data/lib/kuber_kit/ui/api.rb

@@ -0,0 +1,48 @@
+require 'json'
+class KuberKit::UI::Api < KuberKit::UI::Simple
+  class Task < KuberKit::UI::Simple::Task
+    def print_started
+      # do nothing, api formatter should only show result
+    end
+
+    def print_finished
+      # do nothing, api formatter should only show result
+    end
+  end
+
+  def create_task_group
+    TaskGroup.new(KuberKit::UI::Api::Task)
+  end
+
+  def create_task(title, &block)
+    task = KuberKit::UI::Api::Task.new(title, &block)
+    task.execute
+    task.wait
+  end
+
+  def print_info(title, text)
+    logger.debug(text)
+  end
+
+  def print_error(title, text)
+    logger.debug(text)
+    print_json({error: text})
+  end
+
+  def print_warning(title, text)
+    logger.debug(text)
+  end
+
+  def print_debug(title, text)
+    logger.debug(text)
+  end
+
+  def print_result(message, data = {})
+    print_json({message: message}.merge(data))
+  end
+
+  protected
+    def print_json(data)
+      puts JSON.generate(data)
+    end
+end

data/lib/kuber_kit/ui/debug.rb

@@ -0,0 +1,31 @@
+class KuberKit::UI::Debug < KuberKit::UI::Simple
+  def print_info(title, text)
+    print_text(text, color: String::Colors::BLUE)
+  end
+
+  def print_error(title, text)
+    print_text(text, color: String::Colors::RED)
+  end
+
+  def print_warning(title, text)
+    print_text(text, color: String::Colors::YELLOW)
+    logger.debug(text)
+  end
+
+  def print_debug(title, text)
+    print_text(text, color: nil)
+    logger.debug(text)
+  end
+
+  def print_result(message, data = {})
+    print_debug("Result", "---------------------------")
+    print_debug("Result", message)
+    print_debug("Result", "---------------------------")
+  end
+
+  protected
+    def print_text(text, color: nil)
+      colorized_message = color ? text.colorize(color) : text
+      puts "  #{Time.now.strftime("%H:%M:%S").grey} #{colorized_message}"
+    end
+end

data/lib/kuber_kit/ui/interactive.rb

@@ -1,6 +1,10 @@
 require 'cli/ui'
 
 class KuberKit::UI::Interactive
+  include KuberKit::Import[
+    "tools.logger",
+  ]
+
   class TaskGroup < CLI::UI::SpinGroup
   end
 
@@ -24,6 +28,17 @@ class KuberKit::UI::Interactive
 
   def print_warning(title, text)
     print_in_frame(title, text, color: :yellow)
+    logger.debug(text)
+  end
+
+  def print_debug(title, text)
+    logger.debug(text)
+  end
+
+  def print_result(message, data = {})
+    print_debug("Result", "---------------------------")
+    print_debug("Result", message)
+    print_debug("Result", "---------------------------")
   end
 
   def prompt(text, options, &callback)

data/lib/kuber_kit/ui/simple.rb

@@ -1,19 +1,33 @@
 class KuberKit::UI::Simple
+  include KuberKit::Import[
+    "tools.logger",
+  ]
+
   class Task
     def initialize(title, &callback)
       @title = title
       @callback = callback
     end
 
+    def print_started
+      puts "- #{@title}"
+    end
+
+    def print_finished
+      puts "- #{@title.grey}"
+    end
+
     def execute
       if @thread
         raise "Already started execution of task '#{title}'"
       end
 
       @thread = Thread.new do
-        puts "Start task: #{@title.green}"
+        Thread.current.abort_on_exception = true
+        Thread.current.report_on_exception = false
+        print_started
         @callback.call(self)
-        puts "Finish task: #{@title.green}"
+        print_finished
       end
     end
 
@@ -30,8 +44,12 @@ class KuberKit::UI::Simple
   end
 
   class TaskGroup
+    def initialize(task_class)
+      @task_class = task_class
+    end
+
     def add(task_title, &task_block)
-      task = Task.new(task_title, &task_block)
+      task = @task_class.new(task_title, &task_block)
       task.execute
       add_task(task)
     end
@@ -47,7 +65,7 @@ class KuberKit::UI::Simple
   end
 
   def create_task_group
-    TaskGroup.new
+    TaskGroup.new(KuberKit::UI::Simple::Task)
   end
 
   def create_task(title, &block)
@@ -66,6 +84,17 @@ class KuberKit::UI::Simple
 
   def print_warning(title, text)
     print_text(title, text, color: String::Colors::YELLOW)
+    logger.debug(text)
+  end
+
+  def print_debug(title, text)
+    logger.debug(text)
+  end
+
+  def print_result(message, data = {})
+    print_debug("Result", "---------------------------")
+    print_debug("Result", message)
+    print_debug("Result", "---------------------------")
   end
 
   def prompt(text, options, &callback)
@@ -75,7 +104,7 @@ class KuberKit::UI::Simple
     result
   end
 
-  private
+  protected
     def print_text(title, text, color:)
       puts "#{title.colorize(color)}\r\n #{text.colorize(color)}"
     end

data/lib/kuber_kit/version.rb

@@ -1,3 +1,3 @@
 module KuberKit
-  VERSION = "0.3.7"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kuber_kit
 version: !ruby/object:Gem::Version
-  version: 0.3.7
+  version: 0.4.0
 platform: ruby
 authors:
 - Iskander Khaziev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-07 00:00:00.000000000 Z
+date: 2021-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: contracts-lite
@@ -145,6 +145,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/rspec.yml"
 - ".gitignore"
 - ".rspec"
 - ".ruby-gemset"
@@ -182,6 +183,7 @@ files:
 - example/infrastructure/registries.rb
 - example/infrastructure/templates.rb
 - example/services/compose_app.rb
+- example/services/docker_app.rb
 - example/services/env_file.rb
 - example/services/ruby_app.rb
 - kuber_kit.gemspec
@@ -286,6 +288,8 @@ files:
 - lib/kuber_kit/tools/file_presence_checker.rb
 - lib/kuber_kit/tools/logger_factory.rb
 - lib/kuber_kit/ui.rb
+- lib/kuber_kit/ui/api.rb
+- lib/kuber_kit/ui/debug.rb
 - lib/kuber_kit/ui/interactive.rb
 - lib/kuber_kit/ui/simple.rb
 - lib/kuber_kit/version.rb