kuber_kit 0.1.1 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0635a0f1e358b5f29f44badbd6571e0a54c98f16072656c5edb8a19769c7bd92
-  data.tar.gz: 3c81a6c67d14c5ca7852a856c10e3acb22b57cac835ad26a922c020609e57ea1
+  metadata.gz: c345ef3a461e5dc43ff910b8fb2cf4e1b4e306407d24d177ff2d8c0b1c894bcb
+  data.tar.gz: 597d9d093ce85c209562104e50763b3711558437baa410fc0d44e491d53f6f4c
 SHA512:
-  metadata.gz: 0aa582e58931303efe8a60dfebaa4f1550d3e7f962ac6b1d758ff5398ffc2d61c31288699b931e0127720ff67d8e9de750ea005758282539fb6f37d15509abb6
-  data.tar.gz: d676378c03ce31d7812edb3c760cbc5b99df7daf54de7109485691634dd173c55ced342c3c87a77ee6fc6e2b969b7d505b950b0fd62cb29dbe7d321d56867fef
+  metadata.gz: 240963d8b9452926d6d761b5f47c1464894c2fd115a75905f99b6ceed8ea2f835a97aaa34fa96ddf2dfd5ea22774f3cd5d5df474d7f4f7d99636feebd886c73f
+  data.tar.gz: ef2018ef89bad80de6a11bf6d1682ed8f72d24e261a10cd79f018aea5c66930613a9373b2405757070d78017273c302c6a2cdc2f64b05790f032b58a69000a29

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    kuber_kit (0.1.1)
+    kuber_kit (0.1.6)
       cli-ui
       contracts-lite
       dry-auto_inject
@@ -10,7 +10,7 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    cli-ui (1.3.0)
+    cli-ui (1.4.0)
     coderay (1.1.3)
     concurrent-ruby (1.1.7)
     contracts-lite (0.15.0)

data/TODO.md

@@ -1,2 +1,6 @@
+- limit amount of simultaneous image builds
+- list services and require confirmation before deployment
+- service factory should make sure that template exists
 - add build servers support
-- add build vars support (use images instead of containers)
+- add build vars support (use images instead of containers)
+- template should be able to depend on image?

data/example/app_data/env_file.yml

@@ -0,0 +1,10 @@
+---
+apiVersion: v1
+kind: Secret
+metadata:
+  name: env-secret-review
+type: Opaque
+stringData:
+  <% env_file(:test).each do |key, value| -%>
+  <%= key %>: "<%= value %>"
+  <% end -%>

data/example/app_data/service.yml

@@ -1,7 +1,25 @@
-apiVersion: v1
-kind: Service
+
+apiVersion: apps/v1
+kind: Deployment
 metadata:
-  name: "<%= service_uri %>"
+  labels:
+    app: <%= service_uri %>
+  name: <%= service_uri %>
 spec:
+  replicas: 1
   selector:
-    app: test-app
+    matchLabels:
+      app: <%= service_uri %>
+  strategy: {}
+  template:
+    metadata:
+      labels:
+        app: <%= service_uri %>
+    spec:
+      containers:
+      - name: <%= service_uri %>
+        image: <%= service_name %>:latest
+        imagePullPolicy: Always
+      restartPolicy: Always
+      imagePullSecrets:
+        - name: regcred

data/example/infrastructure/templates.rb

@@ -1,4 +1,9 @@
 KuberKit.add_template(
   KuberKit::Core::Templates::ArtifactFile
     .new(:service, artifact_name: :kuber_kit_example_data, file_path: "service.yml")
+)
+
+KuberKit.add_template(
+  KuberKit::Core::Templates::ArtifactFile
+    .new(:env_file, artifact_name: :kuber_kit_example_data, file_path: "env_file.yml")
 )

data/example/services/env_file.rb

@@ -0,0 +1,3 @@
+KuberKit
+  .define_service(:env_file)
+  .template(:env_file)

data/example/services/ruby_app.rb

@@ -0,0 +1,4 @@
+KuberKit
+  .define_service(:ruby_app)
+  .template(:service)
+  .images(:ruby_app)

data/lib/kuber_kit.rb

@@ -82,6 +82,7 @@ module KuberKit
   end
 
   module ImageCompiler
+    autoload :ActionHandler, 'image_compiler/action_handler'
     autoload :Compiler, 'image_compiler/compiler'
     autoload :ImageBuilder, 'image_compiler/image_builder'
     autoload :ImageBuildDirCreator, 'image_compiler/image_build_dir_creator'
@@ -103,9 +104,13 @@ module KuberKit
   end
 
   module EnvFileReader
+    autoload :ActionHandler, 'env_file_reader/action_handler'
     autoload :Reader, 'env_file_reader/reader'
