kuber_kit 0.5.1 → 0.5.6

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/image_compiler/image_dependency_resolver.rb

@@ -1,62 +1,14 @@
-class KuberKit::ImageCompiler::ImageDependencyResolver
-  CircularDependencyError = Class.new(KuberKit::Error)
-  DependencyNotFoundError = Class.new(KuberKit::NotFoundError)
-
+class KuberKit::ImageCompiler::ImageDependencyResolver < KuberKit::Core::Dependencies::AbstractDependencyResolver
   include KuberKit::Import[
     "core.image_store",
     "configs"
   ]
-
-  Contract Or[Symbol, ArrayOf[Symbol]], Proc => Any
-  def each_with_deps(image_names, &block)
-    compile_limit = configs.compile_simultaneous_limit
-
-    resolved_dependencies = []
-    next_dependencies = get_next(image_names, limit: compile_limit)
-
-    while (next_dependencies - resolved_dependencies).any?
-      block.call(next_dependencies)
-      resolved_dependencies += next_dependencies
-      next_dependencies = get_next(image_names, resolved: resolved_dependencies, limit: compile_limit)
-    end
-
-    (image_names - resolved_dependencies).each_slice(compile_limit) do |group|
-      block.call(group)
-    end
-  end
   
-  Contract Or[Symbol, ArrayOf[Symbol]], KeywordArgs[
-    resolved: Optional[ArrayOf[Symbol]],
-    limit:    Optional[Maybe[Num]]
-  ] => Any
-  def get_next(image_names, resolved: [], limit: nil)
-    deps = Array(image_names).map { |i| get_recursive_deps(i) }.flatten.uniq
-
-    ready_to_resolve = deps.select do |dep_name|
-      unresolved_deps = get_deps(dep_name) - resolved
-      unresolved_deps.empty?
-    end
-    unresolved_deps = ready_to_resolve - resolved
-    unresolved_deps = unresolved_deps.take(limit) if limit
-    unresolved_deps
-  end
-
-  def get_recursive_deps(image_name, dependency_tree: [])
-    deps = get_deps(image_name)
-
-    if dependency_tree.include?(image_name)
-      raise CircularDependencyError, "Circular dependency found for #{image_name}. Dependency tree: #{dependency_tree.inspect}"
-    end
-
-    child_deps = []
-    deps.each do |i| 
-      child_deps += get_recursive_deps(i, dependency_tree: dependency_tree + [image_name])
-    end
-
-    (deps + child_deps).uniq
-  end
-
   def get_deps(image_name)
     image_store.get_definition(image_name).dependencies
   end
+
+  def dependency_batch_size
+    configs.compile_simultaneous_limit
+  end
 end

data/lib/kuber_kit/service_deployer/service_dependency_resolver.rb

@@ -0,0 +1,14 @@
+class KuberKit::ServiceDeployer::ServiceDependencyResolver < KuberKit::Core::Dependencies::AbstractDependencyResolver
+  include KuberKit::Import[
+    "core.service_store",
+    "configs"
+  ]
+  
+  def get_deps(service_name)
+    service_store.get_definition(service_name).dependencies
+  end
+
+  def dependency_batch_size
+    configs.deploy_simultaneous_limit
+  end
+end

data/lib/kuber_kit/service_deployer/service_list_resolver.rb

@@ -4,11 +4,12 @@ class KuberKit::ServiceDeployer::ServiceListResolver
   ]
 
   Contract KeywordArgs[
-    services:         Optional[ArrayOf[String]],
-    tags:             Optional[ArrayOf[String]],
-    enabled_services: Optional[ArrayOf[String]]
+    services:           Optional[ArrayOf[String]],
+    tags:               Optional[ArrayOf[String]],
+    enabled_services:   Optional[ArrayOf[String]],
+    disabled_services:  Optional[ArrayOf[String]]
   ] => ArrayOf[String]
-  def resolve(services: [], tags: [], enabled_services: [])
+  def resolve(services: [], tags: [], enabled_services: [], disabled_services: [])
     all_definitions = service_store.all_definitions.values
 
     included_services, excluded_services = split_by_inclusion(services)
