kuber_kit 0.1.0 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9ac91299a59af0f2eec1d7382f3b55f0946931e1d4f87de909d76631242f441
-  data.tar.gz: d0737d6d217a9c4107fb77536fd36e2c3d59e71adb9dd8c68b6dbc2c12e2eb8f
+  metadata.gz: b5df957bf6c31a193caef5d2fc163be4d925ba6dc3bd61f2d98c47f0eee2bb42
+  data.tar.gz: 701748c782360287b41acd34dcd33a3c8d9192a2ba91685a5355dddbe4b19789
 SHA512:
-  metadata.gz: d9feedc39ab9959d1a3e4bd38a5b6703f6d93f16d03bbd4805732166266e64c4dc9798d6e5d173de2e5058f1ccfc8ad86143c793916efd9936768279eedff14f
-  data.tar.gz: a9bf6386c3bac7c75c894f82464af2e9e83dd94e56dec4be9da87fd092c81e9cbff568c4432921ff601c11831127f497651beb835d21edc8379675dffc6c0e1a
+  metadata.gz: f4d10fbac924851b0552f1b833e8080203277245055717a5a7592437284eb9a5cd0535c369764ca474bc7a09686517254423fec45aeb2ccd8568d22c1851cf63
+  data.tar.gz: 1972b5f5cdd6cb8e8b1f33ae210ac783f3ff55e1c36f6304c933c2a43b3b335ff40b9400fd725be957227b3ed8160327d8d19f0352abf9b9596e4f0b0855716d

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    kuber_kit (0.1.0)
+    kuber_kit (0.1.5)
       cli-ui
       contracts-lite
       dry-auto_inject

data/TODO.md

@@ -1,2 +1,4 @@
+- rename service reader to service config reader
+- service factory should make sure that template exists
 - add build servers support
 - add build vars support (use images instead of containers)

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/services/ruby_app.rb

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

data/lib/kuber_kit.rb

@@ -115,9 +115,15 @@ module KuberKit
   end
 
   module ServiceDeployer
+    autoload :Deployer, 'service_deployer/deployer'
+    autoload :ServiceRestarter, 'service_deployer/service_restarter'
     autoload :ServiceReader, 'service_deployer/service_reader'
-    autoload :ServiceApplier, 'service_deployer/service_applier'
     autoload :ServiceListResolver, 'service_deployer/service_list_resolver'
+
+    module Strategies
+      autoload :Abstract, 'service_deployer/strategies/abstract'
+      autoload :Kubernetes, 'service_deployer/strategies/kubernetes'
+    end
   end
 
   module Actions
@@ -125,7 +131,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/configuration_loader.rb

@@ -2,6 +2,7 @@ class KuberKit::Actions::ConfigurationLoader
   include KuberKit::Import[
     "core.registry_store",
     "core.image_store",
+    "core.service_store",
     "core.configuration_store",
     "artifacts_sync.artifacts_updater",
     "tools.logger",
@@ -12,15 +13,17 @@ class KuberKit::Actions::ConfigurationLoader
 
   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)
+    root_path     = options[:path] || File.join(Dir.pwd, configs.kuber_kit_dirname)
+    images_path   = options[:images_path] || File.join(root_path, configs.images_dirname)
+    services_path = options[:services_path] || File.join(root_path, configs.services_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 "  Services path: #{services_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}"
@@ -42,6 +45,11 @@ class KuberKit::Actions::ConfigurationLoader
       files = image_store.load_definitions(images_path)
       task.update_title("Loaded #{files.count} image definitions")
     end
+
+    ui.create_task("Loading service definitions") do |task|
+      files = service_store.load_definitions(services_path)
+      task.update_title("Loaded #{files.count} service definitions")
+    end
   end
   
   def load_configurations(configurations_path, configuration_name)

data/lib/kuber_kit/actions/image_compiler.rb

@@ -43,7 +43,7 @@ class KuberKit::Actions::ImageCompiler
 
     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)
+      compiler.compile(local_shell, image_name, compile_dir)
     end
 
     def generate_build_id

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",
+    "service_deployer.deployer",
+    "core.service_store",
+    "shell.local_shell",
+    "tools.logger",
+    "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 || []
+    )
+
+    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|
+        deployer.deploy(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/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

@@ -14,17 +14,19 @@ class KuberKit::Configs
     'tmp',
     'logs'
   ]
-  INDOCKER_DIRNAME       = "kuber_kit".freeze
+  KUBER_KIT_DIRNAME      = "kuber_kit".freeze
   IMAGES_DIRNAME         = "images".freeze
+  SERVICES_DIRNAME       = "services".freeze
   INFRA_DIRNAME          = "infrastructure".freeze
   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, :infra_dirname, :configurations_dirname,
-                :artifact_clone_dir, :service_config_dir
+                :kuber_kit_dirname, :images_dirname, :services_dirname, :infra_dirname, :configurations_dirname,
+                :artifact_clone_dir, :service_config_dir, :deploy_strategy
 
   def initialize
     @image_dockerfile_name   = IMAGE_DOCKERFILE_NAME
@@ -32,11 +34,13 @@ class KuberKit::Configs
     @image_tag               = IMAGE_TAG
     @image_compile_dir       = IMAGE_COMPILE_DIR
     @docker_ignore_list      = DOCKER_IGNORE_LIST
-    @kuber_kit_dirname        = INDOCKER_DIRNAME
+    @kuber_kit_dirname       = KUBER_KIT_DIRNAME
     @images_dirname          = IMAGES_DIRNAME
