kuber_kit 0.1.0

data/lib/kuber_kit/container.rb

@@ -0,0 +1,207 @@
+class KuberKit::Container
+  extend Dry::Container::Mixin
+
+  register "actions.image_compiler" do
+    KuberKit::Actions::ImageCompiler.new
+  end
+
+  register "actions.env_file_reader" do
+    KuberKit::Actions::EnvFileReader.new
+  end
+
+  register "actions.template_reader" do
+    KuberKit::Actions::TemplateReader.new
+  end
+
+  register "actions.service_reader" do
+    KuberKit::Actions::ServiceReader.new
+  end
+
+  register "actions.service_applier" do
+    KuberKit::Actions::ServiceApplier.new
+  end
+
+  register "actions.configuration_loader" do
+    KuberKit::Actions::ConfigurationLoader.new
+  end
+
+  register "actions.kubectl_applier" do
+    KuberKit::Actions::KubectlApplier.new
+  end
+
+  register "configs" do
+    KuberKit::Configs.new
+  end
+
+  register "core.image_factory" do
+    KuberKit::Core::ImageFactory.new
+  end
+  
+  register "core.image_definition_factory" do
+    KuberKit::Core::ImageDefinitionFactory.new
+  end
+
+  register "core.image_store" do
+    KuberKit::Core::ImageStore.new
+  end
+
+  register "core.service_factory" do
+    KuberKit::Core::ServiceFactory.new
+  end
+  
+  register "core.service_definition_factory" do
+    KuberKit::Core::ServiceDefinitionFactory.new
+  end
+
+  register "core.service_store" do
+    KuberKit::Core::ServiceStore.new
+  end
+
+  register "core.configuration_definition_factory" do
+    KuberKit::Core::ConfigurationDefinitionFactory.new
+  end
+
+  register "core.configuration_factory" do
+    KuberKit::Core::ConfigurationFactory.new
+  end
+
+  register "core.configuration_store" do
+    KuberKit::Core::ConfigurationStore.new
+  end
+
+  register "core.registry_store" do
+    KuberKit::Core::Registries::RegistryStore.new
+  end
+
+  register "core.artifact_store" do
+    KuberKit::Core::Artifacts::ArtifactStore.new
+  end
+
+  register "core.env_file_store" do
+    KuberKit::Core::EnvFiles::EnvFileStore.new
+  end
+
+  register "core.template_store" do
+    KuberKit::Core::Templates::TemplateStore.new
+  end
+
+  register "core.context_helper_factory" do
+    KuberKit::Core::ContextHelper::ContextHelperFactory.new
+  end
+
+  register "tools.file_presence_checker" do
+    KuberKit::Tools::FilePresenceChecker.new
+  end
+
+  register "tools.logger_factory" do
+    KuberKit::Tools::LoggerFactory.new
+  end
+
+  register "tools.logger" do
+    KuberKit::Container["tools.logger_factory"].create("/tmp/kuber_kit.log")
+  end
+
+  register "shell.bash_commands" do
+    KuberKit::Shell::BashCommands.new
+  end
+
+  register "shell.docker_commands" do
+    KuberKit::Shell::DockerCommands.new
+  end
+
+  register "shell.git_commands" do
+    KuberKit::Shell::GitCommands.new
+  end
+
+  register "shell.rsync_commands" do
+    KuberKit::Shell::RsyncCommands.new
+  end
+
+  register "shell.kubectl_commands" do
+    KuberKit::Shell::KubectlCommands.new
+  end
+
+  register "shell.local_shell" do
+    KuberKit::Shell::LocalShell.new
+  end
+
+  register "shell.command_counter" do
+    KuberKit::Shell::CommandCounter.new
+  end
+
+  register "preprocessing.text_preprocessor" do
+    KuberKit::Preprocessing::TextPreprocessor.new
+  end
+
+  register "preprocessing.file_preprocessor" do
+    KuberKit::Preprocessing::FilePreprocessor.new
+  end
+
+  register "preprocessing.dir_preprocessor" do
+    KuberKit::Preprocessing::DirPreprocessor.new
+  end
+
+  register "image_compiler.compiler" do
+    KuberKit::ImageCompiler::Compiler.new
+  end
+
+  register "image_compiler.image_builder" do
+    KuberKit::ImageCompiler::ImageBuilder.new
+  end
+
+  register "image_compiler.image_build_dir_creator" do
+    KuberKit::ImageCompiler::ImageBuildDirCreator.new
+  end
+
+  register "image_compiler.image_dependency_resolver" do
+    KuberKit::ImageCompiler::ImageDependencyResolver.new
+  end
+
+  register "image_compiler.version_tag_builder" do
+    KuberKit::ImageCompiler::VersionTagBuilder.new
+  end
+
+  register "artifacts_sync.artifacts_updater" do
+    KuberKit::ArtifactsSync::ArtifactsUpdater.new
+  end
+
+  register "artifacts_sync.git_artifact_resolver" do
+    KuberKit::ArtifactsSync::GitArtifactResolver.new
+  end
+
+  register "artifacts_sync.null_artifact_resolver" do
+    KuberKit::ArtifactsSync::NullArtifactResolver.new
+  end
+
+  register "env_file_reader.reader" do
+    KuberKit::EnvFileReader::Reader.new
+  end
+
+  register "env_file_reader.artifact_file_reader" do
+    KuberKit::EnvFileReader::ArtifactFileReader.new
+  end
+
+  register "template_reader.reader" do
+    KuberKit::TemplateReader::Reader.new
+  end
+
+  register "template_reader.artifact_file_reader" do
+    KuberKit::TemplateReader::ArtifactFileReader.new
+  end
+
+  register "service_deployer.service_reader" do
+    KuberKit::ServiceDeployer::ServiceReader.new
+  end
+
+  register "service_deployer.service_list_resolver" do
+    KuberKit::ServiceDeployer::ServiceListResolver.new
+  end
+
+  register "ui" do
+    if KuberKit.debug_mode?
+      KuberKit::UI::Simple.new
+    else
+      KuberKit::UI::Interactive.new
+    end
+  end
+end

