kuber_kit 0.5.1 → 0.5.6

data/lib/kuber_kit/configs.rb

@@ -4,8 +4,8 @@ class KuberKit::Configs
   AVAILABLE_CONFIGS = [
     :image_dockerfile_name, :image_build_context_dir, :image_tag, :docker_ignore_list, :image_compile_dir, 
     :kuber_kit_dirname, :kuber_kit_min_version, :images_dirname, :services_dirname, :infra_dirname, :configurations_dirname,
-    :artifact_clone_dir, :service_config_dir, :deployer_strategy, :compile_simultaneous_limit,
-    :additional_images_paths, :deprecation_warnings_disabled, :log_file_path
+    :artifact_clone_dir, :service_config_dir, :deployer_strategy, :compile_simultaneous_limit, :deploy_simultaneous_limit,
+    :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,13 +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

@@ -45,6 +45,10 @@ class KuberKit::Container
     KuberKit::Actions::KubectlDescribe.new
   end
 
+  register "actions.kubectl_get" do
+    KuberKit::Actions::KubectlGet.new
+  end
+
   register "actions.kubectl_logs" do
     KuberKit::Actions::KubectlLogs.new
   end
@@ -225,10 +229,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
@@ -257,6 +273,10 @@ class KuberKit::Container
     KuberKit::ServiceDeployer::ServiceListResolver.new
   end
 
+  register "service_deployer.service_dependency_resolver" do
+    KuberKit::ServiceDeployer::ServiceDependencyResolver.new
+  end
+
   register "service_deployer.strategies.kubernetes" do
     KuberKit::ServiceDeployer::Strategies::Kubernetes.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/configuration.rb

@@ -1,6 +1,6 @@
 class KuberKit::Core::Configuration
   attr_reader :name, :artifacts, :registries, :env_files, :templates, :kubeconfig_path, 
-              :services_attributes, :enabled_services, :build_servers, :global_build_vars,
+              :services_attributes, :enabled_services, :disabled_services, :build_servers, :global_build_vars,
               :deployer_strategy, :deployer_namespace, :deployer_require_confirimation
 
   Contract KeywordArgs[
@@ -12,6 +12,7 @@ class KuberKit::Core::Configuration
     kubeconfig_path:      Maybe[String],
     services_attributes:  HashOf[Symbol => Hash],
     enabled_services:     ArrayOf[Symbol],
+    disabled_services:    ArrayOf[Symbol],
     build_servers:        ArrayOf[KuberKit::Core::BuildServers::AbstractBuildServer],
     global_build_vars:    HashOf[Symbol => Any],
     deployer_strategy:              Symbol,
@@ -19,7 +20,7 @@ class KuberKit::Core::Configuration
     deployer_require_confirimation: Bool,
   ] => Any
   def initialize(name:, artifacts:, registries:, env_files:, templates:, kubeconfig_path:, 
-                 services_attributes:, enabled_services:, build_servers:, global_build_vars:,
+                 services_attributes:, enabled_services:, disabled_services:, build_servers:, global_build_vars:,
                  deployer_strategy:, deployer_namespace:, deployer_require_confirimation:)
     @name                 = name
     @artifacts            = artifacts
@@ -30,6 +31,7 @@ class KuberKit::Core::Configuration
     @build_servers        = build_servers
     @services_attributes  = services_attributes
     @enabled_services     = enabled_services
+    @disabled_services    = disabled_services
     @global_build_vars    = global_build_vars
     @deployer_strategy              = deployer_strategy
     @deployer_namespace             = deployer_namespace

data/lib/kuber_kit/core/configuration_definition.rb

@@ -12,6 +12,7 @@ class KuberKit::Core::ConfigurationDefinition
     @templates  = {}
     @build_servers      = []
     @enabled_services   = []
+    @disabled_services  = []
     @services_attributes = {}
   end
 
@@ -24,6 +25,7 @@ class KuberKit::Core::ConfigurationDefinition
       templates:            @templates,
       kubeconfig_path:      @kubeconfig_path,
       enabled_services:     @enabled_services,
+      disabled_services:    @disabled_services,
       build_servers:        @build_servers,
       services_attributes:  @services_attributes,
       global_build_vars:    @global_build_vars,
@@ -116,6 +118,11 @@ class KuberKit::Core::ConfigurationDefinition
     raise KuberKit::Error, "#enabled_services method accepts only Array or Hash"
   end
 
+  def disabled_services(services)
+    @disabled_services += services.map(&:to_sym)
+    return self
+  end
+
   def service_attributes(services)
     @services_attributes = @services_attributes.merge(services)
     self

data/lib/kuber_kit/core/configuration_factory.rb

@@ -29,6 +29,7 @@ class KuberKit::Core::ConfigurationFactory
       build_servers:        build_servers,
       services_attributes:  configuration_attrs.services_attributes,
       enabled_services:     configuration_attrs.enabled_services,
+      disabled_services:    configuration_attrs.disabled_services,
       global_build_vars:    configuration_attrs.global_build_vars || {},
       deployer_strategy:              configuration_attrs.deployer_strategy || configs.deployer_strategy,
       deployer_namespace:             configuration_attrs.deployer_namespace,

data/lib/kuber_kit/core/dependencies/abstract_dependency_resolver.rb

@@ -0,0 +1,75 @@
+class KuberKit::Core::Dependencies::AbstractDependencyResolver
+  CircularDependencyError = Class.new(KuberKit::Error)
+  DependencyNotFoundError = Class.new(KuberKit::NotFoundError)
+
+  # Iterate over list of dependencies for items (including the items themself).
+  # Iteration will send the list to the callback block function
+  Contract Or[Symbol, ArrayOf[Symbol]], Proc => Any
+  def each_with_deps(item_names, &block)
+    resolved_dependencies = []
+    # Get first list of dependencies ready to resolve
+    next_dependencies = get_next(item_names, limit: dependency_batch_size)
+
+    # Call the block for each list of dependencies ready to resolve, then calculate the next list
+    while (next_dependencies - resolved_dependencies).any?
+      block.call(next_dependencies)
+      resolved_dependencies += next_dependencies
+      next_dependencies = get_next(item_names, resolved: resolved_dependencies, limit: dependency_batch_size)
+    end
+
+    (item_names - resolved_dependencies).each_slice(dependency_batch_size) do |group|
+      block.call(group)
+    end
+  end
+  
+  # Returns next list of dependencies ready to resolve.
+  # Item is not ready to resolve if it has personal dependency.
+  # E.g. if "A" depends on "B" and "C", "C" depends on "D", then only "B" and "D" will be returned. 
+  Contract Or[Symbol, ArrayOf[Symbol]], KeywordArgs[
+    resolved: Optional[ArrayOf[Symbol]],
+    limit:    Optional[Maybe[Num]]
+  ] => Any
+  def get_next(item_names, resolved: [], limit: nil)
+    deps = Array(item_names).map { |i| get_recursive_deps(i) }.flatten.uniq
+
+    # Find out which dependencies are ready to resolve, 
+    # they should not have unresolved personal dependencies
+    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
+
+  # Get all dependencies for items (including the items themself), without any limitations
+  Contract Or[Symbol, ArrayOf[Symbol]] => Any
+  def get_all(item_names)
+    deps = Array(item_names).map { |i| get_recursive_deps(i) }.flatten
+    (deps + item_names).uniq
+  end
+
+  def get_recursive_deps(item_name, dependency_tree: [])
+    deps = get_deps(item_name)
+
+    if dependency_tree.include?(item_name)
+      raise CircularDependencyError, "Circular dependency found for #{item_name}. Dependency tree: #{dependency_tree.inspect}"
+    end
+
+    child_deps = []
+    deps.each do |i| 
+      child_deps += get_recursive_deps(i, dependency_tree: dependency_tree + [item_name])
+    end
+
+    (deps + child_deps).uniq
+  end
+
+  def get_deps(item_name)
+    raise "This method should be overriden"
+  end
+
+  def dependency_batch_size
+    raise "This method should be overriden"
+  end
+end

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/image.rb

@@ -1,5 +1,6 @@
 class KuberKit::Core::Image
-  attr_reader :name, :dependencies, :registry, :dockerfile_path, :build_vars, :build_context_dir, :tag, :before_build_callback, :after_build_callback
+  attr_reader :name, :dependencies, :registry, :dockerfile_path, :build_vars, :build_context_dir, :tag, 
+              :before_build_callback, :after_build_callback
 
   Contract KeywordArgs[
     name:               Symbol,

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/service.rb

@@ -1,18 +1,20 @@
 class KuberKit::Core::Service
   AttributeNotSet = Class.new(Indocker::Error)
 
-  attr_reader :name, :template_name, :tags, :images, :attributes, :deployer_strategy
+  attr_reader :name, :dependencies, :template_name, :tags, :images, :attributes, :deployer_strategy
 
   Contract KeywordArgs[
     name:               Symbol,
+    dependencies:       ArrayOf[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:)
+  def initialize(name:, dependencies:, template_name:, tags:, images:, attributes:, deployer_strategy:)
     @name = name
+    @dependencies = dependencies
     @template_name = template_name
     @tags = tags
     @images = images

data/lib/kuber_kit/core/service_definition.rb

@@ -1,22 +1,29 @@
 class KuberKit::Core::ServiceDefinition
-  attr_reader :service_name, :template_name
+  attr_reader :service_name, :template_name, :dependencies
   
   Contract Or[Symbol, String] => Any
   def initialize(service_name)
     @service_name = service_name.to_sym
+    @dependencies = []
   end
 
   def to_service_attrs
     OpenStruct.new(
-      name:             @service_name,
-      template_name:    get_value(@template_name),
-      tags:             Array(get_value(@tags)).map(&:to_sym),
-      images:           Array(get_value(@images)).map(&:to_sym),
-      attributes:       get_value(@attributes),
+      name:               @service_name,
+      dependencies:       @dependencies,
+      template_name:      get_value(@template_name),
+      tags:               Array(get_value(@tags)).map(&:to_sym),
+      images:             Array(get_value(@images)).map(&:to_sym),
+      attributes:         get_value(@attributes),
       deployer_strategy:  get_value(@deployer_strategy),
     )
   end
 
+  def depends_on(*value, &block)
+    @dependencies = Array(value).flatten
+    self
+  end
+
   def template(value = nil, &block)
     @template_name = block_given? ? block : value
 

data/lib/kuber_kit/core/service_factory.rb

@@ -7,6 +7,7 @@ class KuberKit::Core::ServiceFactory
 
     KuberKit::Core::Service.new(
       name:               service_attrs.name,
+      dependencies:       service_attrs.dependencies,
       template_name:      service_attrs.template_name,
       tags:               service_attrs.tags,
       images:             service_attrs.images,

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