kuber_kit 1.1.4 → 1.1.6

data/lib/kuber_kit/core/configuration.rb

@@ -1,9 +1,9 @@
 class KuberKit::Core::Configuration
   attr_reader :name, :artifacts, :registries, :env_files, :templates, :kubeconfig_path, :kubectl_entrypoint,
               :services_attributes, :enabled_services, :disabled_services, :default_services,
-              :initial_services, :build_servers, :global_build_vars,
+              :pre_deploy_services, :post_deploy_services, :build_servers, :global_build_vars,
               :deployer_strategy, :deployer_namespace, :deployer_require_confirmation,
-              :shell_launcher_strategy
+              :shell_launcher_strategy, :generator_strategy
 
   Contract KeywordArgs[
     name:                 Symbol,
@@ -17,18 +17,20 @@ class KuberKit::Core::Configuration
     enabled_services:     ArrayOf[Symbol],
     disabled_services:    ArrayOf[Symbol],
     default_services:     ArrayOf[Symbol],
-    initial_services:     ArrayOf[Symbol],
+    pre_deploy_services:  ArrayOf[Symbol],
+    post_deploy_services: ArrayOf[Symbol],
     build_servers:        ArrayOf[KuberKit::Core::BuildServers::AbstractBuildServer],
     global_build_vars:    HashOf[Symbol => Any],
     deployer_strategy:              Symbol,
     deployer_namespace:             Maybe[Or[Symbol, String]],
     deployer_require_confirmation:  Bool,
     shell_launcher_strategy:        Symbol,
+    generator_strategy:             Symbol,
   ] => Any
   def initialize(name:, artifacts:, registries:, env_files:, templates:, kubeconfig_path:, kubectl_entrypoint:,
                  services_attributes:, enabled_services:, disabled_services:, default_services:, 
-                 initial_services:, build_servers:, global_build_vars:,
-                 deployer_strategy:, deployer_namespace:, deployer_require_confirmation:, shell_launcher_strategy:)
+                 pre_deploy_services:, post_deploy_services:, build_servers:, global_build_vars:,
+                 deployer_strategy:, deployer_namespace:, deployer_require_confirmation:, shell_launcher_strategy:, generator_strategy:)
     @name                 = name
     @artifacts            = artifacts
     @registries           = registries
@@ -41,12 +43,14 @@ class KuberKit::Core::Configuration
     @enabled_services     = enabled_services
     @disabled_services    = disabled_services
     @default_services     = default_services
-    @initial_services     = initial_services
+    @pre_deploy_services  = pre_deploy_services
+    @post_deploy_services = post_deploy_services
     @global_build_vars    = global_build_vars
     @deployer_strategy              = deployer_strategy
     @deployer_namespace             = deployer_namespace
     @deployer_require_confirmation  = deployer_require_confirmation
     @shell_launcher_strategy        = shell_launcher_strategy
+    @generator_strategy             = generator_strategy
   end
 
   def service_attributes(service_name)

data/lib/kuber_kit/core/configuration_definition.rb

@@ -9,13 +9,14 @@ class KuberKit::Core::ConfigurationDefinition
     @artifacts  = {}
     @registries = {}
     @env_files  = {}
-    @templates  = {}
-    @build_servers      = []
-    @enabled_services   = []
-    @disabled_services  = []
-    @default_services   = []
-    @initial_services   = []
-    @services_attributes = {}
+    @templates  = {} 
+    @build_servers        = []
+    @enabled_services     = []
+    @disabled_services    = []
+    @default_services     = []
+    @pre_deploy_services  = []
+    @post_deploy_services = []
+    @services_attributes  = {}
   end
 
   def to_attrs
@@ -30,7 +31,8 @@ class KuberKit::Core::ConfigurationDefinition
       enabled_services:     @enabled_services,
       disabled_services:    @disabled_services,
       default_services:     @default_services,
-      initial_services:     @initial_services,
+      pre_deploy_services:  @pre_deploy_services,
+      post_deploy_services: @post_deploy_services,
       build_servers:        @build_servers,
       services_attributes:  @services_attributes,
       global_build_vars:    @global_build_vars,