data/lib/kuber_kit/core/artifacts/abstract_artifact.rb

@@ -0,0 +1,13 @@
+class KuberKit::Core::Artifacts::AbstractArtifact
+  include KuberKit::Extensions::Inspectable
+
+  attr_reader :name
+
+  def initialize(artifact_name)
+    @name = artifact_name
+  end
+
+  def namespace
+    raise KuberKit::NotImplementedError, "must be implemented"
+  end
+end

data/lib/kuber_kit/core/artifacts/artifact_store.rb

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

data/lib/kuber_kit/core/artifacts/git.rb

@@ -0,0 +1,22 @@
+class KuberKit::Core::Artifacts::Git < KuberKit::Core::Artifacts::AbstractArtifact
+  attr_reader :remote_url, :remote_name, :email, :password, :branch, :ssh_key
+
+  DEFAULT_SSH_KEY = "id_rsa"
+  DEFAULT_REMOTE_NAME = "origin"
+  DEFAULT_BRANCH = "master"
+
+  def setup(remote_url:, remote_name: DEFAULT_REMOTE_NAME, branch: DEFAULT_BRANCH, clone_path: nil, ssh_key: DEFAULT_SSH_KEY)
+    @remote_name = remote_name
+    @remote_url = remote_url
+    @branch = branch
+    @clone_path = clone_path
+    @ssh_key = ssh_key
+    self
+  end
+
+  def cloned_path
+    # TODO: We should refactor to not call container here
+    configs = KuberKit::Container['configs']
+    "#{configs.artifact_clone_dir}/#{name}"
+  end
+end

data/lib/kuber_kit/core/artifacts/local.rb

@@ -0,0 +1,14 @@
+class KuberKit::Core::Artifacts::Local < KuberKit::Core::Artifacts::AbstractArtifact
+  def setup(root_path)
+    @root_path = File.expand_path(root_path)
+    self
+  end
+
+  def root_path
+    @root_path || (raise ArgumentError.new("root path was not set. Set it using setup method"))
+  end
+
+  def cloned_path
+    root_path
+  end
+end

data/lib/kuber_kit/core/configuration.rb

@@ -0,0 +1,20 @@
+class KuberKit::Core::Configuration
+  attr_reader :name, :artifacts, :registries, :env_files, :templates, :kubecfg_path
+
+  Contract KeywordArgs[
+    name:            Symbol,
+    artifacts:       Hash,
+    registries:      Hash,
+    env_files:       Hash,
+    templates:       Hash,
+    kubecfg_path:    Maybe[String]
+  ] => Any
+  def initialize(name:, artifacts:, registries:, env_files:, templates:, kubecfg_path:)
+    @name       = name
+    @artifacts  = artifacts
+    @registries = registries
+    @env_files  = env_files
+    @templates  = templates
+    @kubecfg_path = kubecfg_path
+  end
+end

