kuber_kit 0.1.0

data/lib/kuber_kit/actions/configuration_loader.rb

@@ -0,0 +1,74 @@
+class KuberKit::Actions::ConfigurationLoader
+  include KuberKit::Import[
+    "core.registry_store",
+    "core.image_store",
+    "core.configuration_store",
+    "artifacts_sync.artifacts_updater",
+    "tools.logger",
+    "shell.local_shell",
+    "ui",
+    "configs"
+  ]
+
+  Contract Hash => Any
+  def call(options)
+    root_path   = options[:path] || File.join(Dir.pwd, configs.kuber_kit_dirname)
+    images_path = options[:images_path] || File.join(root_path, configs.images_dirname)
+    infra_path  = options[:infra_path]  || File.join(root_path, configs.infra_dirname)
+    configurations_path  = options[:configurations_path]  || File.join(root_path, configs.configurations_dirname)
+    configuration_name   = options[:configuration]
+
+    logger.info "Launching kuber_kit with:"
+    logger.info "  Root path: #{root_path.to_s.yellow}"
+    logger.info "  Images path: #{images_path.to_s.yellow}"
+    logger.info "  Infrastructure path: #{infra_path.to_s.yellow}"
+    logger.info "  Configurations path: #{configurations_path.to_s.yellow}"
+    logger.info "  Configuration name: #{configuration_name.to_s.yellow}"
+
+    unless File.exists?(root_path)
+      ui.print_warning "WARNING", "KuberKit root path #{root_path} doesn't exist. You may want to pass it --path parameter."
+    end
+
+    load_configurations(configurations_path, configuration_name)
+    load_infrastructure(infra_path)
+
+    ui.create_task("Updating artifacts") do |task|
+      artifacts = KuberKit.current_configuration.artifacts.values
+      artifacts_updater.update(local_shell, artifacts)
+      task.update_title("Updated #{artifacts.count} artifacts")
+    end
+
+    ui.create_task("Loading image definitions") do |task|
+      files = image_store.load_definitions(images_path)
+      task.update_title("Loaded #{files.count} image definitions")
+    end
+  end
+  
+  def load_configurations(configurations_path, configuration_name)
+    configuration_store.load_definitions(configurations_path)
+
+    if configuration_store.count.zero?
+      configuration_store.define(:_default_)
+      configuration_name ||= :_default_
+    end
+
+    if configuration_store.count == 1 && configuration_name.nil?
+      first_configurations = configuration_store.all_definitions.values.first
+      configuration_name   = first_configurations.configuration_name
+    end
+
+    if configuration_store.count > 1 && configuration_name.nil?
+      raise KuberKit::Error, "Please set configuration name using -C option"
+    end
+
+    KuberKit.set_configuration_name(configuration_name)
+  end
+
+  def load_infrastructure(infra_path)
+    local_shell.recursive_list_files(infra_path).each do |path|
+      require(path)
+    end
+  rescue KuberKit::Shell::AbstractShell::DirNotFoundError
+    logger.warn("Directory with infrastructure not found: #{infra_path}")
+  end
+end

data/lib/kuber_kit/actions/env_file_reader.rb

@@ -0,0 +1,17 @@
+require 'json'
+
+class KuberKit::Actions::EnvFileReader
+  include KuberKit::Import[
+    "core.env_file_store",
+    "env_file_reader.reader",
+    "shell.local_shell",
+    "ui"
+  ]
+
+  Contract Symbol, Hash => Any
+  def call(env_file_name, options)
+    env_file = env_file_store.get(env_file_name)
+    result = reader.read(local_shell, env_file)
+    ui.print_info(env_file_name.to_s, JSON.pretty_generate(result))
+  end
+end

data/lib/kuber_kit/actions/image_compiler.rb