@@ -36,14 +37,18 @@ class KuberKit::ServiceDeployer::ServiceListResolver
       included_services = included_services.select{ |s| enabled_services.include?(s) }
     end
 
+    if disabled_services.any?
+      included_services = included_services.select{ |s| !disabled_services.include?(s) }
+    end
+
     included_services
   end
 
   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,7 @@ class KuberKit::ServiceDeployer::Strategies::Docker < KuberKit::ServiceDeployer:
     :networks,
     :expose,
     :publish,
+    :env_file_names
   ]
 
   Contract KuberKit::Shell::AbstractShell, KuberKit::Core::Service => Any
@@ -28,16 +31,19 @@ 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)
 
     image_name = strategy_options.fetch(:image_name, nil)
     if image_name.nil?
@@ -54,8 +60,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 +81,9 @@ 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
 
     docker_commands.run(
       shell, image.remote_registry_url, 
@@ -84,4 +93,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/service_deployer/strategies/kubernetes.rb

@@ -9,7 +9,8 @@ class KuberKit::ServiceDeployer::Strategies::Kubernetes < KuberKit::ServiceDeplo
     :resource_type,
     :resource_name,
     :delete_if_exists,
-    :restart_if_exists
+    :restart_if_exists,
+    :wait_for_rollout
   ]
 
   Contract KuberKit::Shell::AbstractShell, KuberKit::Core::Service => Any
@@ -41,12 +42,18 @@ class KuberKit::ServiceDeployer::Strategies::Kubernetes < KuberKit::ServiceDeplo
 
     apply_result = kubectl_commands.apply_file(shell, config_path, kubeconfig_path: kubeconfig_path, namespace: namespace)
 
-    restart_enabled = strategy_options.fetch(:restart_if_exists, true)
+    restart_enabled  = strategy_options.fetch(:restart_if_exists, true)
+    wait_for_rollout = strategy_options.fetch(:wait_for_rollout, true)
     if restart_enabled && resource_exists
       kubectl_commands.rolling_restart(
         shell, resource_type, resource_name, 
         kubeconfig_path: kubeconfig_path, namespace: namespace
       )
+      
+      kubectl_commands.rollout_status(
+        shell, resource_type, resource_name, wait: true,
+        kubeconfig_path: kubeconfig_path, namespace: namespace
+      ) if wait_for_rollout
     end
     
     apply_result

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

@@ -102,4 +102,12 @@ class KuberKit::Shell::Commands::KubectlCommands
       }
     }, kubeconfig_path: kubeconfig_path, namespace: namespace)
   end
+
+  def rollout_status(shell, resource_type, resource_name, wait: true, kubeconfig_path: nil, namespace: nil)
+    command_parts = []
+    command_parts << %Q{rollout status #{resource_type} #{resource_name}}
+    command_parts << "-w" if wait
+
+    kubectl_run(shell, command_parts, kubeconfig_path: kubeconfig_path, namespace: namespace)
+  end
 end

data/lib/kuber_kit/shell/local_shell.rb

@@ -1,6 +1,8 @@
 require 'fileutils'
 
 class KuberKit::Shell::LocalShell < KuberKit::Shell::AbstractShell
+  MAX_LINES_TO_PRINT = 50
+
   include KuberKit::Import[
     "shell.command_counter",
     "shell.rsync_commands",
@@ -20,7 +22,19 @@ class KuberKit::Shell::LocalShell < KuberKit::Shell::AbstractShell
     end
 
     if result && result != "" && log_command
-      ui.print_debug("LocalShell", "Finished [#{command_number}] with result: \n  ----\n#{result.grey}\n  ----")
+      print_result = result
+      print_result_lines = print_result.split("\n")
+
+      if print_result_lines.count >= MAX_LINES_TO_PRINT
+        print_result = [
+          "[Result is too long, showing only first and last items]".yellow, 
+          print_result_lines.first, 
+          "[#{print_result_lines.count - 2} lines not showing]".yellow, 
+          print_result_lines.last
+      ].join("\n")
+      end
+
+      ui.print_debug("LocalShell", "Finished [#{command_number}] with result: \n  ----\n#{print_result.grey}\n  ----")
     end
 
     if $?.exitstatus != 0

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