kuber_kit 0.1.5 → 0.2.0

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

@@ -1,19 +1,6 @@
 class KuberKit::Core::Registries::RegistryStore
-  NotFoundError = Class.new(KuberKit::NotFoundError)
-  AlreadyAddedError = Class.new(KuberKit::Error)
-
   def add(registry)
-    @@registries ||= {}
-
-    if !registry.is_a?(KuberKit::Core::Registries::AbstractRegistry)
-      raise ArgumentError.new("should be an instance of KuberKit::Core::Registries::AbstractRegistry, got: #{registry.inspect}")
-    end
-
-    unless @@registries[registry.name].nil?
-      raise AlreadyAddedError, "registry #{registry.name} was already added"
-    end
-
-    @@registries[registry.name] = registry
+    store.add(registry.name, registry)
   end
 
   def get(registry_name)
@@ -24,14 +11,7 @@ class KuberKit::Core::Registries::RegistryStore
   end
 
   def get_global(registry_name)
-    @@registries ||= {}
-    registry = @@registries[registry_name]
-
-    if registry.nil?
-      raise NotFoundError, "registry '#{registry_name}' not found"
-    end
-    
-    registry
+    store.get(registry_name)
   end
 
   def get_from_configuration(registry_name)
@@ -44,6 +24,11 @@ class KuberKit::Core::Registries::RegistryStore
   end
 
   def reset!
-    @@registries = {}
+    store.reset!
   end
+
+  private
+    def store
+      @@store ||= KuberKit::Core::Store.new(KuberKit::Core::Registries::AbstractRegistry)
+    end
 end

data/lib/kuber_kit/core/service.rb

@@ -22,11 +22,15 @@ class KuberKit::Core::Service
     name.to_s.gsub("_", "-")
   end
 
-  def attribute(attribute_name)
-    unless attributes.has_key?(attribute_name.to_sym)
+  def attribute(attribute_name, default: nil)
+    if !attributes.has_key?(attribute_name.to_sym) && default.nil?
       raise AttributeNotSet, "attribute #{attribute_name} was not set"
     end
 
+    if !attributes.has_key?(attribute_name.to_sym) && !default.nil?
+      return default
+    end
+
     attributes[attribute_name.to_sym]
   end
 end

data/lib/kuber_kit/core/service_factory.rb

@@ -8,12 +8,15 @@ class KuberKit::Core::ServiceFactory
       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)
+
     KuberKit::Core::Service.new(
       name:           service_attrs.name,
       template_name:  service_attrs.template_name,
       tags:           service_attrs.tags,
       images:         service_attrs.images,
-      attributes:     service_attrs.attributes || {}
+      attributes:     attributes
     )
   end
 end

data/lib/kuber_kit/core/service_store.rb

@@ -1,7 +1,4 @@
 class KuberKit::Core::ServiceStore