@@ -0,0 +1,56 @@
+class KuberKit::Actions::ImageCompiler
+  include KuberKit::Import[
+    "image_compiler.compiler",
+    "image_compiler.image_dependency_resolver",
+    "shell.local_shell",
+    "tools.logger",
+    "configs",
+    "ui"
+  ]
+
+  Contract ArrayOf[Symbol], Hash => Any
+  def call(image_names, options)
+    build_id = generate_build_id
+
+    resolved_dependencies = []
+    dependencies = image_dependency_resolver.get_next(image_names)
+
+    while (dependencies - resolved_dependencies).any?
+      compile_simultaneously(dependencies, build_id)
+      resolved_dependencies += dependencies
+      dependencies = image_dependency_resolver.get_next(image_names, resolved: resolved_dependencies)
+    end
+
+    compile_simultaneously(image_names - resolved_dependencies, build_id)
+  end
+
+  private
+    def compile_simultaneously(image_names, build_id)
+      task_group = ui.create_task_group
+      image_names.map do |image_name|
+
+        logger.info("Started compiling: #{image_name.to_s.green}")
+        task_group.add("Compiling #{image_name.to_s.yellow}") do |task|
+          compile_image(image_name, build_id)
+
+          task.update_title("Compiled #{image_name.to_s.green}")
+          logger.info("Finished compiling: #{image_name.to_s.green}")
+        end
+        
+      end
+      task_group.wait
+    end
+
+    def compile_image(image_name, build_id)
+      compile_dir = generate_compile_dir(build_id: build_id)
+      image_compiler.compile(local_shell, image_name, compile_dir)
+    end
+
+    def generate_build_id
+      Time.now.strftime("%H%M%S")
+    end
+
+    def generate_compile_dir(build_id:)
+      File.join(configs.image_compile_dir, build_id)
+    end
+end

data/lib/kuber_kit/actions/kubectl_applier.rb

@@ -0,0 +1,17 @@
+class KuberKit::Actions::KubectlApplier
+  include KuberKit::Import[
+    "shell.kubectl_commands",
+    "shell.local_shell",
+    "ui"
+  ]
+
+  Contract String, Hash => Any
+  def call(file_path, options)
+    kubecfg_path = KuberKit.current_configuration.kubecfg_path
+    ui.create_task("Applying file: #{file_path}") do |task|
+      kubectl_commands.apply_file(local_shell, file_path, kubecfg_path: kubecfg_path)
+      task.update_title("Applied file: #{file_path}")
+    end
+    nil
+  end
+end

data/lib/kuber_kit/actions/service_applier.rb

@@ -0,0 +1,39 @@
+class KuberKit::Actions::ServiceApplier
+  include KuberKit::Import[
+    "core.service_store",
+    "service_deployer.service_reader",
+    "service_deployer.service_list_resolver",
+    "shell.local_shell",
+    "shell.kubectl_commands",
+    "configs",
+    "ui"
+  ]
+
+  Contract KeywordArgs[
+    services:   Maybe[ArrayOf[String]],
+    tags:       Maybe[ArrayOf[String]],
+  ] => Any
+  def call(services:, tags:)
+    service_names = service_list_resolver.resolve(
+      services: services || [],
+      tags:     tags || []
+    )
+    service_names.each do |service_name|
+      apply_service(service_name.to_sym)
+    end
+  end
+
+  def apply_service(service_name)
+    service = service_store.get_service(service_name)
+    kubecfg_path = KuberKit.current_configuration.kubecfg_path
+
+    result = service_reader.read(local_shell, service)
+    file_path = "#{configs.service_config_dir}/#{service.name}.yml"
+    local_shell.write(file_path, result)
+
+    ui.create_task("Applying file: #{file_path}") do |task|
+      kubectl_commands.apply_file(local_shell, file_path, kubecfg_path: kubecfg_path)
+      task.update_title("Applied file: #{file_path}")
+    end
+  end
+end

data/lib/kuber_kit/actions/service_reader.rb

@@ -0,0 +1,17 @@
+class KuberKit::Actions::ServiceReader
+  include KuberKit::Import[
+    "core.service_store",
+    "service_deployer.service_reader",
+    "shell.local_shell",
+    "ui"
+  ]
+
+  Contract Symbol, Hash => Any
+  def call(service_name, options)
+    service = service_store.get_service(service_name)
+
+    result = service_reader.read(local_shell, service)
+
+    ui.print_info(service_name.to_s, result)
+  end
+end

data/lib/kuber_kit/actions/template_reader.rb

@@ -0,0 +1,17 @@
+class KuberKit::Actions::TemplateReader
+  include KuberKit::Import[
+    "core.template_store",
+    "template_reader.reader",
+    "shell.local_shell",
+    "ui"
+  ]
+
+  Contract Symbol, Hash => Any
+  def call(template_name, options)
+    template = template_store.get(template_name)
+
+    result = reader.read(local_shell, template)
+
+    ui.print_info(template_name.to_s, result)
+  end
+end

data/lib/kuber_kit/artifacts_sync/abstract_artifact_resolver.rb