@@ -38,6 +40,7 @@ class KuberKit::Core::ConfigurationDefinition
       deployer_namespace:             @deployer_namespace,
       deployer_require_confirmation:  @deployer_require_confirmation || false,
       shell_launcher_strategy:        @shell_launcher_strategy,
+      generator_strategy:             @generator_strategy,
     )
   end
 
@@ -109,6 +112,12 @@ class KuberKit::Core::ConfigurationDefinition
     self
   end
 
+  def generator_strategy(strategy)
+    @generator_strategy = strategy
+
+    self
+  end
+
   def deployer_require_confirmation
     @deployer_require_confirmation = true
 
@@ -143,7 +152,19 @@ class KuberKit::Core::ConfigurationDefinition
   end
 
   def initial_services(services)
-    @initial_services += services.map(&:to_sym)
+    unless KuberKit.deprecation_warnings_disabled?
+      puts "WARNING: initial_services is deprecated, please use pre_deploy_services instead"
+    end
+    pre_deploy_services(services)
+  end
+
+  def pre_deploy_services(services)
+    @pre_deploy_services += services.map(&:to_sym)
+    return self
+  end
+
+  def post_deploy_services(services)
+    @post_deploy_services += services.map(&:to_sym)
     return self
   end
 

data/lib/kuber_kit/core/configuration_factory.rb

@@ -32,12 +32,14 @@ class KuberKit::Core::ConfigurationFactory
       enabled_services:     configuration_attrs.enabled_services,
       disabled_services:    configuration_attrs.disabled_services,
       default_services:     configuration_attrs.default_services,
-      initial_services:     configuration_attrs.initial_services,
+      pre_deploy_services:  configuration_attrs.pre_deploy_services,
+      post_deploy_services: configuration_attrs.post_deploy_services,
       global_build_vars:    configuration_attrs.global_build_vars || {},
       deployer_strategy:              configuration_attrs.deployer_strategy || configs.deployer_strategy,
       deployer_namespace:             configuration_attrs.deployer_namespace,
       deployer_require_confirmation:  configuration_attrs.deployer_require_confirmation,
       shell_launcher_strategy:        configuration_attrs.shell_launcher_strategy || configs.shell_launcher_strategy,
+      generator_strategy:             configuration_attrs.generator_strategy || configs.generator_strategy,
     )
   end
 

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

@@ -0,0 +1,5 @@
+class KuberKit::Core::ContextHelper::AbstractHelper
+  def get_binding
+    binding
+  end
+end

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

@@ -1,6 +1,4 @@
-class KuberKit::Core::ContextHelper::BaseHelper
-  CONTRACT = RespondTo[:get_binding]
-
+class KuberKit::Core::ContextHelper::BaseHelper < KuberKit::Core::ContextHelper::AbstractHelper
   attr_reader :shell, :artifact_store, :image_store, :env_file_reader
 
   def initialize(image_store:, artifact_store:, shell:, env_file_reader:)
@@ -39,8 +37,4 @@ class KuberKit::Core::ContextHelper::BaseHelper
     end
     global_build_vars
   end
-
-  def get_binding
-    binding
-  end
 end

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

@@ -2,7 +2,8 @@ class KuberKit::Core::ContextHelper::ContextHelperFactory
   include KuberKit::Import[
     "core.image_store",
     "core.artifact_store",
-    env_file_reader: "env_file_reader.action_handler"
+    template_renderer: "template_reader.renderer",
+    env_file_reader:   "env_file_reader.action_handler"
   ]
 
   def build_image_context(shell, image)
@@ -22,6 +23,7 @@ class KuberKit::Core::ContextHelper::ContextHelperFactory
       shell:            shell,
       env_file_reader:  env_file_reader,
       service:          service,
+      template_renderer: template_renderer
     )
   end
 end

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

@@ -1,3 +1,4 @@
+require 'ostruct'
 class KuberKit::Core::ContextHelper::ContextVars
   attr_reader :parent, :parent_name
 