-  NotFoundError = Class.new(KuberKit::Error)
-  AlreadyAddedError = Class.new(KuberKit::Error)
-
   include KuberKit::Import[
     "core.service_factory",
     "core.service_definition_factory",
@@ -16,24 +13,12 @@ class KuberKit::Core::ServiceStore
   end
 
   def add_definition(service_definition)
-    @@service_definitions ||= {}
-
-    unless @@service_definitions[service_definition.service_name].nil?
-      raise AlreadyAddedError, "service #{service_definition.service_name} was already added"
-    end
-
-    @@service_definitions[service_definition.service_name] = service_definition
+    definitions_store.add(service_definition.service_name, service_definition)
   end
 
   Contract Symbol => Any
   def get_definition(service_name)
-    @@service_definitions ||= {}
-
-    if @@service_definitions[service_name].nil?
-      raise NotFoundError, "service '#{service_name}' not found"
-    end
-
-    @@service_definitions[service_name]
+    definitions_store.get(service_name)
   end
 
   Contract Symbol => Any
@@ -57,18 +42,23 @@ class KuberKit::Core::ServiceStore
   end
 
   def reset!
-    @@service_definitions = {}
+    definitions_store.reset!
   end
 
-  def all_definitions
-    @@service_definitions ||= {}
+  def count
+    definitions_store.size
   end
 
-  def count
-    all_definitions.count
+  def all_definitions
+    definitions_store.items
   end
 
   def exists?(service_name)
-    !all_definitions[service_name].nil?
+    definitions_store.exists?(service_name)
   end
+
+  private
+    def definitions_store
+      @@definitions_store ||= KuberKit::Core::Store.new(KuberKit::Core::ServiceDefinition)
+    end
 end

data/lib/kuber_kit/core/store.rb

@@ -0,0 +1,48 @@
+class KuberKit::Core::Store
+  NotFoundError = Class.new(KuberKit::NotFoundError)
+  AlreadyAddedError = Class.new(KuberKit::Error)
+
+  attr_reader :object_class_name
+
+  def initialize(object_class_name)
+    @object_class_name = object_class_name
+  end
+
+  def add(item_name, item)
+    unless item.is_a?(object_class_name)
+      raise ArgumentError.new("#{self.object_class_name}: should be an instance of #{object_class_name}, got: #{item.inspect}")
+    end
+
+    unless items[item_name].nil?
+      raise AlreadyAddedError, "#{self.object_class_name}: item with name #{item_name} was already added"
+    end
+
+    items[item_name] = item
+  end
+
+  def get(item_name)
+    item = items[item_name]
+
+    if item.nil?
+      raise NotFoundError, "#{self.object_class_name}: item '#{item_name}' not found"
+    end
+
+    item
+  end
+
+  def items
+    @items ||= {}
+  end
+
+  def reset!
+    @items = {}
+  end
+
+  def size
+    items.count
+  end
+
+  def exists?(name)
+    !items[name].nil?
+  end
+end

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

@@ -1,19 +1,6 @@
 class KuberKit::Core::Templates::TemplateStore
-  NotFoundError = Class.new(KuberKit::NotFoundError)
-  AlreadyAddedError = Class.new(KuberKit::Error)
-
   def add(template)
-    @@templates ||= {}
-
-    if !template.is_a?(KuberKit::Core::Templates::AbstractTemplate)
-      raise ArgumentError.new("should be an instance of KuberKit::Core::Templates::AbstractTemplate, got: #{template.inspect}")
-    end
-
-    unless @@templates[template.name].nil?
-      raise AlreadyAddedError, "template #{template.name} was already added"
-    end
-
-    @@templates[template.name] = template
+    store.add(template.name, template)
   end
 
   def get(template_name)
@@ -24,14 +11,7 @@ class KuberKit::Core::Templates::TemplateStore
   end
 
   def get_global(template_name)
-    @@templates ||= {}
-    template = @@templates[template_name]
-
-    if template.nil?
-      raise NotFoundError, "template '#{template_name}' not found"
-    end
-    
-    template
+    store.get(template_name)
   end
 
   def get_from_configuration(template_name)
@@ -40,6 +20,15 @@ class KuberKit::Core::Templates::TemplateStore
   end
 
   def reset!
-    @@templates = {}
+    store.reset!
+  end
+
+  def exists?(template_name)
+    store.exists?(template_name)
   end
+
+  private
+    def store
+      @@store ||= KuberKit::Core::Store.new(KuberKit::Core::Templates::AbstractTemplate)
+    end
 end

data/lib/kuber_kit/env_file_reader/action_handler.rb

@@ -0,0 +1,12 @@
+class KuberKit::EnvFileReader::ActionHandler
+  include KuberKit::Import[
+    "env_file_reader.reader",
+    "core.env_file_store",
+  ]
+
+  Contract KuberKit::Shell::AbstractShell, Symbol => Any
+  def call(shell, env_file_name)
+    env_file = env_file_store.get(env_file_name)
+    reader.read(shell, env_file)
+  end
+end

data/lib/kuber_kit/env_file_reader/reader.rb

@@ -2,14 +2,14 @@ class KuberKit::EnvFileReader::Reader
   ReaderNotFoundError = Class.new(KuberKit::NotFoundError)
 
   include KuberKit::Import[
-    "env_file_reader.artifact_file_reader",
+    "env_file_reader.strategies.artifact_file",
   ]
 
   def use_reader(env_file_reader, env_file_class:)
     @@readers ||= {}
 
-    if !env_file_reader.is_a?(KuberKit::EnvFileReader::AbstractEnvFileReader)
-      raise ArgumentError.new("should be an instance of KuberKit::EnvFileReader::AbstractEnvFileReader, got: #{env_file_reader.inspect}")
+    if !env_file_reader.is_a?(KuberKit::EnvFileReader::Strategies::Abstract)
+      raise ArgumentError.new("should be an instance of KuberKit::EnvFileReader::Strategies::Abstract, got: #{env_file_reader.inspect}")
     end
 
     @@readers[env_file_class] = env_file_reader
@@ -26,7 +26,7 @@ class KuberKit::EnvFileReader::Reader
   end
 
   def add_default_readers
-    use_reader(artifact_file_reader, env_file_class: KuberKit::Core::EnvFiles::ArtifactFile)
+    use_reader(artifact_file, env_file_class: KuberKit::Core::EnvFiles::ArtifactFile)
   end
 
   def reset!

data/lib/kuber_kit/env_file_reader/{abstract_env_file_reader.rb → strategies/abstract.rb}

@@ -1,4 +1,4 @@
-class KuberKit::EnvFileReader::AbstractEnvFileReader
+class KuberKit::EnvFileReader::Strategies::Abstract
   def read(shell, env_file)
     raise KuberKit::NotImplementedError, "must be implemented"
   end

data/lib/kuber_kit/env_file_reader/{artifact_file_reader.rb → strategies/artifact_file.rb}

@@ -1,4 +1,4 @@
-class KuberKit::EnvFileReader::ArtifactFileReader < KuberKit::EnvFileReader::AbstractEnvFileReader
+class KuberKit::EnvFileReader::Strategies::ArtifactFile < KuberKit::EnvFileReader::Strategies::Abstract
   include KuberKit::Import[
     "core.artifact_store"
   ]

data/lib/kuber_kit/image_compiler/action_handler.rb

@@ -0,0 +1,21 @@
+class KuberKit::ImageCompiler::ActionHandler
+  include KuberKit::Import[
+    "image_compiler.compiler",
+    "core.image_store",
+    "configs",
+  ]
+
+  Contract KuberKit::Shell::AbstractShell, Symbol, String => Any
+  def call(shell, image_name, build_id)
+    image = image_store.get_image(image_name)
+    
+    compile_dir = generate_compile_dir(build_id: build_id)
+
+    compiler.compile(shell, image, compile_dir)
+  end
+
+  private
+    def generate_compile_dir(build_id:)
+      File.join(configs.image_compile_dir, build_id)
+    end
+end

data/lib/kuber_kit/image_compiler/build_server_pool.rb

@@ -0,0 +1,30 @@
+class KuberKit::ImageCompiler::BuildServerPool
+  attr_reader :ssh_shells, :local_shell
+  
+  def initialize(local_shell:, build_servers:, ssh_shell_class:)
+    @local_shell     = local_shell
+    @ssh_shell_class = ssh_shell_class
+    @ssh_shells      = connect_to_ssh_shells(build_servers)
+  end
+
+  def get_shell
+    if @ssh_shells.any?
+      @ssh_shells.sample
+    else
+      @local_shell
+    end
+  end
+
+  def disconnect_all
+    @ssh_shells.each(&:disconnect)
+  end
+
+  private
+    def connect_to_ssh_shells(build_servers)
+      build_servers.map do |bs|
+        shell = @ssh_shell_class.new
+        shell.connect(host: bs.host, user: bs.user, port: bs.port)
+        shell
+      end
+    end
+end

data/lib/kuber_kit/image_compiler/build_server_pool_factory.rb

@@ -0,0 +1,13 @@
+class KuberKit::ImageCompiler::BuildServerPoolFactory
+  include KuberKit::Import[
+    "shell.local_shell",
+  ]
+
+  def create(ssh_shell_class: KuberKit::Shell::SshShell)
+    KuberKit::ImageCompiler::BuildServerPool.new(
+      local_shell:      local_shell,
+      build_servers:    KuberKit.current_configuration.build_servers,
+      ssh_shell_class:  ssh_shell_class,
+    )
+  end
+end

data/lib/kuber_kit/image_compiler/compiler.rb

@@ -3,13 +3,10 @@ class KuberKit::ImageCompiler::Compiler
     "image_compiler.image_build_dir_creator",
     "image_compiler.image_builder",
     "core.context_helper_factory",
-    "core.image_store"
   ]
 