-    autoload :AbstractEnvFileReader, 'env_file_reader/abstract_env_file_reader'
-    autoload :ArtifactFileReader, 'env_file_reader/artifact_file_reader'
+
+    module Strategies
+      autoload :Abstract, 'env_file_reader/strategies/abstract'
+      autoload :ArtifactFile, 'env_file_reader/strategies/artifact_file'
+    end
   end
 
   module TemplateReader
@@ -115,9 +120,20 @@ module KuberKit
   end
 
   module ServiceDeployer
-    autoload :ServiceReader, 'service_deployer/service_reader'
-    autoload :ServiceApplier, 'service_deployer/service_applier'
+    autoload :ActionHandler, 'service_deployer/action_handler'
+    autoload :StrategyDetector, 'service_deployer/strategy_detector'
+    autoload :Deployer, 'service_deployer/deployer'
     autoload :ServiceListResolver, 'service_deployer/service_list_resolver'
+
+    module Strategies
+      autoload :Abstract, 'service_deployer/strategies/abstract'
+      autoload :Kubernetes, 'service_deployer/strategies/kubernetes'
+    end
+  end
+
+  module ServiceReader
+    autoload :ActionHandler, 'service_reader/action_handler'
+    autoload :Reader, 'service_reader/reader'
   end
 
   module Actions
@@ -125,7 +141,7 @@ module KuberKit
     autoload :EnvFileReader, 'actions/env_file_reader'
     autoload :TemplateReader, 'actions/template_reader'
     autoload :ServiceReader, 'actions/service_reader'
-    autoload :ServiceApplier, 'actions/service_applier'
+    autoload :ServiceDeployer, 'actions/service_deployer'
     autoload :ConfigurationLoader, 'actions/configuration_loader'
     autoload :KubectlApplier, 'actions/kubectl_applier'
   end

data/lib/kuber_kit/actions/env_file_reader.rb

@@ -2,16 +2,14 @@ require 'json'
 
 class KuberKit::Actions::EnvFileReader
   include KuberKit::Import[
-    "core.env_file_store",
-    "env_file_reader.reader",
     "shell.local_shell",
-    "ui"
+    "ui",
+    env_file_reader: "env_file_reader.action_handler",
   ]
 
   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)
+    result = env_file_reader.call(local_shell, env_file_name)
     ui.print_info(env_file_name.to_s, JSON.pretty_generate(result))
   end
 end

data/lib/kuber_kit/actions/image_compiler.rb

@@ -1,11 +1,10 @@
 class KuberKit::Actions::ImageCompiler
   include KuberKit::Import[
-    "image_compiler.compiler",
     "image_compiler.image_dependency_resolver",
     "shell.local_shell",
     "tools.logger",
-    "configs",
-    "ui"
+    "ui",
+    image_compiler: "image_compiler.action_handler",
   ]
 
   Contract ArrayOf[Symbol], Hash => Any
@@ -31,7 +30,7 @@ class KuberKit::Actions::ImageCompiler
 
         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)
+          image_compiler.call(local_shell, image_name, build_id)
 
           task.update_title("Compiled #{image_name.to_s.green}")
           logger.info("Finished compiling: #{image_name.to_s.green}")
@@ -41,16 +40,7 @@ class KuberKit::Actions::ImageCompiler
       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

@@ -7,9 +7,9 @@ class KuberKit::Actions::KubectlApplier
 
   Contract String, Hash => Any
   def call(file_path, options)
-    kubecfg_path = KuberKit.current_configuration.kubecfg_path
+    kubeconfig_path = KuberKit.current_configuration.kubeconfig_path
     ui.create_task("Applying file: #{file_path}") do |task|
-      kubectl_commands.apply_file(local_shell, file_path, kubecfg_path: kubecfg_path)
+      kubectl_commands.apply_file(local_shell, file_path, kubeconfig_path: kubeconfig_path)
       task.update_title("Applied file: #{file_path}")
     end
     nil

data/lib/kuber_kit/actions/service_deployer.rb

@@ -0,0 +1,52 @@
+class KuberKit::Actions::ServiceDeployer
+  include KuberKit::Import[
+    "actions.image_compiler",
+    "service_deployer.service_list_resolver",
+    "core.service_store",
+    "shell.local_shell",
+    "tools.logger",
+    "ui",
+    service_deployer: "service_deployer.action_handler",
+  ]
+
+  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 || []
+    )
+
+    services = service_names.map do |service_name|
+      service_store.get_service(service_name.to_sym)
+    end
+
+    images_names = services.map(&:images).flatten.uniq
+
+    compile_images(images_names)
+    deploy_services(service_names)
+  end
+
+  def deploy_services(service_names)
+    task_group = ui.create_task_group
+
+    service_names.each do |service_name|
+
+      logger.info("Started deploying: #{service_name.to_s.green}")
+      task_group.add("Deploying #{service_name.to_s.yellow}") do |task|
+        service_deployer.call(local_shell, service_name.to_sym)
+
+        task.update_title("Deployed #{service_name.to_s.green}")
+        logger.info("Finished deploying: #{service_name.to_s.green}")
+      end
+    end
+
+    task_group.wait
+  end
+
+  def compile_images(images_names)
+    image_compiler.call(images_names, {}) if images_names.any?
+  end
+end