@@ -37,12 +38,27 @@ class KuberKit::Core::ContextHelper::ContextVars
     dig(name)
   end
 
+  def keys
+    @context_vars.keys
+  end
+
   def to_h
-    if @context_vars.is_a?(Hash)
-      return @context_vars
-    else
-      return {value: @context_vars}
+    values = keys.map do |key|
+      value = get_variable_value(key)
+      hash_value = value.respond_to?(:to_h) ? value.to_h : value
+      [key, hash_value]
+    end
+    Hash[values]
+  end
+
+  def to_struct
+    values = keys.map do |key|
+      value = get_variable_value(key)
+      hash_value = value.respond_to?(:to_struct) ? value.to_struct : value
+      [key, hash_value]
     end
+    hash = Hash[values]
+    OpenStruct.new(hash)
   end
 
   def get_variable_value(variable_name)

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

@@ -0,0 +1,14 @@
+class KuberKit::Core::ContextHelper::LocalContextHelper < KuberKit::Core::ContextHelper::AbstractHelper
+  def initialize(parent_context_helper:, variables:)
+    @parent_context_helper = parent_context_helper
+    @variables = variables
+  end
+
+  def method_missing(method_name, *args, &block)
+    if @variables.has_key?(method_name)
+      @variables[method_name]
+    else
+      @parent_context_helper.send(method_name, *args, &block)
+    end
+  end
+end

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

@@ -1,5 +1,5 @@
 class KuberKit::Core::ContextHelper::ServiceHelper < KuberKit::Core::ContextHelper::BaseHelper
-  def initialize(image_store:, artifact_store:, shell:, env_file_reader:, service:)
+  def initialize(image_store:, artifact_store:, shell:, env_file_reader:, service:, template_renderer:)
     super(
       image_store:      image_store, 
       artifact_store:   artifact_store, 
@@ -7,6 +7,7 @@ class KuberKit::Core::ContextHelper::ServiceHelper < KuberKit::Core::ContextHelp
       env_file_reader:  env_file_reader
     )
     @service = service
+    @template_renderer = template_renderer
   end
 
   def service_name
@@ -20,4 +21,17 @@ class KuberKit::Core::ContextHelper::ServiceHelper < KuberKit::Core::ContextHelp
   def attribute(attribute_name, default: nil)
     @service.attribute(attribute_name, default: default)
   end
+
+  Contract Maybe[String, Symbol], Hash => String
+  def render(template_name, variables = {})
+    context_helper = KuberKit::Core::ContextHelper::LocalContextHelper.new(
+      parent_context_helper: self,
+      variables: variables
+    )
+    @template_renderer.call(shell, template_name.to_sym, context_helper: context_helper)
+  end
+
+  def method_missing(m, *args, &block)
+    raise("Unknown variable: #{m} while rendering '#{service_name}' with '#{@service.template_name}' template.")
+  end
 end

data/lib/kuber_kit/core/dependencies/abstract_dependency_resolver.rb

@@ -50,6 +50,13 @@ class KuberKit::Core::Dependencies::AbstractDependencyResolver
     (deps + item_names).uniq
   end
 
+  # Get all dependencies for items (excluding the items themself), without any limitations
+  Contract Or[Symbol, ArrayOf[Symbol]] => Any
+  def get_all_deps(item_names)
+    deps = Array(item_names).map { |i| get_recursive_deps(i) }.flatten
+    deps.uniq - item_names
+  end
+
   def get_recursive_deps(item_name, dependency_tree: [])
     deps = get_deps(item_name)
 

data/lib/kuber_kit/core/service.rb

@@ -1,25 +1,28 @@
 class KuberKit::Core::Service
   AttributeNotSet = Class.new(KuberKit::Error)
 
-  attr_reader :name, :dependencies, :template_name, :tags, :images, :attributes, :deployer_strategy
+  attr_reader :name, :initializers, :template_name, :tags, :images, :attributes, 
+              :deployer_strategy, :generator_strategy
 
   Contract KeywordArgs[
     name:               Symbol,
-    dependencies:       ArrayOf[Symbol],
+    initializers:       ArrayOf[Symbol],
     template_name:      Maybe[Symbol],
     tags:               ArrayOf[Symbol],
     images:             ArrayOf[Symbol],
     attributes:         HashOf[Symbol => Any],
-    deployer_strategy:  Maybe[Symbol]
+    deployer_strategy:  Maybe[Symbol],
+    generator_strategy: Maybe[Symbol]
   ] => Any
