kuber_kit 0.1.0

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

@@ -0,0 +1,25 @@
+class KuberKit::Core::Registries::AbstractRegistry
+  include KuberKit::Extensions::Inspectable
+
+  attr_reader :name
+
+  def initialize(registry_name)
+    @name = registry_name
+  end
+
+  def path
+    raise KuberKit::NotImplementedError, "must be implemented"
+  end
+
+  def remote_path
+    raise KuberKit::NotImplementedError, "must be implemented"
+  end
+
+  def remote?
+    raise KuberKit::NotImplementedError, "must be implemented"
+  end
+
+  def local?
+    raise KuberKit::NotImplementedError, "must be implemented"
+  end
+end

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

@@ -0,0 +1,24 @@
+class KuberKit::Core::Registries::Registry < KuberKit::Core::Registries::AbstractRegistry
+  def set_remote_url(remote_url)
+    @remote_url = remote_url
+    
+    self
+  end
+  alias_method :setup, :set_remote_url
+
+  def path
+    name.to_s
+  end
+
+  def remote_path
+    [@remote_url, path].compact.join("/")
+  end
+
+  def remote?
+    !local?
+  end
+
+  def local?
+    @remote_url.nil?
+  end
+end

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

@@ -0,0 +1,49 @@
+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
+  end
+
+  def get(registry_name)
+    registry = get_from_configuration(registry_name) || 
+               get_global(registry_name)
+
+    registry
+  end
+
+  def get_global(registry_name)
+    @@registries ||= {}
+    registry = @@registries[registry_name]
+
+    if registry.nil?
+      raise NotFoundError, "registry '#{registry_name}' not found"
+    end
+    
+    registry
+  end
+
+  def get_from_configuration(registry_name)
+    registries = KuberKit.current_configuration.registries
+    registries[registry_name]
+  end
+
+  def default_registry
+    @default_registry ||= KuberKit::Core::Registries::Registry.new(:default)
+  end
+
+  def reset!
+    @@registries = {}
+  end
+end

data/lib/kuber_kit/core/service.rb

@@ -0,0 +1,14 @@
+class KuberKit::Core::Service
+  attr_reader :name, :template_name, :tags
+
+  Contract KeywordArgs[
+    name:           Symbol,
+    template_name:  Symbol,
+    tags:           ArrayOf[Symbol],
+  ] => Any
+  def initialize(name:, template_name:, tags:)
+    @name = name
+    @template_name = template_name
+    @tags = tags
+  end
+end

data/lib/kuber_kit/core/service_definition.rb

@@ -0,0 +1,33 @@
+class KuberKit::Core::ServiceDefinition
+  attr_reader :service_name, :template_name
+  
+  Contract Or[Symbol, String] => Any
+  def initialize(service_name)
+    @service_name = service_name.to_sym
+  end
+
+  def to_service_attrs
+    OpenStruct.new(
+      name:           @service_name,
+      template_name:  get_value(@template_name),
+      tags:           Array(get_value(@tags)).map(&:to_sym)
+    )
+  end
+
+  def template(value = nil, &block)
+    @template_name = block_given? ? block : value
+
+    self
+  end
+
+  def tags(*value, &block)
+    @tags = block_given? ? block : Array(value).flatten
+
+    self
+  end
+
+  private
+    def get_value(variable)
+      variable.is_a?(Proc) ? variable.call : variable
+    end
+end

data/lib/kuber_kit/core/service_definition_factory.rb

@@ -0,0 +1,5 @@
+class KuberKit::Core::ServiceDefinitionFactory
+  def create(service_name)
+    KuberKit::Core::ServiceDefinition.new(service_name)
+  end
+end

data/lib/kuber_kit/core/service_factory.rb

@@ -0,0 +1,17 @@
+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
+
+    KuberKit::Core::Service.new(
+      name:           service_attrs.name,
+      template_name:  service_attrs.template_name,
+      tags:           service_attrs.tags
+    )
+  end
+end

data/lib/kuber_kit/core/service_store.rb