data/lib/kuber_kit/actions/service_reader.rb

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

data/lib/kuber_kit/cli.rb

@@ -63,7 +63,7 @@ class KuberKit::CLI < Thor
 
     KuberKit::Container['actions.configuration_loader'].call(options)
 
-    KuberKit::Container['actions.service_applier'].call(services: options[:services], tags: options[:tags])
+    KuberKit::Container['actions.service_deployer'].call(services: options[:services], tags: options[:tags])
   end
 
   def self.exit_on_failure?

data/lib/kuber_kit/configs.rb

@@ -21,11 +21,12 @@ class KuberKit::Configs
   CONFIGURATIONS_DIRNAME = "configurations".freeze
   ARTIFACT_CLONE_DIR     = "/tmp/kuber_kit/artifacts"
   SERVICE_CONFIG_DIR     = "/tmp/kuber_kit/services"
+  DEPLOY_STRATEGY        = :kubernetes
 
   attr_accessor :image_dockerfile_name, :image_build_context_dir, :image_tag,
                 :docker_ignore_list, :image_compile_dir, 
                 :kuber_kit_dirname, :images_dirname, :services_dirname, :infra_dirname, :configurations_dirname,
-                :artifact_clone_dir, :service_config_dir
+                :artifact_clone_dir, :service_config_dir, :deploy_strategy
 
   def initialize
     @image_dockerfile_name   = IMAGE_DOCKERFILE_NAME
@@ -40,5 +41,6 @@ class KuberKit::Configs
     @configurations_dirname  = CONFIGURATIONS_DIRNAME
     @artifact_clone_dir      = ARTIFACT_CLONE_DIR
     @service_config_dir      = SERVICE_CONFIG_DIR
+    @deploy_strategy         = DEPLOY_STRATEGY
   end
 end

data/lib/kuber_kit/container.rb

@@ -17,8 +17,8 @@ class KuberKit::Container
     KuberKit::Actions::ServiceReader.new
   end
 
-  register "actions.service_applier" do
-    KuberKit::Actions::ServiceApplier.new
+  register "actions.service_deployer" do
+    KuberKit::Actions::ServiceDeployer.new
   end
 
   register "actions.configuration_loader" do
@@ -141,6 +141,10 @@ class KuberKit::Container
     KuberKit::Preprocessing::DirPreprocessor.new
   end
 
+  register "image_compiler.action_handler" do
+    KuberKit::ImageCompiler::ActionHandler.new
+  end
+
   register "image_compiler.compiler" do
     KuberKit::ImageCompiler::Compiler.new
   end
@@ -173,12 +177,16 @@ class KuberKit::Container
     KuberKit::ArtifactsSync::NullArtifactResolver.new
   end
 
+  register "env_file_reader.action_handler" do
+    KuberKit::EnvFileReader::ActionHandler.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
+  register "env_file_reader.strategies.artifact_file" do
+    KuberKit::EnvFileReader::Strategies::ArtifactFile.new
   end
 
   register "template_reader.reader" do
@@ -189,14 +197,34 @@ class KuberKit::Container
     KuberKit::TemplateReader::ArtifactFileReader.new
   end
 
-  register "service_deployer.service_reader" do
-    KuberKit::ServiceDeployer::ServiceReader.new
+  register "service_deployer.action_handler" do
+    KuberKit::ServiceDeployer::ActionHandler.new
+  end
+
+  register "service_deployer.strategy_detector" do
+    KuberKit::ServiceDeployer::StrategyDetector.new
+  end
+
+  register "service_deployer.deployer" do
+    KuberKit::ServiceDeployer::Deployer.new
   end
 
   register "service_deployer.service_list_resolver" do
     KuberKit::ServiceDeployer::ServiceListResolver.new
   end
 
+  register "service_deployer.strategies.kubernetes" do
+    KuberKit::ServiceDeployer::Strategies::Kubernetes.new
+  end
+
+  register "service_reader.action_handler" do
+    KuberKit::ServiceReader::ActionHandler.new
+  end
+
+  register "service_reader.reader" do
+    KuberKit::ServiceReader::Reader.new
+  end
+
   register "ui" do
     if KuberKit.debug_mode?
       KuberKit::UI::Simple.new

data/lib/kuber_kit/core/configuration.rb

@@ -1,5 +1,5 @@
 class KuberKit::Core::Configuration
