kuber_kit 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 339883bd875277f494fdef1fe01035920e6a867ea98394e10c4d08e5a8b5a108
-  data.tar.gz: 96448b7bb059d60e55ec0b8bceb70e1a02b8740773dcdbc4944afa3fafda3192
+  metadata.gz: ae284766e125c54579032cd54c29d602848f95a9a91e07c357ab1b985632a9d1
+  data.tar.gz: 9a9c7a194893cdc39c7629fbda8e03bb7da6b77583899995c14a511f3b152943
 SHA512:
-  metadata.gz: 49b5bf9c115c06ab88f67b60bc54f55b254a3a1a4de58ebe0fa834c04b352d8e759ed66747bd98e1d62a8adbb794cbda948dbd324c06165113af29d28ce02aad
-  data.tar.gz: 77354cf127ad50ff4f5f092aeaebfdb7568030ea8120e990dc01eb109a9ca679da83f1124cd5df225d37053ce2abe84d4e9016c0d284b47a323a4d175ba28b40
+  metadata.gz: 3cbef254939ce54ff789fcde11ca3db500bfc552f75768bb9424dbdef682830eceed216b046f5930b95e45c8985c2b77e6ce2947e277951e718b1f38df62af29
+  data.tar.gz: bb571f10d8f4e41612c31e1616138e45a54134b92b4b8f9a9577083fc175982e3e5f1a77f1ec564a160ce88f46f76d57d143a8968b8282c92d66f4cb2e2f4220

data/Gemfile.lock

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

data/lib/kuber_kit.rb

@@ -146,9 +146,9 @@ module KuberKit
 
     module Strategies
       autoload :Abstract, 'service_deployer/strategies/abstract'
+      autoload :Docker, 'service_deployer/strategies/docker'
       autoload :DockerCompose, 'service_deployer/strategies/docker_compose'
       autoload :Kubernetes, 'service_deployer/strategies/kubernetes'
-      autoload :KubernetesRunner, 'service_deployer/strategies/kubernetes_runner'
     end
   end
 

data/lib/kuber_kit/container.rb

@@ -233,8 +233,8 @@ class KuberKit::Container
     KuberKit::ServiceDeployer::Strategies::Kubernetes.new
   end
 
-  register "service_deployer.strategies.kubernetes_runner" do
-    KuberKit::ServiceDeployer::Strategies::KubernetesRunner.new
+  register "service_deployer.strategies.docker" do
+    KuberKit::ServiceDeployer::Strategies::Docker.new
   end
 
   register "service_deployer.strategies.docker_compose" do

data/lib/kuber_kit/service_deployer/deployer.rb

@@ -4,7 +4,7 @@ class KuberKit::ServiceDeployer::Deployer
   include KuberKit::Import[
     "core.service_store",
     "service_deployer.strategies.kubernetes",
-    "service_deployer.strategies.kubernetes_runner",
+    "service_deployer.strategies.docker",
     "service_deployer.strategies.docker_compose"
   ]
 
@@ -39,7 +39,7 @@ class KuberKit::ServiceDeployer::Deployer
   private
     def add_default_strategies
       register_strategy(:kubernetes, kubernetes)
-      register_strategy(:kubernetes_runner, kubernetes_runner)
+      register_strategy(:docker, docker)
       register_strategy(:docker_compose, docker_compose)
     end
 end

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

@@ -0,0 +1,41 @@
+class KuberKit::ServiceDeployer::Strategies::Docker < KuberKit::ServiceDeployer::Strategies::Abstract
+  include KuberKit::Import[
+    "shell.docker_commands",
+    "core.image_store",
+    "configs",
+  ]
+
+  STRATEGY_OPTIONS = [
+    :container_name,
+    :image_name,
+    :docker_run_args,
+    :docker_run_command,
+    :delete_if_exists
+  ]
+
+  Contract KuberKit::Shell::AbstractShell, KuberKit::Core::Service => Any
+  def deploy(shell, service)
+    strategy_options = service.attribute(:deployer, default: {})
+    unknown_options  = strategy_options.keys.map(&:to_sym) - STRATEGY_OPTIONS
+    if unknown_options.any?
+      raise KuberKit::Error, "Unknow options for deploy strategy: #{unknown_options}. Available options: #{STRATEGY_OPTIONS}"
+    end
+    
+    container_name    = strategy_options.fetch(:container_name, service.uri)
+    docker_run_args   = strategy_options.fetch(:docker_run_args, nil)
+    docker_run_command = strategy_options.fetch(:docker_run_command, nil)
+
+    image_name = strategy_options.fetch(:image_name, nil)
+    if image_name.nil?
+      raise KuberKit::Error, "image_name is mandatory attribute for this deploy strategy"
+    end
+    image = image_store.get_image(image_name.to_sym)
+
+    delete_enabled = strategy_options.fetch(:delete_if_exists, false)
+    if delete_enabled && docker_commands.container_exists?(shell, container_name)
+      docker_commands.delete_container(shell, container_name)
+    end
+
+    docker_commands.run(shell, image.remote_registry_url, run_args: docker_run_args, run_command: docker_run_command)
+  end
+end

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