+    @services_dirname        = SERVICES_DIRNAME
     @infra_dirname           = INFRA_DIRNAME
     @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
@@ -189,6 +189,14 @@ class KuberKit::Container
     KuberKit::TemplateReader::ArtifactFileReader.new
   end
 
+  register "service_deployer.deployer" do
+    KuberKit::ServiceDeployer::Deployer.new
+  end
+
+  register "service_deployer.service_restarter" do
+    KuberKit::ServiceDeployer::ServiceRestarter.new
+  end
+
   register "service_deployer.service_reader" do
     KuberKit::ServiceDeployer::ServiceReader.new
   end
@@ -197,6 +205,10 @@ class KuberKit::Container
     KuberKit::ServiceDeployer::ServiceListResolver.new
   end
 
+  register "service_deployer.strategies.kubernetes" do
+    KuberKit::ServiceDeployer::Strategies::Kubernetes.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
 
   Contract KeywordArgs[
     name:            Symbol,
@@ -7,14 +7,16 @@ class KuberKit::Core::Configuration
     registries:      Hash,
     env_files:       Hash,
     templates:       Hash,
-    kubecfg_path:    Maybe[String]
+    kubeconfig_path:    Maybe[String],
+    deploy_strategy: Symbol
   ] => 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:)
+    @name             = name
+    @artifacts        = artifacts
+    @registries       = registries
+    @env_files        = env_files
+    @templates        = templates
+    @kubeconfig_path  = kubeconfig_path
+    @deploy_strategy  = deploy_strategy
   end
 end

data/lib/kuber_kit/core/configuration_definition.rb

@@ -14,12 +14,13 @@ class KuberKit::Core::ConfigurationDefinition
 
   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
     )
   end
 
@@ -59,8 +60,14 @@ 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

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,13 @@ 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
     )
   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,4 +1,6 @@
 class KuberKit::Core::ContextHelper::BaseHelper
+  CONTRACT = RespondTo[:get_binding]
+
   attr_reader :shell, :artifact_store, :image_store
 
   def initialize(image_store:, artifact_store:, shell:)

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

@@ -13,7 +13,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

@@ -11,7 +11,9 @@ class KuberKit::Core::ServiceFactory
     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:     service_attrs.attributes || {}
     )
   end
 end

data/lib/kuber_kit/core/service_store.rb

@@ -5,7 +5,8 @@ class KuberKit::Core::ServiceStore
   include KuberKit::Import[
     "core.service_factory",
     "core.service_definition_factory",
-    "shell.local_shell"
+    "shell.local_shell",
+    "tools.logger"
   ]
 
   def define(service_name)
@@ -24,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 ||= {}
 
@@ -34,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)
 
@@ -44,6 +47,9 @@ class KuberKit::Core::ServiceStore
     files = local_shell.recursive_list_files(dir_path, name: "*.rb").each do |path|
       load_definition(path)
     end
+  rescue KuberKit::Shell::AbstractShell::DirNotFoundError
+    logger.warn("Directory with services not found: #{dir_path}")
+    []
   end
 
   def load_definition(file_path)

data/lib/kuber_kit/image_compiler/compiler.rb

@@ -15,7 +15,7 @@ class KuberKit::ImageCompiler::Compiler
     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/service_deployer/deployer.rb

@@ -0,0 +1,15 @@
+class KuberKit::ServiceDeployer::Deployer
+  include KuberKit::Import[
+    "service_deployer.service_restarter",
+    "core.service_store",
+  ]
+
+  Contract KuberKit::Shell::AbstractShell, Symbol => Any
+  def deploy(shell, service_name)
+    service = service_store.get_service(service_name)
+
+    strategy_name = KuberKit.current_configuration.deploy_strategy
+
+    service_restarter.restart(shell, service, strategy_name)
+  end
+end

data/lib/kuber_kit/service_deployer/service_reader.rb

@@ -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/service_deployer/service_restarter.rb

@@ -0,0 +1,37 @@
+class KuberKit::ServiceDeployer::ServiceRestarter
+  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 restart(shell, service, strategy_name)
+    add_default_strategies
+
+    restarter = @@strategies[strategy_name]
+
+    raise StrategyNotFoundError, "Can't find strategy with name #{strategy_name}" if restarter.nil?
+
+    restarter.restart(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 restart(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_deployer.service_reader",
+    "shell.kubectl_commands",
+    "configs",
+  ]
+
+  Contract KuberKit::Shell::AbstractShell, KuberKit::Core::Service => Any
+  def restart(shell, service)
+    service_config = service_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/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.0"
+  VERSION = "0.1.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kuber_kit
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.5
 platform: ruby
 authors:
 - Iskander Khaziev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-30 00:00:00.000000000 Z
+date: 2020-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: contracts-lite
@@ -162,15 +162,15 @@ files:
 - example/infrastructure/artifacts.rb
 - example/infrastructure/env_files.rb
 - example/infrastructure/registries.rb
-- example/infrastructure/services.rb
 - example/infrastructure/templates.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
@@ -227,8 +227,12 @@ 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/deployer.rb
 - lib/kuber_kit/service_deployer/service_list_resolver.rb
 - lib/kuber_kit/service_deployer/service_reader.rb
+- lib/kuber_kit/service_deployer/service_restarter.rb
+- lib/kuber_kit/service_deployer/strategies/abstract.rb
+- lib/kuber_kit/service_deployer/strategies/kubernetes.rb
 - lib/kuber_kit/shell/abstract_shell.rb
 - lib/kuber_kit/shell/bash_commands.rb
 - lib/kuber_kit/shell/command_counter.rb

data/example/infrastructure/services.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