-  attr_reader :name, :artifacts, :registries, :env_files, :templates, :kubecfg_path
+  attr_reader :name, :artifacts, :registries, :env_files, :templates, :kubeconfig_path, :deploy_strategy, :services_attributes
 
   Contract KeywordArgs[
     name:            Symbol,
@@ -7,14 +7,22 @@ class KuberKit::Core::Configuration
     registries:      Hash,
     env_files:       Hash,
     templates:       Hash,
-    kubecfg_path:    Maybe[String]
+    kubeconfig_path: Maybe[String],
+    deploy_strategy: Symbol,
+    services_attributes: HashOf[Symbol => Hash]
   ] => 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
+  def initialize(name:, artifacts:, registries:, env_files:, templates:, kubeconfig_path:, deploy_strategy:, services_attributes:)
+    @name             = name
+    @artifacts        = artifacts
+    @registries       = registries
+    @env_files        = env_files
+    @templates        = templates
+    @kubeconfig_path  = kubeconfig_path
+    @deploy_strategy  = deploy_strategy
+    @services_attributes = services_attributes
+  end
+
+  def service_attributes(service_name)
+    services_attributes[service_name.to_sym] || {}
   end
 end

data/lib/kuber_kit/core/configuration_definition.rb

@@ -10,16 +10,21 @@ class KuberKit::Core::ConfigurationDefinition
     @registries = {}
     @env_files  = {}
     @templates  = {}
+    @enabled_services   = []
+    @services_attributes = {}
   end
 
   def to_attrs
     OpenStruct.new(
-      name:          @configuration_name,
-      artifacts:     @artifacts,
-      registries:    @registries,
-      env_files:     @env_files,
-      templates:     @templates,
-      kubecfg_path:  @kubecfg_path
+      name:             @configuration_name,
+      artifacts:        @artifacts,
+      registries:       @registries,
+      env_files:        @env_files,
+      templates:        @templates,
+      kubeconfig_path:  @kubeconfig_path,
+      deploy_strategy:  @deploy_strategy,
+      enabled_services: @enabled_services,
+      services_attributes: @services_attributes
     )
   end
 
@@ -59,8 +64,21 @@ class KuberKit::Core::ConfigurationDefinition
     self
   end
 
-  def kubecfg_path(path)
-    @kubecfg_path = path
+  def kubeconfig_path(path)
+    @kubeconfig_path = path
+
+    self
+  end
+
+  def deploy_strategy(path)
+    @deploy_strategy = path
+
+    self
+  end
+
+  def enabled_services(services_hash)
+    @enabled_services += services_hash.keys.map(&:to_sym)
+    @services_attributes = @services_attributes.merge(services_hash)
 
     self
   end

data/lib/kuber_kit/core/configuration_factory.rb

@@ -5,7 +5,8 @@ class KuberKit::Core::ConfigurationFactory
     "core.registry_store",
     "core.artifact_store",
     "core.env_file_store",
-    "core.template_store"
+    "core.template_store",
+    "configs"
   ]
 
   def create(definition)
@@ -17,12 +18,14 @@ class KuberKit::Core::ConfigurationFactory
     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
+      name:             configuration_attrs.name,
+      artifacts:        artifacts,
+      registries:       registries,
+      env_files:        env_files,
+      templates:        templates,
+      kubeconfig_path:  configuration_attrs.kubeconfig_path,
+      deploy_strategy:  configuration_attrs.deploy_strategy || configs.deploy_strategy,
+      services_attributes: configuration_attrs.services_attributes
     )
   end
 

data/lib/kuber_kit/core/configuration_store.rb

@@ -25,6 +25,7 @@ class KuberKit::Core::ConfigurationStore
     @@configuration_definitions[configuration_definition.configuration_name] = configuration_definition
   end
 
+  Contract Symbol => Any
   def get_definition(configuration_name)
     @@configuration_definitions ||= {}
 
@@ -35,6 +36,7 @@ class KuberKit::Core::ConfigurationStore
     @@configuration_definitions[configuration_name]
   end
 
+  Contract Symbol => Any
   def get_configuration(configuration_name)
     definition = get_definition(configuration_name)
 

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

@@ -1,23 +1,30 @@
 class KuberKit::Core::ContextHelper::BaseHelper
-  attr_reader :shell, :artifact_store, :image_store
+  CONTRACT = RespondTo[:get_binding]
 
-  def initialize(image_store:, artifact_store:, shell:)
-    @image_store    = image_store
-    @artifact_store = artifact_store
-    @shell          = shell
+  attr_reader :shell, :artifact_store, :image_store, :env_file_reader
+
+  def initialize(image_store:, artifact_store:, shell:, env_file_reader:)
+    @image_store      = image_store
+    @artifact_store   = artifact_store
+    @shell            = shell
+    @env_file_reader  = env_file_reader
   end
 
   def image_url(image_name)
-    image = @image_store.get_image(image_name)
+    image = @image_store.get_image(image_name.to_sym)
 
     image.remote_registry_url
   end
 
   def artifact_path(name, file_name = nil)
-    artifact = @artifact_store.get(name)
+    artifact = @artifact_store.get(name.to_sym)
     [artifact.cloned_path, file_name].compact.join("/")
   end
 