@@ -5,20 +5,29 @@ class KuberKit::ServiceDeployer::Strategies::DockerCompose < KuberKit::ServiceDe
     "configs",
   ]
 
+  STRATEGY_OPTIONS = [
+    :service_name, 
+    :command_name
+  ]
+
   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)
 
-    deployer_service_name = service.attribute(:deployer_service_name, default: service.name.to_s)
-    deployer_command_name = service.attribute(:deployer_command_name, default: "bash")
-    deployer_interactive  = service.attribute(:deployer_interactive, default: false)
+    strategy_options = service.attribute(:deployer, default: {})
+    unknown_options  = strategy_options.keys.map(&:to_sym) - STRATEGY_OPTIONS
+    if unknown_options.any?
+      raise KuberKit::Error, "Unknow options for deploy strategy: #{unknown_options}. Available options: #{STRATEGY_OPTIONS}"
+    end
+
+    service_name = strategy_options.fetch(:service_name, service.name.to_s)
+    command_name = strategy_options.fetch(:command_name, "bash")
 
     docker_compose_commands.run(shell, config_path, 
-      service:      deployer_service_name, 
-      command:      deployer_command_name,
-      interactive:  deployer_interactive
+      service:      service_name, 
+      command:      command_name,
     )
   end
 end

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

@@ -5,21 +5,48 @@ class KuberKit::ServiceDeployer::Strategies::Kubernetes < KuberKit::ServiceDeplo
     "configs",
   ]
 
+  STRATEGY_OPTIONS = [
+    :resource_type,
+    :resource_name,
+    :delete_if_exists,
+    :restart_if_exists
+  ]
+
   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
-    deployer_namespace = KuberKit.current_configuration.deployer_namespace
+    kubeconfig_path = KuberKit.current_configuration.kubeconfig_path
+    namespace       = KuberKit.current_configuration.deployer_namespace
+
+    strategy_options = service.attribute(:deployer, default: {})
+    unknown_options  = strategy_options.keys.map(&:to_sym) - STRATEGY_OPTIONS
+    if unknown_options.any?
+      raise KuberKit::Error, "Unknow options for deploy strategy: #{unknown_options}. Available options: #{STRATEGY_OPTIONS}"
+    end
+    
+    resource_type = strategy_options.fetch(:resource_type, "deployment")
+    resource_name = strategy_options.fetch(:resource_name, service.uri)
+    
+    resource_exists = kubectl_commands.resource_exists?(
+      shell, resource_type, resource_name, kubeconfig_path: kubeconfig_path, namespace: namespace
+    )
+
+    delete_enabled = strategy_options.fetch(:delete_if_exists, false)
+    if delete_enabled && resource_exists
+      kubectl_commands.delete_resource(shell, resource_type, resource_name, kubeconfig_path: kubeconfig_path, namespace: namespace)
+    end
 
-    kubectl_commands.apply_file(shell, config_path, kubeconfig_path: kubeconfig_path, namespace: deployer_namespace)
+    kubectl_commands.apply_file(shell, config_path, kubeconfig_path: kubeconfig_path, namespace: namespace)
 
-    deployer_restart_enabled = service.attribute(:deployer_restart_enabled, default: true)
-    deployer_restart_name    = service.attribute(:deployer_restart_name, default: service.uri)
-    if deployer_restart_enabled
-      kubectl_commands.rolling_restart(shell, deployer_restart_name, kubeconfig_path: kubeconfig_path, namespace: deployer_namespace)
+    restart_enabled = strategy_options.fetch(:restart_if_exists, true)
+    if restart_enabled && resource_exists
+      kubectl_commands.rolling_restart(
+        shell, resource_type, resource_name, 
+        kubeconfig_path: kubeconfig_path, namespace: namespace
+      )
     end
   end
 end

data/lib/kuber_kit/shell/commands/docker_commands.rb