-  def initialize(name:, dependencies:, template_name:, tags:, images:, attributes:, deployer_strategy:)
+  def initialize(name:, initializers:, template_name:, tags:, images:, attributes:, deployer_strategy:, generator_strategy:)
     @name = name
-    @dependencies = dependencies
+    @initializers = initializers
     @template_name = template_name
     @tags = tags
     @images = images
     @attributes = attributes
     @deployer_strategy = deployer_strategy
+    @generator_strategy = generator_strategy
   end
 
   def uri

data/lib/kuber_kit/core/service_definition.rb

@@ -1,26 +1,32 @@
 class KuberKit::Core::ServiceDefinition
-  attr_reader :service_name, :template_name, :dependencies
+  attr_reader :service_name, :template_name, :dependencies, :initializers
   
   Contract Or[Symbol, String] => Any
   def initialize(service_name)
     @service_name = service_name.to_sym
-    @dependencies = []
+    @initializers = []
   end
 
   def to_service_attrs
     OpenStruct.new(
       name:               @service_name,
-      dependencies:       @dependencies,
+      initializers:       @initializers,
       template_name:      get_value(@template_name),
       tags:               Array(get_value(@tags)).map(&:to_sym),
       images:             Array(get_value(@images)).map(&:to_sym),
       attributes:         get_value(@attributes),
       deployer_strategy:  get_value(@deployer_strategy),
+      generator_strategy: get_value(@generator_strategy),
     )
   end
 
   def depends_on(*value, &block)
-    @dependencies = Array(value).flatten
+    initialize_with(value)
+    self
+  end
+
+  def initialize_with(*value, &block)
+    @initializers = Array(value).flatten
     self
   end
 
@@ -54,6 +60,12 @@ class KuberKit::Core::ServiceDefinition
     self
   end
 
+  def generator_strategy(value = nil, &block)
+    @generator_strategy = 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

@@ -7,12 +7,13 @@ class KuberKit::Core::ServiceFactory
 
     KuberKit::Core::Service.new(
       name:               service_attrs.name,
-      dependencies:       service_attrs.dependencies,
+      initializers:       service_attrs.initializers,
       template_name:      service_attrs.template_name,
       tags:               service_attrs.tags,
       images:             service_attrs.images,
       attributes:         attributes,
       deployer_strategy:  service_attrs.deployer_strategy,
+      generator_strategy: service_attrs.generator_strategy,
     )
   end
 end

data/lib/kuber_kit/defaults.rb

@@ -7,12 +7,12 @@ class KuberKit::Defaults
     end
 
     def init!