@@ -0,0 +1,5 @@
+class KuberKit::ArtifactsSync::AbstractArtifactResolver
+  def resolve(shell, artifact)
+    raise KuberKit::NotImplementedError, "must be implemented"
+  end
+end

data/lib/kuber_kit/artifacts_sync/artifacts_updater.rb

@@ -0,0 +1,42 @@
+class KuberKit::ArtifactsSync::ArtifactsUpdater
+  ResolverNotFoundError = Class.new(KuberKit::NotFoundError)
+
+  include KuberKit::Import[
+    "artifacts_sync.git_artifact_resolver",
+    "artifacts_sync.null_artifact_resolver",
+    "tools.logger"
+  ]
+
+  def use_resolver(artifact_resolver, artifact_class:)
+    @@resolvers ||= {}
+
+    if !artifact_resolver.is_a?(KuberKit::ArtifactsSync::AbstractArtifactResolver)
+      raise ArgumentError.new("should be an instance of KuberKit::ArtifactsSync::AbstractArtifactResolver, got: #{artifact_resolver.inspect}")
+    end
+
+    @@resolvers[artifact_class] = artifact_resolver
+  end
+
+  def update(shell, artifacts)
+    add_default_resolvers
+
+    artifacts.each do |artifact|
+      resolver = @@resolvers[artifact.class]
+
+      logger.info "Updating artifact #{artifact.name.to_s.green}"
+      
+      raise ResolverNotFoundError, "Can't find resolver for artifact #{artifact}" if resolver.nil?
+
+      resolver.resolve(shell, artifact)
+    end
+  end
+
+  def add_default_resolvers
+    use_resolver(git_artifact_resolver, artifact_class: KuberKit::Core::Artifacts::Git)
+    use_resolver(null_artifact_resolver, artifact_class: KuberKit::Core::Artifacts::Local)
+  end
+
+  def reset!
+    @@resolvers = {}
+  end
+end

data/lib/kuber_kit/artifacts_sync/git_artifact_resolver.rb

@@ -0,0 +1,31 @@
+class KuberKit::ArtifactsSync::GitArtifactResolver < KuberKit::ArtifactsSync::AbstractArtifactResolver
+
+  include KuberKit::Import[
+    "shell.git_commands",
+  ]
+
+  Contract KuberKit::Shell::AbstractShell, KuberKit::Core::Artifacts::Git => Any
+  def resolve(shell, artifact)
+    already_cloned = artifact_already_cloned?(
+      shell:       shell,
+      target_path: artifact.cloned_path,
+      remote_url:  artifact.remote_url,
+    )
+
+    if already_cloned
+      git_commands.force_pull_repo(shell, 
+        path: artifact.cloned_path, branch: artifact.branch
+      )
+    else
+      git_commands.download_repo(shell, 
+        remote_url: artifact.remote_url, path: artifact.cloned_path, branch: artifact.branch
+      )
+    end
+  end
+
+  private
+    def artifact_already_cloned?(shell:, target_path:, remote_url:)
+      target_remote_url = git_commands.get_remote_url(shell, target_path)
+      target_remote_url == remote_url
+    end
+end

data/lib/kuber_kit/artifacts_sync/null_artifact_resolver.rb

@@ -0,0 +1,7 @@
+class KuberKit::ArtifactsSync::NullArtifactResolver < KuberKit::ArtifactsSync::AbstractArtifactResolver
+
+  Contract KuberKit::Shell::AbstractShell, Any => Any
+  def resolve(shell, artifact)
+    return true
+  end
+end

data/lib/kuber_kit/cli.rb