+  def env_file(env_file_name)
+    @env_file_reader.call(@shell, env_file_name)
+  end
+
   def configuration_name
     KuberKit.current_configuration.name
   end

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

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

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

@@ -1,9 +1,10 @@
 class KuberKit::Core::ContextHelper::ServiceHelper < KuberKit::Core::ContextHelper::BaseHelper
-  def initialize(image_store:, artifact_store:, shell:, service:)
+  def initialize(image_store:, artifact_store:, shell:, env_file_reader:, service:)
     super(
-      image_store:    image_store, 
-      artifact_store: artifact_store, 
-      shell:          shell
+      image_store:      image_store, 
+      artifact_store:   artifact_store, 
+      shell:            shell,
+      env_file_reader:  env_file_reader
     )
     @service = service
   end
@@ -13,7 +14,10 @@ class KuberKit::Core::ContextHelper::ServiceHelper < KuberKit::Core::ContextHelp
   end
 
   def service_uri
-    service_name
-      .sub("_", "-")
+    @service.uri
+  end
+
+  def attribute(attribute_name)
+    @service.attribute(attribute_name)
   end
 end

data/lib/kuber_kit/core/image_store.rb

@@ -25,6 +25,7 @@ class KuberKit::Core::ImageStore
     @@image_definitions[image_definition.image_name] = image_definition
   end
 
+  Contract Symbol => Any
   def get_definition(image_name)
     @@image_definitions ||= {}
 
@@ -35,6 +36,7 @@ class KuberKit::Core::ImageStore
     @@image_definitions[image_name]
   end
 
+  Contract Symbol => Any
   def get_image(image_name)
     definition = get_definition(image_name)
 

data/lib/kuber_kit/core/service.rb

@@ -1,14 +1,32 @@
 class KuberKit::Core::Service
-  attr_reader :name, :template_name, :tags
+  AttributeNotSet = Class.new(Indocker::Error)
+
+  attr_reader :name, :template_name, :tags, :images, :attributes
 
   Contract KeywordArgs[
     name:           Symbol,
     template_name:  Symbol,
     tags:           ArrayOf[Symbol],
+    images:         ArrayOf[Symbol],
+    attributes:     HashOf[Symbol => Any],
   ] => Any
-  def initialize(name:, template_name:, tags:)
+  def initialize(name:, template_name:, tags:, images:, attributes:)
     @name = name
     @template_name = template_name
     @tags = tags
+    @images = images
+    @attributes = attributes
+  end
+
+  def uri
+    name.to_s.gsub("_", "-")
+  end
+
+  def attribute(attribute_name)
+    unless attributes.has_key?(attribute_name.to_sym)
+      raise AttributeNotSet, "attribute #{attribute_name} was not set"
+    end
+
+    attributes[attribute_name.to_sym]
   end
 end

data/lib/kuber_kit/core/service_definition.rb

@@ -10,7 +10,9 @@ class KuberKit::Core::ServiceDefinition
     OpenStruct.new(
       name:           @service_name,
       template_name:  get_value(@template_name),
-      tags:           Array(get_value(@tags)).map(&:to_sym)
+      tags:           Array(get_value(@tags)).map(&:to_sym),
+      images:         Array(get_value(@images)).map(&:to_sym),
+      attributes:     get_value(@attributes),
     )
   end
 
@@ -26,6 +28,18 @@ class KuberKit::Core::ServiceDefinition
     self
   end
 
+  def images(*value, &block)
+    @images = block_given? ? block : Array(value).flatten
+
+    self
+  end
+
+  def attributes(value = nil, &block)
+    @attributes = block_given? ? block : value
+
+    self
+  end
+
   private
     def get_value(variable)
       variable.is_a?(Proc) ? variable.call : variable

data/lib/kuber_kit/core/service_factory.rb

@@ -8,10 +8,15 @@ class KuberKit::Core::ServiceFactory
       raise AttributeNotSetError, "Please set template for service using #template method"
     end
 
+    configuration_attributes = KuberKit.current_configuration.service_attributes(service_attrs.name)
+    attributes = (service_attrs.attributes || {}).merge(configuration_attributes)
+
     KuberKit::Core::Service.new(
       name:           service_attrs.name,
       template_name:  service_attrs.template_name,
-      tags:           service_attrs.tags
+      tags:           service_attrs.tags,
+      images:         service_attrs.images,
+      attributes:     attributes
     )
   end
 end

data/lib/kuber_kit/core/service_store.rb

@@ -25,6 +25,7 @@ class KuberKit::Core::ServiceStore
     @@service_definitions[service_definition.service_name] = service_definition
   end
 
+  Contract Symbol => Any
   def get_definition(service_name)
     @@service_definitions ||= {}
 
@@ -35,6 +36,7 @@ class KuberKit::Core::ServiceStore
     @@service_definitions[service_name]
   end
 