-      container["artifacts_sync.artifact_updater"].use_resolver(
-        container["artifacts_sync.git_artifact_resolver"], 
+      container["artifacts_sync.artifact_updater"].use_strategy(
+        container["artifacts_sync.strategies.git_updater"], 
         artifact_class: KuberKit::Core::Artifacts::Git
       )
-      container["artifacts_sync.artifact_updater"].use_resolver(
-        container["artifacts_sync.null_artifact_resolver"], 
+      container["artifacts_sync.artifact_updater"].use_strategy(
+        container["artifacts_sync.strategies.null_updater"], 
         artifact_class: KuberKit::Core::Artifacts::Local
       )
       container["env_file_reader.reader"].use_reader(
@@ -39,6 +39,15 @@ class KuberKit::Defaults
         :docker_compose,
         KuberKit::ServiceDeployer::Strategies::DockerCompose.new
       )
+      container["service_deployer.deployer"].register_strategy(
+        :helm,
+        KuberKit::ServiceDeployer::Strategies::Helm.new
+      )
+
+      container["service_generator.generator"].register_strategy(
+        :helm,
+        KuberKit::ServiceGenerator::Strategies::Helm.new
+      )
 
       container["shell_launcher.launcher"].register_strategy(
         :kubernetes,

data/lib/kuber_kit/image_compiler/image_builder.rb

@@ -5,7 +5,7 @@ class KuberKit::ImageCompiler::ImageBuilder
   ]
 
   Contract KuberKit::Shell::AbstractShell, KuberKit::Core::Image, String, KeywordArgs[
-    context_helper: Maybe[KuberKit::Core::ContextHelper::BaseHelper::CONTRACT]
+    context_helper: Maybe[KuberKit::Core::ContextHelper::AbstractHelper]
   ] => Any
   def build(shell, image, build_dir, context_helper: nil)
     image.before_build_callback.call(context_helper, build_dir) if image.before_build_callback

data/lib/kuber_kit/service_deployer/service_dependency_resolver.rb

@@ -5,7 +5,7 @@ class KuberKit::ServiceDeployer::ServiceDependencyResolver < KuberKit::Core::Dep
   ]
   
   def get_deps(service_name)
-    service_store.get_definition(service_name).dependencies
+    service_store.get_definition(service_name).initializers
   end
 
   def dependency_batch_size

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

@@ -0,0 +1,41 @@
+class KuberKit::ServiceDeployer::Strategies::Helm < KuberKit::ServiceDeployer::Strategies::Abstract
+  include KuberKit::Import[
+    "service_reader.reader",
+    "shell.helm_commands",
+    "shell.bash_commands",
+    "configs",
+  ]
+
+  Contract KuberKit::Shell::AbstractShell, KuberKit::Core::Service => Any
+  def deploy(shell, service)
+    service_config        = reader.read(shell, service)
+    chart_root_path       = File.join(configs.service_config_dir, "#{service.name}_chart")
+    chart_templates_path  = File.join(chart_root_path, "templates")
+    chart_config_path = File.join(chart_root_path, "Chart.yaml")
+    release_path      = File.join(chart_templates_path, "release.yaml")
+
+    bash_commands.mkdir_p(shell, chart_root_path)
+    bash_commands.mkdir_p(shell, chart_templates_path)
+
+    shell.write(release_path, service_config)
+    shell.write(chart_config_path, chart_config_content(service.uri))
+
+    kubeconfig_path = KuberKit.current_configuration.kubeconfig_path
+    namespace       = KuberKit.current_configuration.deployer_namespace
+
+    upgrade_result = helm_commands.upgrade(shell, service.uri, chart_root_path, kubeconfig_path: kubeconfig_path, namespace: namespace)
+    
+    upgrade_result
+  end
+
+  def chart_config_content(release_name)
+    query = <<-CHART
+apiVersion: v2
+name: #{release_name}
+description: #{release_name}
+type: application
+version: 1.0.0
+appVersion: "1.0.0"
+    CHART
+  end
+end

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

@@ -10,7 +10,8 @@ class KuberKit::ServiceDeployer::Strategies::Kubernetes < KuberKit::ServiceDeplo
     :resource_name,
     :delete_if_exists,
     :restart_if_exists,
-    :wait_for_rollout
+    :wait_for_rollout,
+    :apply_command
   ]
 
   Contract KuberKit::Shell::AbstractShell, KuberKit::Core::Service => Any
@@ -40,7 +41,12 @@ class KuberKit::ServiceDeployer::Strategies::Kubernetes < KuberKit::ServiceDeplo
       kubectl_commands.delete_resource(shell, resource_type, resource_name, kubeconfig_path: kubeconfig_path, namespace: namespace)
     end
 
-    apply_result = kubectl_commands.apply_file(shell, config_path, kubeconfig_path: kubeconfig_path, namespace: namespace)
+    apply_result = kubectl_commands.apply_file(
+      shell, config_path, 
+      kubeconfig_path: kubeconfig_path, 
+      namespace: namespace,
+      apply_command: strategy_options.fetch(:apply_command, "apply")
+    )
 
     restart_enabled  = strategy_options.fetch(:restart_if_exists, true)
     wait_for_rollout = strategy_options.fetch(:wait_for_rollout, true)

