kuber_kit 0.1.0

data/lib/kuber_kit/core/configuration_store.rb

@@ -0,0 +1,72 @@
+class KuberKit::Core::ConfigurationStore
+  NotFoundError = Class.new(KuberKit::NotFoundError)
+  AlreadyAddedError = Class.new(KuberKit::Error)
+
+  include KuberKit::Import[
+    "core.configuration_factory",
+    "core.configuration_definition_factory",
+    "shell.local_shell",
+    "tools.logger"
+  ]
+
+  def define(configuration_name)
+    definition = configuration_definition_factory.create(configuration_name)
+    add_definition(definition)
+    definition
+  end
+
+  def add_definition(configuration_definition)
+    @@configuration_definitions ||= {}
+
+    unless @@configuration_definitions[configuration_definition.configuration_name].nil?
+      raise AlreadyAddedError, "image #{configuration_definition.configuration_name} was already added"
+    end
+
+    @@configuration_definitions[configuration_definition.configuration_name] = configuration_definition
+  end
+
+  def get_definition(configuration_name)
+    @@configuration_definitions ||= {}
+
+    if @@configuration_definitions[configuration_name].nil?
+      raise NotFoundError, "configuration #{configuration_name} not found"
+    end
+
+    @@configuration_definitions[configuration_name]
+  end
+
+  def get_configuration(configuration_name)
+    definition = get_definition(configuration_name)
+
+    configuration_factory.create(definition)
+  end
+
+  def load_definitions(dir_path)
+    files = local_shell.recursive_list_files(dir_path).each do |path|
+      load_definition(path)
+    end
+  rescue KuberKit::Shell::AbstractShell::DirNotFoundError
+    logger.warn("Directory with configurations not found: #{dir_path}")
+    []
+  end
+
+  def load_definition(file_path)
+    require(file_path)
+  end
+
+  def reset!
+    @@configuration_definitions = {}
+  end
+
+  def all_definitions
+    @@configuration_definitions ||= {}
+  end
+
+  def count
+    all_definitions.count
+  end
+
+  def exists?(configuration_name)
+    !all_definitions[configuration_name].nil?
+  end
+end

data/lib/kuber_kit/core/context_helper/base_helper.rb

@@ -0,0 +1,28 @@
+class KuberKit::Core::ContextHelper::BaseHelper
+  attr_reader :shell, :artifact_store, :image_store
+
+  def initialize(image_store:, artifact_store:, shell:)
+    @image_store    = image_store
+    @artifact_store = artifact_store
+    @shell          = shell
+  end
+
+  def image_url(image_name)
+    image = @image_store.get_image(image_name)
+
+    image.remote_registry_url
+  end
+
+  def artifact_path(name, file_name = nil)
+    artifact = @artifact_store.get(name)
+    [artifact.cloned_path, file_name].compact.join("/")
+  end
+
+  def configuration_name
+    KuberKit.current_configuration.name
+  end
+
+  def get_binding
+    binding
+  end
+end

data/lib/kuber_kit/core/context_helper/context_helper_factory.rb

@@ -0,0 +1,23 @@
+class KuberKit::Core::ContextHelper::ContextHelperFactory
+  include KuberKit::Import[
+    "core.image_store",
+    "core.artifact_store"
+  ]
+
+  def build_image_context(shell)
+    KuberKit::Core::ContextHelper::ImageHelper.new(
+      image_store:    image_store,
+      artifact_store: artifact_store,
+      shell:          shell
+    )
+  end
+
+  def build_service_context(shell, service)
+    KuberKit::Core::ContextHelper::ServiceHelper.new(
+      image_store:    image_store,
+      artifact_store: artifact_store,
+      shell:          shell,
+      service:        service
+    )
+  end
+end

data/lib/kuber_kit/core/context_helper/image_helper.rb

@@ -0,0 +1,2 @@
+class KuberKit::Core::ContextHelper::ImageHelper < KuberKit::Core::ContextHelper::BaseHelper
+end

data/lib/kuber_kit/core/context_helper/service_helper.rb

@@ -0,0 +1,19 @@
+class KuberKit::Core::ContextHelper::ServiceHelper < KuberKit::Core::ContextHelper::BaseHelper
+  def initialize(image_store:, artifact_store:, shell:, service:)
+    super(
+      image_store:    image_store, 
+      artifact_store: artifact_store, 
+      shell:          shell
+    )
+    @service = service
+  end
+
+  def service_name
+    @service.name.to_s
+  end
+
+  def service_uri
+    service_name
+      .sub("_", "-")
+  end
+end

data/lib/kuber_kit/core/env_files/abstract_env_file.rb