+  Contract Symbol => Any
   def get_service(service_name)
     definition = get_definition(service_name)
 

data/lib/kuber_kit/env_file_reader/action_handler.rb

@@ -0,0 +1,12 @@
+class KuberKit::EnvFileReader::ActionHandler
+  include KuberKit::Import[
+    "env_file_reader.reader",
+    "core.env_file_store",
+  ]
+
+  Contract KuberKit::Shell::AbstractShell, Symbol => Any
+  def call(shell, env_file_name)
+    env_file = env_file_store.get(env_file_name)
+    reader.read(shell, env_file)
+  end
+end

data/lib/kuber_kit/env_file_reader/reader.rb

@@ -2,14 +2,14 @@ class KuberKit::EnvFileReader::Reader
   ReaderNotFoundError = Class.new(KuberKit::NotFoundError)
 
   include KuberKit::Import[
-    "env_file_reader.artifact_file_reader",
+    "env_file_reader.strategies.artifact_file",
   ]
 
   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}")
+    if !env_file_reader.is_a?(KuberKit::EnvFileReader::Strategies::Abstract)
+      raise ArgumentError.new("should be an instance of KuberKit::EnvFileReader::Strategies::Abstract, got: #{env_file_reader.inspect}")
     end
 
     @@readers[env_file_class] = env_file_reader
@@ -26,7 +26,7 @@ class KuberKit::EnvFileReader::Reader
   end
 
   def add_default_readers
-    use_reader(artifact_file_reader, env_file_class: KuberKit::Core::EnvFiles::ArtifactFile)
+    use_reader(artifact_file, env_file_class: KuberKit::Core::EnvFiles::ArtifactFile)
   end
 
   def reset!

data/lib/kuber_kit/env_file_reader/{abstract_env_file_reader.rb → strategies/abstract.rb}

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

data/lib/kuber_kit/env_file_reader/{artifact_file_reader.rb → strategies/artifact_file.rb}

@@ -1,4 +1,4 @@
-class KuberKit::EnvFileReader::ArtifactFileReader < KuberKit::EnvFileReader::AbstractEnvFileReader
+class KuberKit::EnvFileReader::Strategies::ArtifactFile < KuberKit::EnvFileReader::Strategies::Abstract
   include KuberKit::Import[
     "core.artifact_store"
   ]

data/lib/kuber_kit/image_compiler/action_handler.rb

@@ -0,0 +1,20 @@
+class KuberKit::ImageCompiler::ActionHandler
+  include KuberKit::Import[
+    "image_compiler.compiler",
+    "core.image_store",
+    "configs",
+  ]
+
+  Contract KuberKit::Shell::AbstractShell, Symbol, String => Any
+  def call(shell, image_name, build_id)
+    image = image_store.get_image(image_name)
+    
+    compile_dir = generate_compile_dir(build_id: build_id)
+
+    compiler.compile(shell, image, compile_dir)
+  end
+
+  def generate_compile_dir(build_id:)
+    File.join(configs.image_compile_dir, build_id)
+  end
+end

data/lib/kuber_kit/image_compiler/compiler.rb

@@ -3,19 +3,16 @@ class KuberKit::ImageCompiler::Compiler
     "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)
-
+  Contract KuberKit::Shell::AbstractShell, KuberKit::Core::Image, String => Any
+  def compile(shell, image, builds_dir)
     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_builder.build(shell, image, image_build_dir, context_helper: context_helper)
     image_build_dir_creator.cleanup(shell, image_build_dir)
   end
 end

data/lib/kuber_kit/image_compiler/image_builder.rb

@@ -5,10 +5,9 @@ class KuberKit::ImageCompiler::ImageBuilder
   ]
 
   Contract KuberKit::Shell::AbstractShell, KuberKit::Core::Image, String, KeywordArgs[
-    args: Maybe[Any],
-    context_helper: Maybe[KuberKit::Core::ContextHelper]
+    context_helper: Maybe[KuberKit::Core::ContextHelper::BaseHelper::CONTRACT]
   ] => Any
-  def build(shell, image, build_dir, context_helper: nil, args: [])
+  def build(shell, image, build_dir, context_helper: nil)
     image.before_build_callback.call(context_helper, build_dir) if image.before_build_callback
 
     docker_commands.build(shell, build_dir, ["-t=#{image.registry_url}"])

data/lib/kuber_kit/preprocessing/text_preprocessor.rb

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

data/lib/kuber_kit/service_deployer/action_handler.rb

@@ -0,0 +1,16 @@
+class KuberKit::ServiceDeployer::ActionHandler
+  include KuberKit::Import[
+    "service_deployer.deployer",
+    "service_deployer.strategy_detector",
+    "core.service_store",
+  ]
+
+  Contract KuberKit::Shell::AbstractShell, Symbol => Any
+  def call(shell, service_name)
+    service = service_store.get_service(service_name)
+
+    strategy_name = strategy_detector.call(service)
+
+    deployer.restart(shell, service, strategy_name)
+  end
+end