@@ -0,0 +1,72 @@
+require 'thor'
+
+class KuberKit::CLI < Thor
+  class_option :path, :type => :string
+  class_option :images_path, :type => :string
+  class_option :infra_path, :type => :string
+  class_option :configurations_path, :type => :string
+  class_option :debug, :type => :boolean, aliases: ["-d"]
+  class_option :configuration, :type => :string, aliases: ["-C"]
+
+  desc "compile IMAGE_NAMES", "Compile image with IMAGE_NAMES (comma-separated)"
+  def compile(image_names_str)
+    KuberKit.set_debug_mode(options[:debug])
+    
+    image_names = image_names_str.split(",").map(&:strip).map(&:to_sym)
+
+    KuberKit::Container['actions.configuration_loader'].call(options)
+    KuberKit::Container['actions.image_compiler'].call(image_names, options)
+
+    logger = KuberKit::Container['tools.logger']
+    logger.info("---------------------------")
+    logger.info("Image compilation finished!")
+    logger.info("---------------------------")
+  end
+
+  desc "env ENV_FILE_NAME", "Return content of Env File ENV_FILE_NAME"
+  def env(env_file_name)
+    KuberKit.set_debug_mode(options[:debug])
+
+    KuberKit::Container['actions.configuration_loader'].call(options)
+    KuberKit::Container['actions.env_file_reader'].call(env_file_name.to_sym, options)
+  end
+
+  desc "template TEMPLATE_NAME", "Return content of Template TEMPLATE_NAME"
+  def template(template_name)
+    KuberKit.set_debug_mode(options[:debug])
+
+    KuberKit::Container['actions.configuration_loader'].call(options)
+    KuberKit::Container['actions.template_reader'].call(template_name.to_sym, options)
+  end
+
+  desc "service SERVICE_NAME", "Return content of Service SERVICE_NAME"
+  def service(service_name)
+    KuberKit.set_debug_mode(options[:debug])
+
+    KuberKit::Container['actions.configuration_loader'].call(options)
+    KuberKit::Container['actions.service_reader'].call(service_name.to_sym, options)
+  end
+
+  desc "apply FILE_PATH", "Apply FILE_PATH with kubectl"
+  def apply(file_path)
+    KuberKit.set_debug_mode(options[:debug])
+
+    KuberKit::Container['actions.configuration_loader'].call(options)
+    KuberKit::Container['actions.kubectl_applier'].call(File.expand_path(file_path), options)
+  end
+
+  desc "deploy CONTEXT_NAME", "Deploy CONTEXT_NAME with kubectl"
+  method_option :services,   :type => :array, aliases: ["-s"]
+  method_option :tags,       :type => :array, aliases: ["-t"]
+  def deploy
+    KuberKit.set_debug_mode(options[:debug])
+
+    KuberKit::Container['actions.configuration_loader'].call(options)
+
+    KuberKit::Container['actions.service_applier'].call(services: options[:services], tags: options[:tags])
+  end
+
+  def self.exit_on_failure?
+    true
+  end
+end

data/lib/kuber_kit/configs.rb

@@ -0,0 +1,42 @@
+class KuberKit::Configs
+  IMAGE_DOCKERFILE_NAME = "Dockerfile".freeze
+  IMAGE_BUILD_CONTEXT_DIR = "build_context".freeze
+  IMAGE_TAG = 'latest'.freeze
+  IMAGE_COMPILE_DIR = "/tmp/kuber_kit/image_builds"
+  DOCKER_IGNORE_LIST = [
+    'Dockerfile',
+    '.DS_Store',
+    '**/.DS_Store',
+    '**/*.log',
+    'node_modules',
+    '.vagrant',
+    '.vscode',
+    'tmp',
+    'logs'
+  ]
+  INDOCKER_DIRNAME       = "kuber_kit".freeze
+  IMAGES_DIRNAME         = "images".freeze
+  INFRA_DIRNAME          = "infrastructure".freeze
+  CONFIGURATIONS_DIRNAME = "configurations".freeze
+  ARTIFACT_CLONE_DIR     = "/tmp/kuber_kit/artifacts"
+  SERVICE_CONFIG_DIR     = "/tmp/kuber_kit/services"
+
+  attr_accessor :image_dockerfile_name, :image_build_context_dir, :image_tag,
+                :docker_ignore_list, :image_compile_dir, 
+                :kuber_kit_dirname, :images_dirname, :infra_dirname, :configurations_dirname,
+                :artifact_clone_dir, :service_config_dir
+
+  def initialize
+    @image_dockerfile_name   = IMAGE_DOCKERFILE_NAME
+    @image_build_context_dir = IMAGE_BUILD_CONTEXT_DIR
+    @image_tag               = IMAGE_TAG
+    @image_compile_dir       = IMAGE_COMPILE_DIR
+    @docker_ignore_list      = DOCKER_IGNORE_LIST
+    @kuber_kit_dirname        = INDOCKER_DIRNAME
+    @images_dirname          = IMAGES_DIRNAME
+    @infra_dirname           = INFRA_DIRNAME
+    @configurations_dirname  = CONFIGURATIONS_DIRNAME
+    @artifact_clone_dir      = ARTIFACT_CLONE_DIR
+    @service_config_dir      = SERVICE_CONFIG_DIR
+  end
+end