-  Contract KuberKit::Shell::AbstractShell, Symbol, String => Any
-  def compile(shell, image_name, builds_dir)
-    image = image_store.get_image(image_name)
-
+  Contract KuberKit::Shell::AbstractShell, KuberKit::Core::Image, String => Any
+  def compile(shell, image, builds_dir)
     image_build_dir = File.join(builds_dir, image.name.to_s)
 
     context_helper = context_helper_factory.build_image_context(shell)

data/lib/kuber_kit/image_compiler/image_build_dir_creator.rb

@@ -1,8 +1,8 @@
 class KuberKit::ImageCompiler::ImageBuildDirCreator
   include KuberKit::Import[
-    "preprocessing.dir_preprocessor",
     "preprocessing.file_preprocessor",
     "shell.bash_commands",
+    "shell.local_shell",
     "configs"
   ]
 
@@ -14,16 +14,22 @@ class KuberKit::ImageCompiler::ImageBuildDirCreator
     bash_commands.mkdir_p(shell, build_dir)
 
     if image.build_context_dir
-      dir_preprocessor.compile(
-        shell, image.build_context_dir, build_dir,
-        context_helper: context_helper
-      )
+      # Sync build context and then preprocess
+      shell.sync(image.build_context_dir, build_dir)
+
+      shell.recursive_list_files(build_dir).each do |file_path|
+        file_preprocessor.compile(
+          shell, file_path, 
+          context_helper: context_helper
+        )
+      end
     end
 
+    # Sync dockerfile and then preprocess
     target_dockerfile = File.join(build_dir, configs.image_dockerfile_name)
+    shell.sync(image.dockerfile_path, target_dockerfile)
     file_preprocessor.compile(
-      shell, image.dockerfile_path, 
-      destination_path: target_dockerfile, 
+      shell, target_dockerfile,
       context_helper: context_helper
     )
 

data/lib/kuber_kit/image_compiler/image_dependency_resolver.rb

@@ -3,20 +3,40 @@ class KuberKit::ImageCompiler::ImageDependencyResolver
   DependencyNotFoundError = Class.new(KuberKit::NotFoundError)
 
   include KuberKit::Import[
-    "core.image_store"
+    "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
+
+    block.call(image_names - resolved_dependencies)
+  end
   
-  Contract Any, KeywordArgs[
-    resolved: Optional[ArrayOf[Symbol]]
+  Contract Or[Symbol, ArrayOf[Symbol]], KeywordArgs[
+    resolved: Optional[ArrayOf[Symbol]],
+    limit:    Optional[Maybe[Num]]
   ] => Any
-  def get_next(image_names, resolved: [])
+  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
-    ready_to_resolve - resolved
+    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: [])