kuber_kit 0.1.0

data/lib/kuber_kit/extensions/contracts.rb

@@ -0,0 +1,4 @@
+class Object
+  include Contracts::Core
+  include Contracts::Builtin
+end

data/lib/kuber_kit/extensions/indocker_compat.rb

@@ -0,0 +1,19 @@
+# Aliases for compatibility with Indocker
+module KuberKit
+  module Registries
+    Local = KuberKit::Core::Registries::Registry
+    Remote = KuberKit::Core::Registries::Registry
+  end
+
+  module Repositories
+    NoSync = KuberKit::Core::Artifacts::Local
+    Git = KuberKit::Core::Artifacts::Git
+  end
+
+  class << self
+    def build_configuration(configuration_name)
+      define_configuration(configuration_name)
+    end
+  end
+end
+Indocker = KuberKit

data/lib/kuber_kit/extensions/inspectable.rb

@@ -0,0 +1,10 @@
+module KuberKit::Extensions::Inspectable
+  def inspect
+    data = {}
+    instance_variables.each do |variable|
+      data[variable.to_s.gsub('@', '').to_sym] = instance_variable_get(variable)
+    end
+
+    "#{self.class.to_s}<#{data.inspect}>"
+  end
+end

data/lib/kuber_kit/image_compiler/compiler.rb

@@ -0,0 +1,21 @@
+class KuberKit::ImageCompiler::Compiler
+  include KuberKit::Import[
+    "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)
+
+    image_build_dir = File.join(builds_dir, image.name.to_s)
+
+    context_helper = context_helper_factory.build_image_context(shell)
+    image_build_dir_creator.create(shell, image, image_build_dir, context_helper: context_helper)
+
+    image_builder.build(shell, image, image_build_dir, context_helper: context_helper, args: [])
+    image_build_dir_creator.cleanup(shell, image_build_dir)
+  end
+end

data/lib/kuber_kit/image_compiler/image_build_dir_creator.rb

@@ -0,0 +1,37 @@
+class KuberKit::ImageCompiler::ImageBuildDirCreator
+  include KuberKit::Import[
+    "preprocessing.dir_preprocessor",
+    "preprocessing.file_preprocessor",
+    "shell.bash_commands",
+    "configs"
+  ]
+
+  Contract KuberKit::Shell::AbstractShell, KuberKit::Core::Image, String, KeywordArgs[
+    context_helper: Maybe[Any]
+  ] => Any
+  def create(shell, image, build_dir, context_helper: nil)
+    bash_commands.rm_rf(shell, build_dir)
+    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
+      )
+    end
+
+    target_dockerfile = File.join(build_dir, configs.image_dockerfile_name)
+    file_preprocessor.compile(
+      shell, image.dockerfile_path, 
+      destination_path: target_dockerfile, 
+      context_helper: context_helper
+    )
+
+    docker_ignore_content = configs.docker_ignore_list.join("\r\n")
+    shell.write(File.join(build_dir, '.dockerignore'), docker_ignore_content)
+  end
+
+  def cleanup(shell, build_dir)
+    bash_commands.rm_rf(shell, build_dir)
+  end
+end

data/lib/kuber_kit/image_compiler/image_builder.rb

@@ -0,0 +1,26 @@
+class KuberKit::ImageCompiler::ImageBuilder
+  include KuberKit::Import[
+    "shell.docker_commands",
+    "image_compiler.version_tag_builder"
+  ]
+
+  Contract KuberKit::Shell::AbstractShell, KuberKit::Core::Image, String, KeywordArgs[
+    args: Maybe[Any],
+    context_helper: Maybe[KuberKit::Core::ContextHelper]
+  ] => Any
+  def build(shell, image, build_dir, context_helper: nil, args: [])
+    image.before_build_callback.call(context_helper, build_dir) if image.before_build_callback
+
+    docker_commands.build(shell, build_dir, ["-t=#{image.registry_url}"])
+
+    version_tag = version_tag_builder.get_version
+    docker_commands.tag(shell, image.registry_url, version_tag)
+
+    if image.registry.remote?
+      docker_commands.tag(shell, image.registry_url, image.remote_registry_url)
+      docker_commands.push(shell, image.remote_registry_url)
+    end
+
+    image.after_build_callback.call(context_helper, build_dir) if image.after_build_callback
+  end
+end

data/lib/kuber_kit/image_compiler/image_dependency_resolver.rb

@@ -0,0 +1,40 @@
+class KuberKit::ImageCompiler::ImageDependencyResolver
+  CircularDependencyError = Class.new(KuberKit::Error)
+  DependencyNotFoundError = Class.new(KuberKit::NotFoundError)
+
+  include KuberKit::Import[
+    "core.image_store"
+  ]
+  
+  Contract Any, KeywordArgs[
+    resolved: Optional[ArrayOf[Symbol]]
+  ] => Any
+  def get_next(image_names, resolved: [])
+    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
+  end
+
+  def get_recursive_deps(image_name, dependency_tree: [])
+    deps = get_deps(image_name)
+
+    if dependency_tree.include?(image_name)
+      raise CircularDependencyError, "Circular dependency found for #{image_name}. Dependency tree: #{dependency_tree.inspect}"
+    end
+
+    child_deps = []
+    deps.each do |i| 
+      child_deps += get_recursive_deps(i, dependency_tree: dependency_tree + [image_name])
+    end
+
+    (deps + child_deps).uniq
+  end
+
+  def get_deps(image_name)
+    image_store.get_definition(image_name).dependencies
+  end
+end