@@ -0,0 +1,9 @@
+class KuberKit::Core::EnvFiles::AbstractEnvFile
+  include KuberKit::Extensions::Inspectable
+
+  attr_reader :name
+
+  def initialize(env_file_name)
+    @name = env_file_name
+  end
+end

data/lib/kuber_kit/core/env_files/artifact_file.rb

@@ -0,0 +1,9 @@
+class KuberKit::Core::EnvFiles::ArtifactFile < KuberKit::Core::EnvFiles::AbstractEnvFile
+  attr_reader :artifact_name, :file_path
+
+  def initialize(env_file_name, artifact_name:, file_path:)
+    super(env_file_name)
+    @artifact_name = artifact_name
+    @file_path = file_path
+  end
+end

data/lib/kuber_kit/core/env_files/env_file_store.rb

@@ -0,0 +1,45 @@
+class KuberKit::Core::EnvFiles::EnvFileStore
+  NotFoundError = Class.new(KuberKit::NotFoundError)
+  AlreadyAddedError = Class.new(KuberKit::Error)
+
+  def add(env_file)
+    @@env_files ||= {}
+
+    if !env_file.is_a?(KuberKit::Core::EnvFiles::AbstractEnvFile)
+      raise ArgumentError.new("should be an instance of KuberKit::Core::EnvFiles::AbstractEnvFile, got: #{env_file.inspect}")
+    end
+
+    unless @@env_files[env_file.name].nil?
+      raise AlreadyAddedError, "env_file #{env_file.name} was already added"
+    end
+
+    @@env_files[env_file.name] = env_file
+  end
+
+  def get(env_file_name)
+    env_file = get_from_configuration(env_file_name) || 
+               get_global(env_file_name)
+
+    env_file
+  end
+
+  def get_global(env_file_name)
+    @@env_files ||= {}
+    env_file = @@env_files[env_file_name]
+
+    if env_file.nil?
+      raise NotFoundError, "env_file '#{env_file_name}' not found"
+    end
+    
+    env_file
+  end
+
+  def get_from_configuration(env_file_name)
+    env_files = KuberKit.current_configuration.env_files
+    env_files[env_file_name]
+  end
+
+  def reset!
+    @@env_files = {}
+  end
+end

data/lib/kuber_kit/core/image.rb

@@ -0,0 +1,39 @@
+class KuberKit::Core::Image
+  attr_reader :name, :dependencies, :registry, :dockerfile_path, :build_vars, :build_context_dir, :tag, :before_build_callback, :after_build_callback
+
+  Contract KeywordArgs[
+    name:               Symbol,
+    dependencies:       ArrayOf[Symbol],
+    registry:           Maybe[KuberKit::Core::Registries::Registry],
+    dockerfile_path:    String,
+    build_vars:         Hash,
+    build_context_dir:  Maybe[String],
+    tag:                String,
+    before_build_callback: Maybe[Proc],
+    after_build_callback:  Maybe[Proc]
+  ] => Any
+  def initialize(name:, dependencies:, registry:, dockerfile_path:, build_vars:, build_context_dir:, tag:, before_build_callback:, after_build_callback:)
+    @name = name
+    @dependencies = dependencies
+    @registry = registry
+    @dockerfile_path = dockerfile_path
+    @build_vars = build_vars
+    @build_context_dir = build_context_dir
+    @tag = tag
+    @before_build_callback = before_build_callback
+    @after_build_callback = after_build_callback
+  end
+
+  def registry_url
+    "#{registry.path}/#{name}:#{tag}"
+  end
+
+  def remote_registry_url
+    "#{registry.remote_path}/#{name}:#{tag}"
+  end
+
+  def build_args
+    puts "WARNING: build_args is deprecated, please use build_vars instead"
+    build_vars
+  end
+end

data/lib/kuber_kit/core/image_definition.rb

