kuber_kit 0.3.8 → 0.4.1

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

@@ -9,9 +9,11 @@ class KuberKit::ServiceDeployer::Strategies::Docker < KuberKit::ServiceDeployer:
     :container_name,
     :image_name,
     :detached,
-    :docker_run_args,
-    :docker_run_command,
-    :delete_if_exists
+    :command_name,
+    :custom_args,
+    :delete_if_exists,
+    :volumes,
+    :networks,
   ]
 
   Contract KuberKit::Shell::AbstractShell, KuberKit::Core::Service => Any
@@ -22,9 +24,11 @@ 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")
+    custom_args   = strategy_options.fetch(:custom_args, nil)
+    networks       = strategy_options.fetch(:networks, [])
+    volumes        = strategy_options.fetch(:volumes, [])
 
     image_name = strategy_options.fetch(:image_name, nil)
     if image_name.nil?
@@ -37,11 +41,24 @@ class KuberKit::ServiceDeployer::Strategies::Docker < KuberKit::ServiceDeployer:
       docker_commands.delete_container(shell, container_name)
     end
 
+    custom_args = Array(custom_args)
+    if container_name
+      custom_args << "--name #{container_name}"
+    end
+    networks.each do |network|
+      docker_commands.create_network(shell, network)
+      custom_args << "--network #{network}"
+    end
+    volumes.each do |volume|
+      docker_commands.create_volume(shell, volume)
+      custom_args << "--volume #{volume}"
+    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:       custom_args, 
+      detached:   !!strategy_options[:detached]
     )
   end
 end

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

@@ -8,6 +8,7 @@ class KuberKit::ServiceDeployer::Strategies::DockerCompose < KuberKit::ServiceDe
   STRATEGY_OPTIONS = [
     :service_name, 
     :command_name,
+    :custom_args,
     :detached
   ]
 
@@ -25,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")
+    custom_args = strategy_options.fetch(:custom_args, nil)
 
     docker_compose_commands.run(shell, config_path, 
       service:  service_name, 
       command:  command_name,
+      args:     custom_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,37 +14,82 @@ 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_containers(shell, container_name, status: status)
     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")
+  def get_containers(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(" "))
   end
+
+  def delete_container(shell, container_name)
+    shell.exec!("docker rm -f #{container_name}")
+  end
+
+  def create_network(shell, name)
+    unless network_exists?(shell, name)
+      shell.exec!("docker network create #{name}")
+    end
+  end
+
+  def network_exists?(shell, network_name)
+    result = get_networks(shell, network_name)
+    result && result != ""
+  end
+
+  def get_networks(shell, network_name)
+    command_parts = []
+    command_parts << "docker network ls"
+    command_parts << "--filter=\"name=#{network_name}\""
+    command_parts << "--format \"{{.Name}}\""
+
+    shell.exec!(command_parts.join(" "))
+  end
+
+  def create_volume(shell, name)
+    unless volume_exists?(shell, name)
+      shell.exec!("docker volume create #{name}")
+    end
+  end
+
+  def volume_exists?(shell, volume_name)
+    result = get_volumes(shell, volume_name)
+    result && result != ""
+  end
+
+  def get_volumes(shell, volume_name)
+    command_parts = []
+    command_parts << "docker volume ls"
+    command_parts << "--filter=\"name=#{volume_name}\""
+    command_parts << "--format \"{{.Name}}\""
+
+    shell.exec!(command_parts.join(" "))
+  end
 end

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",
       "-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")