data/lib/kuber_kit/image_compiler/version_tag_builder.rb

@@ -0,0 +1,5 @@
+class KuberKit::ImageCompiler::VersionTagBuilder
+  def get_version
+    Time.now.strftime("%Y%m%d.%H%M%S")
+  end
+end

data/lib/kuber_kit/preprocessing/dir_preprocessor.rb

@@ -0,0 +1,19 @@
+class KuberKit::Preprocessing::DirPreprocessor
+  include KuberKit::Import[
+    "preprocessing.file_preprocessor",
+    "shell.bash_commands"
+  ]
+
+  def compile(shell, source_dir, destination_dir, context_helper: nil)
+    shell.recursive_list_files(source_dir).each do |source_file_path|
+      relative_path = source_file_path.sub(source_dir, '')
+      destination_file_path = File.join(destination_dir, relative_path)
+
+      file_preprocessor.compile(
+        shell, source_file_path, 
+        destination_path: destination_file_path, 
+        context_helper: context_helper
+      )
+    end
+  end
+end

data/lib/kuber_kit/preprocessing/file_preprocessor.rb

@@ -0,0 +1,33 @@
+class KuberKit::Preprocessing::FilePreprocessor
+  include KuberKit::Import[
+    "preprocessing.text_preprocessor"
+  ]
+
+  PreprocessingError = Class.new(KuberKit::Error)
+
+  def compile(shell, source_path, destination_path: nil, context_helper: nil)
+    destination_path ||= source_path
+
+    prepare_destination_dir(destination_path)
+
+    template = shell.read(source_path)
+    content = text_preprocessor.compile(template, context_helper: context_helper)
+
+    is_content_changed = template != content
+    if !is_content_changed && source_path == destination_path
+      return false
+    end
+
+    shell.write(destination_path, content)
+
+    return true
+  rescue Exception => e
+    message = "#{e.message}\r\n"
+    message += e.backtrace.select{|l| l.include?("(erb)") }.join("\r\n")
+    raise PreprocessingError, "Error while processing template #{source_path}.\r\n#{message}"
+  end
+
+  def prepare_destination_dir(destination_path)
+    FileUtils.mkdir_p(File.dirname(destination_path))
+  end
+end

data/lib/kuber_kit/preprocessing/text_preprocessor.rb

@@ -0,0 +1,7 @@
+require 'erb'
+
+class KuberKit::Preprocessing::TextPreprocessor
+  def compile(template, context_helper: nil)
+    ERB.new(template).result(context_helper&.get_binding)
+  end
+end

data/lib/kuber_kit/service_deployer/service_list_resolver.rb

@@ -0,0 +1,56 @@
+class KuberKit::ServiceDeployer::ServiceListResolver
+  include KuberKit::Import[
+    "core.service_store"
+  ]
+
+  Contract KeywordArgs[
+    services: Optional[ArrayOf[String]],
+    tags:     Optional[ArrayOf[String]]
+  ] => ArrayOf[String]
+  def resolve(services: [], tags: [])
+    all_definitions = service_store.all_definitions.values
+
+    included_services, excluded_services = split_by_inclusion(services)
+    included_tags,     excluded_tags     = split_by_inclusion(tags)
+    
+    included_definitions = all_definitions.select do |definition|
+      service_name = definition.service_name.to_s
+      service_tags = definition.to_service_attrs.tags.map(&:to_s)
+
+      matches_any?([service_name], included_services) ||
+      matches_any?(service_tags, included_tags)
+    end
+
+    included_definitions = included_definitions.reject do |definition|
+      service_name = definition.service_name.to_s
+      service_tags = definition.to_service_attrs.tags.map(&:to_s)
+
+      matches_any?([service_name], excluded_services) ||
+      matches_any?(service_tags, excluded_tags)
+    end
+
+    included_definitions.map(&:service_name).map(&:to_s)
+  end
+
+  Contract Array => Array
+  def split_by_inclusion(array)
+    excluded, included = array.partition{|e| e.start_with?('-') }
+
+    excluded.map!{ |item| item.gsub(/^\-/, "") }
+
+    [included, excluded]
+  end
+
+  Contract String, String => Bool
+  def matches_name?(name, pattern)
+    regexp = Regexp.new("\\A" + pattern.gsub("*", "[a-z\_0-9]+") + "\\z")
+    name.match?(regexp)
+  end
+
+  Contract ArrayOf[String], ArrayOf[String] => Bool
+  def matches_any?(names, patterns)
+    patterns.any? do |pattern|
+      names.any? { |name| matches_name?(name, pattern) }
+    end
+  end
+end