data/lib/kuber_kit/core/configuration_definition.rb

@@ -0,0 +1,67 @@
+class KuberKit::Core::ConfigurationDefinition
+  ResourceAlreadyAdded = Class.new(KuberKit::Error)
+
+  attr_reader :configuration_name
+
+  Contract Or[Symbol, String] => Any
+  def initialize(configuration_name)
+    @configuration_name = configuration_name.to_sym
+    @artifacts  = {}
+    @registries = {}
+    @env_files  = {}
+    @templates  = {}
+  end
+
+  def to_attrs
+    OpenStruct.new(
+      name:          @configuration_name,
+      artifacts:     @artifacts,
+      registries:    @registries,
+      env_files:     @env_files,
+      templates:     @templates,
+      kubecfg_path:  @kubecfg_path
+    )
+  end
+
+  def use_artifact(artifact_name, as:)
+    if @artifacts.has_key?(as)
+      raise ResourceAlreadyAdded.new("alias name :#{as} is already used by artifact: #{@artifacts[as].inspect}")
+    end
+    @artifacts[as] = artifact_name
+
+    self
+  end
+
+  def use_registry(registry_name, as:)
+    if @registries.has_key?(as)
+      raise ResourceAlreadyAdded.new("alias name :#{as} is already used by registry: #{@registries[as].inspect}")
+    end
+    @registries[as] = registry_name
+
+    self
+  end
+
+  def use_env_file(env_file_name, as:)
+    if @env_files.has_key?(as)
+      raise ResourceAlreadyAdded.new("alias name :#{as} is already used by env_file: #{@env_files[as].inspect}")
+    end
+    @env_files[as] = env_file_name
+
+    self
+  end
+
+  def use_template(template_name, as:)
+    if @templates.has_key?(as)
+      raise ResourceAlreadyAdded.new("alias name :#{as} is already used by template: #{@templates[as].inspect}")
+    end
+    @templates[as] = template_name
+
+    self
+  end
+
+  def kubecfg_path(path)
+    @kubecfg_path = path
+
+    self
+  end
+end

data/lib/kuber_kit/core/configuration_definition_factory.rb

@@ -0,0 +1,5 @@
+class KuberKit::Core::ConfigurationDefinitionFactory
+  def create(configuration_name)
+    KuberKit::Core::ConfigurationDefinition.new(configuration_name)
+  end
+end

data/lib/kuber_kit/core/configuration_factory.rb

@@ -0,0 +1,61 @@
+class KuberKit::Core::ConfigurationFactory
+  NotFoundError = Class.new(KuberKit::NotFoundError)
+
+  include KuberKit::Import[
+    "core.registry_store",
+    "core.artifact_store",
+    "core.env_file_store",
+    "core.template_store"
+  ]
+
+  def create(definition)
+    configuration_attrs = definition.to_attrs
+
+    artifacts  = fetch_artifacts(configuration_attrs.artifacts)
+    registries = fetch_registries(configuration_attrs.registries)
+    env_files  = fetch_env_files(configuration_attrs.env_files)
+    templates  = fetch_templates(configuration_attrs.templates)
+
+    KuberKit::Core::Configuration.new(
+      name:           configuration_attrs.name,
+      artifacts:      artifacts,
+      registries:     registries,
+      env_files:      env_files,
+      templates:      templates,
+      kubecfg_path:   configuration_attrs.kubecfg_path
+    )
+  end
+
+  private
+    def fetch_registries(registries)
+      result = {}
+      registries.each do |registry_alias, registry_name|
+        result[registry_alias] = registry_store.get_global(registry_name)
+      end
+      result
+    end
+
+    def fetch_artifacts(artifacts)
+      result = {}
+      artifacts.each do |artifact_alias, artifact_name|
+        result[artifact_alias] = artifact_store.get_global(artifact_name)
+      end
+      result
+    end
+
+    def fetch_env_files(env_files)
+      result = {}
+      env_files.each do |env_file_alias, env_file_name|
+        result[env_file_alias] = env_file_store.get_global(env_file_name)
+      end
+      result
+    end
+
+    def fetch_templates(templates)
+      result = {}
+      templates.each do |template_alias, template_name|
+        result[template_alias] = template_store.get_global(template_name)
+      end
+      result
+    end
+end