@@ -14,6 +14,25 @@ class KuberKit::Shell::Commands::DockerCommands
     shell.exec!(%Q{docker push #{tag_name}})
   end
 
+  def run(shell, image_name, run_args: nil, run_command: nil)
+    command_parts = []
+    command_parts << "docker run"
+    command_parts << run_args if run_args
+    command_parts << image_name
+    command_parts << run_command if run_command
+
+    shell.exec!(command_parts.join(" "))
+  end
+
+  def container_exists?(shell, container_name)
+    result = get_container_id(shell, container_name)
+    result && result != ""
+  end
+
+  def delete_container(shell, container_name)
+    shell.exec!(%Q{docker rm -f #{container_name}})
+  end
+
   def get_container_id(shell, container_name, only_healthy: false, status: "running")
     command_parts = []
     command_parts << "docker ps -a -q"

data/lib/kuber_kit/shell/commands/kubectl_commands.rb

@@ -57,8 +57,16 @@ class KuberKit::Shell::Commands::KubectlCommands
     kubectl_run(shell, command, kubeconfig_path: kubeconfig_path, namespace: namespace)
   end
 
-  def rolling_restart(shell, deployer_name, kubeconfig_path: nil, namespace: nil)
-    patch_deployment(shell, deployer_name, {
+  def patch_resource(shell, resource_type, resource_name, specs, kubeconfig_path: nil, namespace: nil)
+    specs_json = JSON.dump(specs).gsub('"', '\"')
+
+    command = %Q{patch #{resource_type} #{resource_name} -p "#{specs_json}"}
+
+    kubectl_run(shell, command, kubeconfig_path: kubeconfig_path, namespace: namespace)
+  end
+
+  def rolling_restart(shell, resource_type, resource_name, kubeconfig_path: nil, namespace: nil)
+    patch_resource(shell, resource_type, resource_name, {
       spec: {
         template: {
           metadata: {
@@ -70,12 +78,4 @@ class KuberKit::Shell::Commands::KubectlCommands
       }
     }, kubeconfig_path: kubeconfig_path, namespace: namespace)
   end
-
-  def patch_deployment(shell, deployer_name, specs, kubeconfig_path: nil, namespace: nil)
-    specs_json = JSON.dump(specs).gsub('"', '\"')
-
-    command = %Q{patch deployment #{deployer_name} -p "#{specs_json}"}
-
-    kubectl_run(shell, command, kubeconfig_path: kubeconfig_path, namespace: namespace)
-  end
 end

data/lib/kuber_kit/version.rb

@@ -1,3 +1,3 @@
 module KuberKit
-  VERSION = "0.3.2"
+  VERSION = "0.3.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kuber_kit
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
 - Iskander Khaziev
@@ -140,8 +140,8 @@ description: Docker Containers Build & Deployment
 email:
 - gvalmon@gmail.com
 executables:
-- console
 - kit
+- kit_console
 extensions: []
 extra_rdoc_files: []
 files:
@@ -156,8 +156,8 @@ files:
 - README.md
 - Rakefile
 - TODO.md
-- bin/console
 - bin/kit
+- bin/kit_console
 - example/app_data/docker_compose.yml
 - example/app_data/env_file.yml
 - example/app_data/service.yml
@@ -260,9 +260,9 @@ files:
 - lib/kuber_kit/service_deployer/deployer.rb
 - lib/kuber_kit/service_deployer/service_list_resolver.rb
 - lib/kuber_kit/service_deployer/strategies/abstract.rb
+- lib/kuber_kit/service_deployer/strategies/docker.rb
 - lib/kuber_kit/service_deployer/strategies/docker_compose.rb
 - lib/kuber_kit/service_deployer/strategies/kubernetes.rb
-- lib/kuber_kit/service_deployer/strategies/kubernetes_runner.rb
 - lib/kuber_kit/service_deployer/strategy_detector.rb
 - lib/kuber_kit/service_reader/action_handler.rb
 - lib/kuber_kit/service_reader/reader.rb

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

@@ -1,35 +0,0 @@
-class KuberKit::ServiceDeployer::Strategies::KubernetesRunner < 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
-    deployer_namespace = KuberKit.current_configuration.deployer_namespace
-
-    deployer_resource_name  = service.attribute(:deployer_resource_name, default: service.uri)
-    deployer_resource_type  = service.attribute(:deployer_resource_type, default: "job")
-
-    deployer_delete_enabled = service.attribute(:deployer_delete_enabled, default: true)
-    if deployer_delete_enabled
-      delete_resource_if_exists(shell, deployer_resource_type, deployer_resource_name, kubeconfig_path: kubeconfig_path, namespace: deployer_namespace)
-    end
-
-    kubectl_commands.apply_file(shell, config_path, kubeconfig_path: kubeconfig_path, namespace: deployer_namespace)
-  end
-
-  private
-    def delete_resource_if_exists(shell, resource_type, resource_name, kubeconfig_path:, namespace: )
-      unless kubectl_commands.resource_exists?(shell, resource_type, resource_name, kubeconfig_path: kubeconfig_path, namespace: namespace)
-        return false
-      end
-      kubectl_commands.delete_resource(shell, resource_type, resource_name, kubeconfig_path: kubeconfig_path, namespace: namespace)
-    end
-end