@@ -0,0 +1,85 @@
+class KuberKit::Core::ImageDefinition
+  attr_reader :image_name, :path,
+              :dependencies, :registry_name, :dockerfile_path,
+              :build_vars, :build_context_dir, :tag, 
+              :before_build_callback, :after_build_callback
+  
+  Contract Or[Symbol, String], Maybe[String] => Any
+  def initialize(image_name, image_dir)
+    @image_name   = image_name.to_sym
+    @image_dir    = image_dir
+    @dependencies = []
+  end
+
+  def to_image_attrs
+    OpenStruct.new(
+      name:                   @image_name,
+      dir:                    @image_dir,
+      dependencies:           @dependencies,
+      registry_name:          get_value(@registry_name),
+      dockerfile_path:        get_value(@dockerfile_path),
+      build_vars:             get_value(@build_vars),
+      build_context_dir:      get_value(@build_context_dir),
+      tag:                    get_value(@tag),
+      before_build_callback:  @before_build_callback,
+      after_build_callback:   @after_build_callback
+    )
+  end
+
+  def depends_on(*value, &block)
+    @dependencies = Array(value).flatten
+    self
+  end
+
+  def registry(value = nil, &block)
+    @registry_name = block_given? ? block : value
+
+    self
+  end
+
+  def dockerfile(value = nil, &block)
+    @dockerfile_path = block_given? ? block : value
+
+    self
+  end
+
+  def build_args(value = nil, &block)
+    puts "WARNING: build_args is deprecated, please use build_vars instead"
+    build_vars(value, *block)
+  end
+
+  def build_vars(value = nil, &block)
+    @build_vars = block_given? ? block : value
+
+    self
+  end
+
+  def build_context(value = nil, &block)
+    @build_context_dir = block_given? ? block : value
+
+    self
+  end
+
+  def tag(value = nil, &block)
+    @tag = block_given? ? block : value
+
+    self
+  end
+
+  def before_build(&block)
+    @before_build_callback = block
+
+    self
+  end
+
+  def after_build(&block)
+    @after_build_callback = block
+
+    self
+  end
+
+  private
+    def get_value(variable)
+      variable.is_a?(Proc) ? variable.call : variable
+    end
+end

data/lib/kuber_kit/core/image_definition_factory.rb

@@ -0,0 +1,5 @@
+class KuberKit::Core::ImageDefinitionFactory
+  def create(image_name, image_dir)
+    KuberKit::Core::ImageDefinition.new(image_name, image_dir)
+  end
+end

data/lib/kuber_kit/core/image_factory.rb

@@ -0,0 +1,40 @@
+class KuberKit::Core::ImageFactory
+  include KuberKit::Import[
+    "configs",
+    "tools.file_presence_checker",
+    "core.registry_store"
+  ]
+
+  def create(definition)
+    image_attrs = definition.to_image_attrs
+
+    dockerfile_path = image_attrs.dockerfile_path || File.join(image_attrs.dir, configs.image_dockerfile_name)
+    file_presence_checker.check_file!(dockerfile_path)
+
+    if image_attrs.build_context_dir
+      file_presence_checker.check_dir!(image_attrs.build_context_dir)
+      build_context_dir = image_attrs.build_context_dir
+    else
+      default_dir = File.join(image_attrs.dir, configs.image_build_context_dir)
+      build_context_dir = file_presence_checker.dir_exists?(default_dir) ? default_dir : nil
+    end
+
+    if image_attrs.registry_name
+      registry = registry_store.get(image_attrs.registry_name)
+    else
+      registry = registry_store.default_registry
+    end
+
+    KuberKit::Core::Image.new(
+      name:                   image_attrs.name,
+      dependencies:           image_attrs.dependencies,
+      registry:               registry,
+      dockerfile_path:        dockerfile_path,
+      build_vars:             image_attrs.build_vars || {},
+      build_context_dir:      build_context_dir,
+      tag:                    image_attrs.tag || configs.image_tag,
+      before_build_callback:  image_attrs.before_build_callback,
+      after_build_callback:   image_attrs.after_build_callback
+    )
+  end
+end

data/lib/kuber_kit/core/image_store.rb

@@ -0,0 +1,60 @@
+class KuberKit::Core::ImageStore
+  NotFoundError = Class.new(KuberKit::Error)
+  AlreadyAddedError = Class.new(KuberKit::Error)
+
+  include KuberKit::Import[
+    "core.image_factory",
+    "core.image_definition_factory",
+    "shell.local_shell",
+    "tools.logger"
+  ]
+
+  def define(image_name, image_dir = nil)
+    definition = image_definition_factory.create(image_name, image_dir)
+    add_definition(definition)
+    definition
+  end
+
+  def add_definition(image_definition)
+    @@image_definitions ||= {}
+
+    unless @@image_definitions[image_definition.image_name].nil?
+      raise AlreadyAddedError, "image #{image_definition.image_name} was already added"
+    end
+
+    @@image_definitions[image_definition.image_name] = image_definition
+  end
+
+  def get_definition(image_name)
+    @@image_definitions ||= {}
+
+    if @@image_definitions[image_name].nil?
+      raise NotFoundError, "image #{image_name} not found"
+    end
+
+    @@image_definitions[image_name]
+  end
+
+  def get_image(image_name)
+    definition = get_definition(image_name)
+
+    image_factory.create(definition)
+  end
+
+  def load_definitions(dir_path)
+    files = local_shell.recursive_list_files(dir_path, name: "image.rb").each do |path|
+      load_definition(path)
+    end
+  rescue KuberKit::Shell::AbstractShell::DirNotFoundError
+    logger.warn("Directory with images not found: #{dir_path}")
+    []
+  end
+
+  def load_definition(file_path)
+    require(file_path)
+  end
+
+  def reset!
+    @@image_definitions = {}
+  end
+end