data/lib/kuber_kit/service_generator/action_handler.rb

@@ -0,0 +1,16 @@
+class KuberKit::ServiceGenerator::ActionHandler
+  include KuberKit::Import[
+    "service_generator.generator",
+    "service_generator.strategy_detector",
+    "core.service_store",
+  ]
+
+  Contract KuberKit::Shell::AbstractShell, Symbol, String => Any
+  def call(shell, service_name, export_path)
+    service = service_store.get_service(service_name)
+
+    strategy_name = strategy_detector.call(service)
+
+    generator.generate(shell, service, export_path, strategy_name)
+  end
+end

data/lib/kuber_kit/service_generator/generator.rb

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

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

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

data/lib/kuber_kit/service_generator/strategies/helm.rb

@@ -0,0 +1,33 @@
+class KuberKit::ServiceGenerator::Strategies::Helm < KuberKit::ServiceGenerator::Strategies::Abstract
+  include KuberKit::Import[
+    "service_reader.reader",
+    "shell.bash_commands",
+    "configs",
+  ]
+
+  Contract KuberKit::Shell::AbstractShell, KuberKit::Core::Service, String => Any
+  def generate(shell, service, export_path)
+    service_config        = reader.read(shell, service)
+    chart_root_path       = File.join(export_path, "#{service.name}_chart")
+    chart_templates_path  = File.join(chart_root_path, "templates")
+    chart_config_path     = File.join(chart_root_path, "Chart.yaml")
+    release_path          = File.join(chart_templates_path, "release.yaml")
+
+    bash_commands.mkdir_p(shell, chart_root_path)
+    bash_commands.mkdir_p(shell, chart_templates_path)
+
+    shell.write(release_path, service_config)
+    shell.write(chart_config_path, chart_config_content(service.uri))
+  end
+
+  def chart_config_content(release_name)
+    query = <<-CHART
+apiVersion: v2
+name: #{release_name}
+description: #{release_name}
+type: application
+version: 1.0.0
+appVersion: "1.0.0"
+    CHART
+  end
+end

data/lib/kuber_kit/service_generator/strategy_detector.rb

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

data/lib/kuber_kit/service_reader/reader.rb

@@ -1,9 +1,7 @@
 class KuberKit::ServiceReader::Reader
   include KuberKit::Import[
-    "core.template_store",
     "core.context_helper_factory",
-    "template_reader.reader",
-    "preprocessing.text_preprocessor"
+    "template_reader.renderer"
   ]
 
   AttributeNotSetError = Class.new(KuberKit::Error)
@@ -14,14 +12,8 @@ class KuberKit::ServiceReader::Reader
       raise AttributeNotSetError, "Please set template for service using #template method"
     end
 
-    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
+    renderer.call(shell, service.template_name, context_helper: context_helper)
   end
 end

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

@@ -44,7 +44,7 @@ class KuberKit::Shell::Commands::DockerCommands
     if status
       command_parts << "--filter=\"status=#{status}\""
     end
-    command_parts << "--filter=\"name=#{container_name}\""
+    command_parts << "--filter=\"name=^/#{container_name}$\""
 
     shell.exec!(command_parts.join(" "))
   end

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

@@ -8,6 +8,15 @@ class KuberKit::Shell::Commands::GitCommands
     return nil
   end
 
+  def get_branch_name(shell, git_repo_path, remote_name: "origin")
+    shell.exec!([
+      "cd #{git_repo_path}",
+      "git rev-parse --abbrev-ref HEAD",
+    ].join(" && "), merge_stderr: true)
+  rescue KuberKit::Shell::AbstractShell::ShellError
+    return nil
+  end
+
   def get_version_hash(shell, git_repo_path)
     shell.exec!([
       "cd #{git_repo_path}",
@@ -28,6 +37,7 @@ class KuberKit::Shell::Commands::GitCommands
       "cd #{path}",
       "git add .",
       "git reset HEAD --hard",
+      "git fetch origin #{branch}",
       "git checkout #{branch}",
       "git reset --hard '@{u}'",
       "git pull --force",