data/lib/kuber_kit/service_deployer/deployer.rb

@@ -0,0 +1,37 @@
+class KuberKit::ServiceDeployer::Deployer
+  StrategyNotFoundError = Class.new(KuberKit::NotFoundError)
+
+  include KuberKit::Import[
+    "core.service_store",
+    "service_deployer.strategies.kubernetes"
+  ]
+
+  def register_strategy(strategy_name, strategy)
+    @@strategies ||= {}
+
+    if !strategy.is_a?(KuberKit::ServiceDeployer::Strategies::Abstract)
+      raise ArgumentError.new("should be an instance of KuberKit::ServiceDeployer::Strategies::Abstract, got: #{strategy.inspect}")
+    end
+
+    @@strategies[strategy_name] = strategy
+  end
+
+  Contract KuberKit::Shell::AbstractShell, KuberKit::Core::Service, Symbol => Any
+  def deploy(shell, service, strategy_name)
+    add_default_strategies
+
+    deployer = @@strategies[strategy_name]
+
+    raise StrategyNotFoundError, "Can't find strategy with name #{strategy_name}" if deployer.nil?
+
+    deployer.deploy(shell, service)
+  end
+
+  def add_default_strategies
+    register_strategy(:kubernetes, kubernetes)
+  end
+
+  def reset!
+    @@strategies = {}
+  end
+end

data/lib/kuber_kit/service_deployer/strategies/abstract.rb

@@ -0,0 +1,5 @@
+class KuberKit::ServiceDeployer::Strategies::Abstract
+  def deploy(shell, service)
+    raise KuberKit::NotImplementedError, "must be implemented"
+  end
+end

data/lib/kuber_kit/service_deployer/strategies/kubernetes.rb

@@ -0,0 +1,18 @@
+class KuberKit::ServiceDeployer::Strategies::Kubernetes < KuberKit::ServiceDeployer::Strategies::Abstract
+  include KuberKit::Import[
+    "service_reader.reader",
+    "shell.kubectl_commands",
+    "configs",
+  ]
+
+  Contract KuberKit::Shell::AbstractShell, KuberKit::Core::Service => Any
+  def deploy(shell, service)
+    service_config = reader.read(shell, service)
+    config_path    = "#{configs.service_config_dir}/#{service.name}.yml"
+    shell.write(config_path, service_config)
+
+    kubeconfig_path = KuberKit.current_configuration.kubeconfig_path
+    kubectl_commands.apply_file(shell, config_path, kubeconfig_path: kubeconfig_path)
+    kubectl_commands.rolling_restart(shell, service.uri, kubeconfig_path: kubeconfig_path)
+  end
+end

data/lib/kuber_kit/service_deployer/strategy_detector.rb

@@ -0,0 +1,6 @@
+class KuberKit::ServiceDeployer::StrategyDetector
+  Contract KuberKit::Core::Service => Symbol
+  def call(service)
+    KuberKit.current_configuration.deploy_strategy
+  end
+end

data/lib/kuber_kit/service_reader/action_handler.rb

@@ -0,0 +1,13 @@
+class KuberKit::ServiceReader::ActionHandler
+  include KuberKit::Import[
+    "service_reader.reader",
+    "core.service_store",
+  ]
+
+  Contract KuberKit::Shell::AbstractShell, Symbol => Any
+  def call(shell, service_name)
+    service = service_store.get_service(service_name)
+
+    reader.read(shell, service)
+  end
+end

data/lib/kuber_kit/{service_deployer/service_reader.rb → service_reader/reader.rb}

@@ -1,4 +1,4 @@
-class KuberKit::ServiceDeployer::ServiceReader
+class KuberKit::ServiceReader::Reader
   include KuberKit::Import[
     "core.template_store",
     "core.context_helper_factory",
@@ -6,6 +6,7 @@ class KuberKit::ServiceDeployer::ServiceReader
     "preprocessing.text_preprocessor"
   ]
 
+  Contract KuberKit::Shell::AbstractShell, KuberKit::Core::Service => Any
   def read(shell, service)
     template = template_store.get(service.template_name)
 

data/lib/kuber_kit/shell/kubectl_commands.rb

@@ -1,12 +1,42 @@
+require 'json'
+require 'shellwords'
+
 class KuberKit::Shell::KubectlCommands
-  def apply_file(shell, file_path, kubecfg_path: nil)
+  def apply_file(shell, file_path, kubeconfig_path: nil)
     command_parts = []
-    if kubecfg_path
-      command_parts << "KUBECFG=#{kubecfg_path}"
+    if kubeconfig_path
+      command_parts << "KUBECONFIG=#{kubeconfig_path}"
     end
 
     command_parts << "kubectl apply -f #{file_path}"
 
     shell.exec!(command_parts.join(" "))
   end