@@ -0,0 +1,68 @@
+class KuberKit::Core::ServiceStore
+  NotFoundError = Class.new(KuberKit::Error)
+  AlreadyAddedError = Class.new(KuberKit::Error)
+
+  include KuberKit::Import[
+    "core.service_factory",
+    "core.service_definition_factory",
+    "shell.local_shell"
+  ]
+
+  def define(service_name)
+    definition = service_definition_factory.create(service_name)
+    add_definition(definition)
+    definition
+  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
+  end
+
+  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]
+  end
+
+  def get_service(service_name)
+    definition = get_definition(service_name)
+
+    service_factory.create(definition)
+  end
+
+  def load_definitions(dir_path)
+    files = local_shell.recursive_list_files(dir_path, name: "*.rb").each do |path|
+      load_definition(path)
+    end
+  end
+
+  def load_definition(file_path)
+    require(file_path)
+  end
+
+  def reset!
+    @@service_definitions = {}
+  end
+
+  def all_definitions
+    @@service_definitions ||= {}
+  end
+
+  def count
+    all_definitions.count
+  end
+
+  def exists?(service_name)
+    !all_definitions[service_name].nil?
+  end
+end

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

@@ -0,0 +1,9 @@
+class KuberKit::Core::Templates::AbstractTemplate
+  include KuberKit::Extensions::Inspectable
+
+  attr_reader :name
+
+  def initialize(template_name)
+    @name = template_name
+  end
+end

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

@@ -0,0 +1,9 @@
+class KuberKit::Core::Templates::ArtifactFile < KuberKit::Core::Templates::AbstractTemplate
+  attr_reader :artifact_name, :file_path
+
+  def initialize(template_name, artifact_name:, file_path:)
+    super(template_name)
+    @artifact_name = artifact_name
+    @file_path = file_path
+  end
+end

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

@@ -0,0 +1,45 @@
+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
+  end
+
+  def get(template_name)
+    template = get_from_configuration(template_name) || 
+               get_global(template_name)
+
+    template
+  end
+
+  def get_global(template_name)
+    @@templates ||= {}
+    template = @@templates[template_name]
+
+    if template.nil?
+      raise NotFoundError, "template '#{template_name}' not found"
+    end
+    
+    template
+  end
+
+  def get_from_configuration(template_name)
+    templates = KuberKit.current_configuration.templates
+    templates[template_name]
+  end
+
+  def reset!
+    @@templates = {}
+  end
+end

data/lib/kuber_kit/env_file_reader/abstract_env_file_reader.rb

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

data/lib/kuber_kit/env_file_reader/artifact_file_reader.rb

@@ -0,0 +1,86 @@
+class KuberKit::EnvFileReader::ArtifactFileReader < KuberKit::EnvFileReader::AbstractEnvFileReader
+  include KuberKit::Import[
+    "core.artifact_store"
+  ]
+
+  def read(shell, env_file)
+    artifact = artifact_store.get(env_file.artifact_name)
+
+    file_parts = [artifact.cloned_path, env_file.file_path].compact
+    file_path  = File.join(*file_parts)
+
+    read_file(shell, file_path)
+  end
+
+  private
+    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
+      end
+    end
+
+    def initialize(string, is_load = false)
+      @string = string
+      @hash = {}
+      @is_load = is_load
+    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/reader.rb

@@ -0,0 +1,35 @@
+class KuberKit::EnvFileReader::Reader
+  ReaderNotFoundError = Class.new(KuberKit::NotFoundError)
+
+  include KuberKit::Import[
+    "env_file_reader.artifact_file_reader",
+  ]
+
+  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}")
+    end
+
+    @@readers[env_file_class] = env_file_reader
+  end
+
+  def read(shell, env_file)
+    add_default_readers
+
+    reader = @@readers[env_file.class]
+
+    raise ReaderNotFoundError, "Can't find reader for env file #{env_file}" if reader.nil?
+
+    reader.read(shell, env_file)
+  end
+
+  def add_default_readers
+    use_reader(artifact_file_reader, env_file_class: KuberKit::Core::EnvFiles::ArtifactFile)
+  end
+
+  def reset!
+    @@readers = {}
+  end
+end

data/lib/kuber_kit/extensions/colored_string.rb

@@ -0,0 +1,43 @@
+class String
+  module Colors
+    RED    = 31
+    GREEN  = 32
+    YELLOW = 33
+    BLUE   = 34
+    PURPLE = 35
+    CYAN   = 36
+    GREY   = 37
+  end
+
+  def red
+    colorize(Colors::RED)
+  end
+
+  def green
+    colorize(Colors::GREEN)
+  end
+
+  def yellow
+    colorize(Colors::YELLOW)
+  end
+
+  def blue
+    colorize(Colors::BLUE)
+  end
+
+  def purple
+    colorize(Colors::PURPLE)
+  end
+
+  def cyan
+    colorize(Colors::CYAN)
+  end
+
+  def grey
+    colorize(Colors::GREY)
+  end
+
+  def colorize(color_code)
+    "\e[#{color_code}m#{self}\e[0m"
+  end
+end