data/lib/kuber_kit/service_deployer/service_reader.rb

@@ -0,0 +1,20 @@
+class KuberKit::ServiceDeployer::ServiceReader
+  include KuberKit::Import[
+    "core.template_store",
+    "core.context_helper_factory",
+    "template_reader.reader",
+    "preprocessing.text_preprocessor"
+  ]
+
+  def read(shell, service)
+    template = template_store.get(service.template_name)
+
+    context_helper = context_helper_factory.build_service_context(shell, service)
+
+    template = reader.read(shell, template)
+
+    result = text_preprocessor.compile(template, context_helper: context_helper)
+
+    result
+  end
+end

data/lib/kuber_kit/shell/abstract_shell.rb

@@ -0,0 +1,20 @@
+class KuberKit::Shell::AbstractShell
+  ShellError = Class.new(KuberKit::Error)
+  DirNotFoundError = Class.new(ShellError)
+
+  def exec!(command)
+    raise KuberKit::NotImplementedError, "must be implemented"
+  end
+
+  def read(file_path)
+    raise KuberKit::NotImplementedError, "must be implemented"
+  end
+
+  def write(file_path, content)
+    raise KuberKit::NotImplementedError, "must be implemented"
+  end
+
+  def recursive_list_files(path, name: nil)
+    raise KuberKit::NotImplementedError, "must be implemented"
+  end
+end

data/lib/kuber_kit/shell/bash_commands.rb

@@ -0,0 +1,25 @@
+class KuberKit::Shell::BashCommands
+  def rm(shell, path)
+    shell.exec!(%Q{rm "#{path}"})
+  end
+
+  def rm_rf(shell, path)
+    shell.exec!(%Q{rm -rf "#{path}"})
+  end
+
+  def cp(shell, source_path, dest_path)
+    shell.exec!(%Q{cp "#{source_path}" "#{dest_path}"})
+  end
+
+  def cp_r(shell, source_path, dest_path)
+    shell.exec!(%Q{cp -r "#{source_path}" "#{dest_path}"})
+  end
+
+  def mkdir(shell, path)
+    shell.exec!(%Q{mkdir "#{path}"})
+  end
+
+  def mkdir_p(shell, path)
+    shell.exec!(%Q{mkdir -p "#{path}"})
+  end
+end

data/lib/kuber_kit/shell/command_counter.rb

@@ -0,0 +1,19 @@
+class KuberKit::Shell::CommandCounter
+  def initialize
+    @mutex = Mutex.new
+  end
+
+  def get_number
+    @mutex.synchronize do
+      @@number ||= 0
+      @@number += 1
+      @@number
+    end
+  end
+
+  def reset!
+    @mutex.synchronize do
+      @@number = 0
+    end
+  end
+end

data/lib/kuber_kit/shell/docker_commands.rb

@@ -0,0 +1,16 @@
+class KuberKit::Shell::DockerCommands
+  def build(shell, build_dir, args = [])
+    default_args = ["--rm=true"]
+    args_list = (default_args + args).join(" ")
+
+    shell.exec!(%Q{docker build #{build_dir} #{args_list}})
+  end
+
+  def tag(shell, image_name, tag_name)
+    shell.exec!(%Q{docker tag #{image_name} #{tag_name}})
+  end
+
+  def push(shell, tag_name)
+    shell.exec!(%Q{docker push #{tag_name}})
+  end
+end

data/lib/kuber_kit/shell/git_commands.rb

@@ -0,0 +1,28 @@
+class KuberKit::Shell::GitCommands
+  def get_remote_url(shell, git_repo_path, remote_name: "origin")
+    shell.exec! [
+      "cd #{git_repo_path}",
+      "git config --get remote.#{remote_name}.url",
+    ].join(" && ")
+  rescue KuberKit::Shell::AbstractShell::ShellError
+    return nil
+  end
+
+  def download_repo(shell, remote_url:, path:, branch:)
+    shell.exec! [
+      "rm -rf #{path}",
+      "mkdir -p #{path}",
+      "git clone -b #{branch} --depth 1 #{remote_url} #{path}",
+    ].join(" && ")
+  end
+
+  def force_pull_repo(shell, path:, branch:)
+    shell.exec! [
+      "cd #{path}",
+      "git add .",
+      "git reset HEAD --hard",
+      "git checkout #{branch}",
+      "git pull --force",
+    ].join(" && ")
+  end
+end

data/lib/kuber_kit/shell/kubectl_commands.rb

@@ -0,0 +1,12 @@
+class KuberKit::Shell::KubectlCommands
+  def apply_file(shell, file_path, kubecfg_path: nil)
+    command_parts = []
+    if kubecfg_path
+      command_parts << "KUBECFG=#{kubecfg_path}"
+    end
+
+    command_parts << "kubectl apply -f #{file_path}"
+
+    shell.exec!(command_parts.join(" "))
+  end
+end