+
+  def rolling_restart(shell, deployment_name, kubeconfig_path: nil)
+    patch_deployment(shell, deployment_name, {
+      spec: {
+        template: {
+          metadata: {
+            labels: {
+              redeploy: "$(date +%s)"
+            }
+          }
+        }
+      }
+    }, kubeconfig_path: kubeconfig_path)
+  end
+
+  def patch_deployment(shell, deployment_name, specs, kubeconfig_path: nil)
+    command_parts = []
+    if kubeconfig_path
+      command_parts << "KUBECONFIG=#{kubeconfig_path}"
+    end
+
+    specs_json = JSON.dump(specs).gsub('"', '\"')
+
+    command_parts << %Q{kubectl patch deployment #{deployment_name} -p "#{specs_json}"}
+
+    shell.exec!(command_parts.join(" "))
+  end
 end

data/lib/kuber_kit/version.rb

@@ -1,3 +1,3 @@
 module KuberKit
-  VERSION = "0.1.1"
+  VERSION = "0.1.6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kuber_kit
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.6
 platform: ruby
 authors:
 - Iskander Khaziev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-30 00:00:00.000000000 Z
+date: 2020-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: contracts-lite
@@ -144,6 +144,7 @@ files:
 - TODO.md
 - bin/console
 - bin/kit
+- example/app_data/env_file.yml
 - example/app_data/service.yml
 - example/app_data/test.env
 - example/app_data/test.txt
@@ -163,14 +164,15 @@ files:
 - example/infrastructure/env_files.rb
 - example/infrastructure/registries.rb
 - example/infrastructure/templates.rb
-- example/services/auth_app.rb
+- example/services/env_file.rb
+- example/services/ruby_app.rb
 - kuber_kit.gemspec
 - lib/kuber_kit.rb
 - lib/kuber_kit/actions/configuration_loader.rb
 - lib/kuber_kit/actions/env_file_reader.rb
 - lib/kuber_kit/actions/image_compiler.rb
 - lib/kuber_kit/actions/kubectl_applier.rb
-- lib/kuber_kit/actions/service_applier.rb
+- lib/kuber_kit/actions/service_deployer.rb
 - lib/kuber_kit/actions/service_reader.rb
 - lib/kuber_kit/actions/template_reader.rb
 - lib/kuber_kit/artifacts_sync/abstract_artifact_resolver.rb
@@ -212,13 +214,15 @@ files:
 - lib/kuber_kit/core/templates/abstract_template.rb
 - lib/kuber_kit/core/templates/artifact_file.rb
 - lib/kuber_kit/core/templates/template_store.rb
-- lib/kuber_kit/env_file_reader/abstract_env_file_reader.rb
-- lib/kuber_kit/env_file_reader/artifact_file_reader.rb
+- lib/kuber_kit/env_file_reader/action_handler.rb
 - lib/kuber_kit/env_file_reader/reader.rb
+- lib/kuber_kit/env_file_reader/strategies/abstract.rb
+- lib/kuber_kit/env_file_reader/strategies/artifact_file.rb
 - lib/kuber_kit/extensions/colored_string.rb
 - lib/kuber_kit/extensions/contracts.rb
 - lib/kuber_kit/extensions/indocker_compat.rb
 - lib/kuber_kit/extensions/inspectable.rb
+- lib/kuber_kit/image_compiler/action_handler.rb
 - lib/kuber_kit/image_compiler/compiler.rb
 - lib/kuber_kit/image_compiler/image_build_dir_creator.rb
 - lib/kuber_kit/image_compiler/image_builder.rb
@@ -227,8 +231,14 @@ files:
 - lib/kuber_kit/preprocessing/dir_preprocessor.rb
 - lib/kuber_kit/preprocessing/file_preprocessor.rb
 - lib/kuber_kit/preprocessing/text_preprocessor.rb
+- lib/kuber_kit/service_deployer/action_handler.rb
+- lib/kuber_kit/service_deployer/deployer.rb
 - lib/kuber_kit/service_deployer/service_list_resolver.rb
-- lib/kuber_kit/service_deployer/service_reader.rb
+- lib/kuber_kit/service_deployer/strategies/abstract.rb
+- lib/kuber_kit/service_deployer/strategies/kubernetes.rb
+- lib/kuber_kit/service_deployer/strategy_detector.rb
+- lib/kuber_kit/service_reader/action_handler.rb
+- lib/kuber_kit/service_reader/reader.rb
 - lib/kuber_kit/shell/abstract_shell.rb
 - lib/kuber_kit/shell/bash_commands.rb
 - lib/kuber_kit/shell/command_counter.rb

data/example/services/auth_app.rb

@@ -1,3 +0,0 @@
-KuberKit
-  .define_service(:auth_app)
-  .template(:service)

data/lib/kuber_kit/actions/service_applier.rb

@@ -1,39 +0,0 @@
-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