kubernetes-cli 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44f3e261b827758d975c3e51c00f9319ac280c25592fd50d5980418de7fc4a46
-  data.tar.gz: ce69cc4e1c0a898e4baad326c14fd15baeebc18f39416157986a992a7e40596f
+  metadata.gz: b93bf8e3f620c17f2781d2eb5f2748f970982a854d0aa622d3313b1d74104d3b
+  data.tar.gz: 9c7d170e2ab873b66cfbf6a12532260e3442781330c9e96363e472d354ff997a
 SHA512:
-  metadata.gz: 73a7bff727ab4a7f5b42c3b1f1b4d6fd95d2176667978fe454b308c8fc78219eacfeb451ec2bffc50b42f6e8d7d895656ab282c888b48bb9aa0c3ded65fa945d
-  data.tar.gz: 931ebe19d76a237f4e357ec0cac817221a52ba96e53630bfd3f76c669096b50694a52dc27f70bcbc7404ece859249592b433169d795f21736970afa02c2dd3ea
+  metadata.gz: 0156747413340bab08b571bf13db212d0a8397ceb0b733fbc152c7835080f203400f6f1554829c74dab4fe1b743b3f3eda3d2e11950896f01da6b9bedf5bc3ca
+  data.tar.gz: c21786be60e403d60d2c39fd7be371a7043539412000e9cff2ea197e37092fe38a2bc621a6413266aabd0b8633656375056ce46745ac65726eb08c3e31cd14e3

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 0.4.0
+* Add `#version` method to get k8s client/server version info.
+* Add Sorbet type definitions.
+* Add tests.
+
+## 0.3.2
+* Add missing require statement.
+
+## 0.3.1
+* Fix issue restricting Docker CLI output.
+
 ## 0.3.0
 * Add ability to redirect kubectl's stdout and stderr streams.
 

data/Gemfile

@@ -6,10 +6,21 @@ gemspec
 # See: https://github.com/rubygems/rubygems/issues/3646
 gem 'kubectl-rb'
 
+group :test do
+  gem 'rspec'
+  gem 'kind-rb', '~> 0.1'
+  gem 'kube-dsl', '~> 0.6'
+end
+
 group :development do
-  gem 'rake'
+  gem 'curdle', '~> 1.0'
+
+  # lock to same version as kuby-core
+  gem 'sorbet', '= 0.5.6433'
+  gem 'parlour', '~> 6.0'
 end
 
-group :test do
-  gem 'rspec'
+group :development, :test do
+  gem 'pry-byebug'
+  gem 'rake'
 end

data/README.md

@@ -0,0 +1,49 @@
+## kubernetes-cli
+
+![Unit Tests](https://github.com/getkuby/kuby-core/actions/workflows/unit_tests.yml/badge.svg?branch=master)
+![Integration Tests](https://github.com/getkuby/kuby-core/actions/workflows/integration_tests.yml/badge.svg?branch=master)
+
+A Ruby wrapper around the Kubernetes CLI.
+
+### Usage
+
+Create a new instance by passing the path to your Kube config (usually ~/.kube/config) and optionally the path to the kubectl executable (by default, the executable path comes from the [kubectl-rb gem](https://github.com/getkuby/kubectl-rb)).
+
+```ruby
+cli = KubernetesCLI(File.join(ENV['HOME'], '.kube', 'config'))
+```
+
+### Available Methods
+
+- `annotate`
+- `api_resources`
+- `apply`
+- `apply_uri`
+- `current_context`
+- `delete_object`
+- `delete_objects`
+- `exec_cmd`
+- `executable`
+- `get_object`
+- `get_objects`
+- `kubeconfig_path`
+- `last_status`
+- `logtail`
+- `patch_object`
+- `restart_deployment`
+- `run_cmd`
+- `system_cmd`
+
+Please see the source code for available options.
+
+## Running Tests
+
+`bundle exec rspec` should do the trick. Requires that you have Docker installed.
+
+## License
+
+Licensed under the MIT license. See LICENSE for details.
+
+## Authors
+
+* Cameron C. Dutro: http://github.com/camertron

data/Rakefile

@@ -2,9 +2,11 @@ require 'bundler'
 require 'rspec/core/rake_task'
 require 'rubygems/package_task'
 
+require 'sorbet-runtime'
 require 'kubernetes-cli'
+require 'curdle'
 
-Bundler::GemHelper.install_tasks
+Curdle::Tasks.install
 
 task default: :spec
 

data/kubernetes-cli.gemspec

@@ -11,8 +11,8 @@ Gem::Specification.new do |s|
 
   s.description = s.summary = 'Ruby wrapper around the Kubernetes CLI.'
 
-  s.add_dependency 'kubectl-rb', '~> 0.1'
+  s.add_dependency 'kubectl-rb', '~> 0.2'
 
   s.require_path = 'lib'
-  s.files = Dir['{lib,spec,vendor}/**/*', 'Gemfile', 'LICENSE', 'CHANGELOG.md', 'README.md', 'Rakefile', 'kubernetes-cli.gemspec']
+  s.files = Dir['{lib,spec,rbi}/**/*', 'Gemfile', 'LICENSE', 'CHANGELOG.md', 'README.md', 'Rakefile', 'kubernetes-cli.gemspec']
 end

data/lib/kubernetes-cli/version.rb

@@ -1,3 +1,5 @@
+# typed: ignore
+
 class KubernetesCLI
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'.freeze
 end

data/lib/kubernetes-cli.rb

@@ -1,64 +1,161 @@
+# typed: strict
+
+require 'json'
 require 'kubectl-rb'
 require 'open3'
+require 'shellwords'
 require 'stringio'
 
 class KubernetesCLI
+  # extend T::Sig
+
   class KubernetesError < StandardError; end
 
   class InvalidResourceError < KubernetesError
-    attr_accessor :resource
+    # extend T::Sig
+
+    # T::Sig::WithoutRuntime.sig { returns(T.nilable(::KubeDSL::DSLObject)) }
+    attr_reader :resource
+
+    # T::Sig::WithoutRuntime.sig { params(resource: ::KubeDSL::DSLObject).returns(::KubeDSL::DSLObject) }
+    attr_writer :resource
+
+    # T::Sig::WithoutRuntime.sig { params(args: T.untyped).void }
+    def initialize(*args)
+      # @resource = T.let(@resource, T.nilable(::KubeDSL::DSLObject))
+      super
+    end
   end
 
   class InvalidResourceUriError < KubernetesError
-    attr_accessor :resource_uri
+    # extend T::Sig
+
+    # T::Sig::WithoutRuntime.sig { returns(T.nilable(String)) }
+    attr_reader :resource_uri
+
+    # T::Sig::WithoutRuntime.sig { params(resource_uri: String).returns(String) }
+    attr_writer :resource_uri
+
+    # T::Sig::WithoutRuntime.sig { params(args: T.untyped).void }
+    def initialize(*args)
+      # @resource_uri = T.let(@resource_uri, T.nilable(String))
+      super
+    end
   end
 
   class GetResourceError < KubernetesError; end
+  class DeleteResourceError < KubernetesError; end
+  class PatchResourceError < KubernetesError; end
+  class AnnotateResourceError < KubernetesError; end
+  class GetVersionError < KubernetesError; end
 
   STATUS_KEY = :kubernetes_cli_last_status
   STDOUT_KEY = :kubernetes_cli_stdout
   STDERR_KEY = :kubernetes_cli_stderr
 
-  attr_reader :kubeconfig_path, :executable
+  # T::Sig::WithoutRuntime.sig { returns(String) }
+  attr_reader :kubeconfig_path
+
+  # T::Sig::WithoutRuntime.sig { returns(String) }
+  attr_reader :executable
 
+  # BeforeCallback = T.type_alias { T.proc.params(cmd: T::Array[String]).void }
+  # AfterCallback = T.type_alias do
+  #   T.proc.params(cmd: T::Array[String], last_status: Process::Status).void
+  # end
+
+  # T::Sig::WithoutRuntime.sig { params(kubeconfig_path: String, executable: String).void }
   def initialize(kubeconfig_path, executable = KubectlRb.executable)
     @kubeconfig_path = kubeconfig_path
     @executable = executable
     @before_execute = []
     @after_execute = []
+    # @env = T.let(@env, T.nilable(T::Hash[String, String]))
   end
 
+  # T::Sig::WithoutRuntime.sig { params(block: BeforeCallback).void }
   def before_execute(&block)
     @before_execute << block
   end
 
+  # T::Sig::WithoutRuntime.sig { params(block: AfterCallback).void }
   def after_execute(&block)
     @after_execute << block
   end
 
+  # T::Sig::WithoutRuntime.sig { returns(T.nilable(Process::Status)) }
   def last_status
     Thread.current[STATUS_KEY]
   end
 
+  # T::Sig::WithoutRuntime.sig { params(block: T.proc.params(last_status: Process::Status).void).void }
+  def with_last_status(&block)
+    block.call(last_status)
+  end
+
+  # T::Sig::WithoutRuntime.sig { params(block: T.proc.params(last_status: Process::Status).void).void }
+  def on_last_status_failure(&block)
+    with_last_status do |ls|
+      block.call(ls) unless ls.success?
+    end
+  end
+
+  # T::Sig::WithoutRuntime.sig { returns(T::Hash[T.untyped, T.untyped]) }
+  def version
+    cmd = [executable, '--kubeconfig', kubeconfig_path, 'version', '-o', 'json']
+    result = backticks(cmd)
+
+    on_last_status_failure do |last_status|
+      raise GetVersionError, "couldn't get version info: "\
+        "kubectl exited with status code #{last_status.exitstatus}"
+    end
+
+    JSON.parse(result)
+  end
+
+  # T::Sig::WithoutRuntime.sig { params(cmd: T.any(String, T::Array[String])).void }
   def run_cmd(cmd)
     cmd = [executable, '--kubeconfig', kubeconfig_path, *Array(cmd)]
     execc(cmd)
   end
 
-  def exec_cmd(container_cmd, namespace, pod, tty = true)
+  # T::Sig::WithoutRuntime.sig {
+  #   params(
+  #     container_cmd: T.any(String, T::Array[String]),
+  #     namespace: String,
+  #     pod: String,
+  #     tty: T::Boolean,
+  #     container: T.nilable(String),
+  #     out_file: T.nilable(String)
+  #   ).void
+  # }
+  def exec_cmd(container_cmd, namespace, pod, tty = true, container = nil, out_file = nil)
     cmd = [executable, '--kubeconfig', kubeconfig_path, '-n', namespace, 'exec']
     cmd += ['-it'] if tty
+    cmd += ['-c', container] if container
     cmd += [pod, '--', *Array(container_cmd)]
+    cmd += ['>', out_file] if out_file
     execc(cmd)
   end
 
-  def system_cmd(container_cmd, namespace, pod, tty = true)
+  # T::Sig::WithoutRuntime.sig {
+  #   params(
+  #     container_cmd: T.any(String, T::Array[String]),
+  #     namespace: String,
+  #     pod: String,
+  #     tty: T::Boolean,
+  #     container: T.nilable(String)
+  #   ).void
+  # }
+  def system_cmd(container_cmd, namespace, pod, tty = true, container = nil)
     cmd = [executable, '--kubeconfig', kubeconfig_path, '-n', namespace, 'exec']
     cmd += ['-it'] if tty
+    cmd += ['-c', container] if container
     cmd += [pod, '--', *Array(container_cmd)]
     systemm(cmd)
   end
 
+  # T::Sig::WithoutRuntime.sig { params(res: ::KubeDSL::DSLObject, dry_run: T::Boolean).void }
   def apply(res, dry_run: false)
     cmd = [executable, '--kubeconfig', kubeconfig_path, 'apply', '--validate']
     cmd << '--dry-run=client' if dry_run
@@ -68,8 +165,8 @@ class KubernetesCLI
       stdin.puts(res.to_resource.to_yaml)
     end
 
-    unless last_status.success?
-      err = InvalidResourceError.new("Could not apply #{res.kind_sym.to_s.humanize.downcase} "\
+    on_last_status_failure do |last_status|
+      err = InvalidResourceError.new("Could not apply #{res.kind_sym} "\
         "'#{res.metadata.name}': kubectl exited with status code #{last_status.exitstatus}"
       )
 
@@ -78,13 +175,14 @@ class KubernetesCLI
     end
   end
 
+  # T::Sig::WithoutRuntime.sig { params(uri: String, dry_run: T::Boolean).void }
   def apply_uri(uri, dry_run: false)
     cmd = [executable, '--kubeconfig', kubeconfig_path, 'apply', '--validate']
     cmd << '--dry-run=client' if dry_run
     cmd += ['-f', uri]
     systemm(cmd)
 
-    unless last_status.success?
+    on_last_status_failure do |last_status|
       err = InvalidResourceUriError.new("Could not apply #{uri}: "\
         "kubectl exited with status code #{last_status.exitstatus}"
       )
@@ -94,29 +192,48 @@ class KubernetesCLI
     end
   end
 
-  def get_object(type, namespace, name = nil, match_labels = {})
-    cmd = [executable, '--kubeconfig', kubeconfig_path, '-n', namespace]
+  # T::Sig::WithoutRuntime.sig {
+  #   params(
+  #     type: String,
+  #     namespace: String,
+  #     name: String
+  #   ).returns(
+  #     T::Hash[String, T.untyped]
+  #   )
+  # }
+  def get_object(type, namespace, name)
+    cmd = [executable, '--kubeconfig', kubeconfig_path]
+    cmd += ['-n', namespace] if namespace
     cmd += ['get', type, name]
-
-    unless match_labels.empty?
-      cmd += ['--selector', match_labels.map { |key, value| "#{key}=#{value}" }.join(',')]
-    end
-
     cmd += ['-o', 'json']
 
     result = backticks(cmd)
 
-    unless last_status.success?
-      raise GetResourceError, "couldn't get resources of type '#{type}' "\
+    on_last_status_failure do |last_status|
+      raise GetResourceError, "couldn't get resource of type '#{type}' named '#{name}' "\
         "in namespace #{namespace}: kubectl exited with status code #{last_status.exitstatus}"
     end
 
     JSON.parse(result)
   end
 
+  # T::Sig::WithoutRuntime.sig {
+  #   params(
+  #     type: String,
+  #     namespace: T.any(String, Symbol),
+  #     match_labels: T::Hash[String, String]
+  #   ).returns(
+  #     T::Array[T.untyped]
+  #   )
+  # }
   def get_objects(type, namespace, match_labels = {})
-    cmd = [executable, '--kubeconfig', kubeconfig_path, '-n', namespace]
-    cmd += ['get', type]
+    cmd = [executable, '--kubeconfig', kubeconfig_path, 'get', type]
+
+    if namespace == :all
+      cmd << '--all-namespaces'
+    elsif namespace
+      cmd += ['-n', namespace.to_s]
+    end
 
     unless match_labels.empty?
       cmd += ['--selector', match_labels.map { |key, value| "#{key}=#{value}" }.join(',')]
@@ -126,7 +243,7 @@ class KubernetesCLI
 
     result = backticks(cmd)
 
-    unless last_status.success?
+    on_last_status_failure do |last_status|
       raise GetResourceError, "couldn't get resources of type '#{type}' "\
         "in namespace #{namespace}: kubectl exited with status code #{last_status.exitstatus}"
     end
@@ -134,6 +251,89 @@ class KubernetesCLI
     JSON.parse(result)['items']
   end
 
+  # T::Sig::WithoutRuntime.sig {
+  #   params(
+  #     type: String,
+  #     namespace: String,
+  #     name: String
+  #   ).void
+  # }
+  def delete_object(type, namespace, name)
+    cmd = [executable, '--kubeconfig', kubeconfig_path]
+    cmd += ['-n', namespace] if namespace
+    cmd += ['delete', type, name]
+
+    systemm(cmd)
+
+    on_last_status_failure do |last_status|
+      raise DeleteResourceError, "couldn't delete resource of type '#{type}' named '#{name}' "\
+        "in namespace #{namespace}: kubectl exited with status code #{last_status.exitstatus}"
+    end
+  end
+
+  # T::Sig::WithoutRuntime.sig {
+  #   params(
+  #     type: String,
+  #     namespace: T.any(String, Symbol),
+  #     match_labels: T::Hash[String, String]
+  #   ).void
+  # }
+  def delete_objects(type, namespace, match_labels = {})
+    cmd = [executable, '--kubeconfig', kubeconfig_path]
+
+    if namespace == :all
+      cmd << '--all-namespaces'
+    elsif namespace
+      cmd += ['-n', namespace.to_s]
+    end
+
+    cmd += ['delete', type]
+
+    unless match_labels.empty?
+      cmd += ['--selector', match_labels.map { |key, value| "#{key}=#{value}" }.join(',')]
+    end
+
+    systemm(cmd)
+
+    on_last_status_failure do |last_status|
+      raise DeleteResourceError, "couldn't delete resources of type '#{type}' "\
+        "in namespace #{namespace}: kubectl exited with status code #{last_status.exitstatus}"
+    end
+  end
+
+  # T::Sig::WithoutRuntime.sig {
+  #   params(
+  #     type: String,
+  #     namespace: String,
+  #     name: String,
+  #     patch_data: String,
+  #     patch_type: String
+  #   ).void
+  # }
+  def patch_object(type, namespace, name, patch_data, patch_type = 'merge')
+    cmd = [executable, '--kubeconfig', kubeconfig_path]
+    cmd += ['-n', namespace] if namespace
+    cmd += ['patch', type, name]
+    cmd += ['-p', Shellwords.shellescape(patch_data)]
+    cmd += ['--type', patch_type]
+
+    systemm(cmd)
+
+    on_last_status_failure do |last_status|
+      raise PatchResourceError, "couldn't patch resource of type '#{type}' named '#{name}' "\
+        "in namespace #{namespace}: kubectl exited with status code #{last_status.exitstatus}"
+    end
+  end
+
+  # T::Sig::WithoutRuntime.sig {
+  #   params(
+  #     type: String,
+  #     namespace: String,
+  #     name: String,
+  #     annotations: T::Hash[String, String],
+  #     overwrite: T::Boolean
+  #   ).void
+  # }
   def annotate(type, namespace, name, annotations, overwrite: true)
     cmd = [
       executable,
@@ -151,12 +351,19 @@ class KubernetesCLI
 
     systemm(cmd)
 
-    unless last_status.success?
-      raise KubernetesError, "could not annotate resource '#{name}': kubectl "\
+    on_last_status_failure do |last_status|
+      raise AnnotateResourceError, "could not annotate resource '#{name}': kubectl "\
         "exited with status code #{last_status.exitstatus}"
     end
   end
 
+  # T::Sig::WithoutRuntime.sig {
+  #   params(
+  #     namespace: String,
+  #     selector: T::Hash[String, String],
+  #     follow: T::Boolean
+  #   ).void
+  # }
   def logtail(namespace, selector, follow: true)
     cmd = [executable, '--kubeconfig', kubeconfig_path, '-n', namespace, 'logs']
     cmd << '-f' if follow
@@ -165,16 +372,18 @@ class KubernetesCLI
     execc(cmd)
   end
 
+  # T::Sig::WithoutRuntime.sig { returns(String) }
   def current_context
     cmd = [executable, '--kubeconfig', kubeconfig_path, 'config', 'current-context']
     backticks(cmd).strip
   end
 
+  # T::Sig::WithoutRuntime.sig { returns(String) }
   def api_resources
     cmd = [executable, '--kubeconfig', kubeconfig_path, 'api-resources']
     result = backticks(cmd)
 
-    unless last_status.success?
+    on_last_status_failure do |last_status|
       raise KubernetesError, 'could not fetch API resources: kubectl exited with '\
         "status code #{last_status.exitstatus}. #{result}"
     end
@@ -182,6 +391,7 @@ class KubernetesCLI
     result
   end
 
+  # T::Sig::WithoutRuntime.sig { params(namespace: String, deployment: String).void }
   def restart_deployment(namespace, deployment)
     cmd = [
       executable,
@@ -192,13 +402,14 @@ class KubernetesCLI
 
     systemm(cmd)
 
-    unless last_status.success?
+    on_last_status_failure do |last_status|
       raise KubernetesError, 'could not restart deployment: kubectl exited with '\
         "status code #{last_status.exitstatus}"
     end
   end
 
-  def with_pipes(out = STDOUT, err = STDERR)
+  # T::Sig::WithoutRuntime.sig { params(out: T.any(StringIO, IO), err: T.any(StringIO, IO), block: T.proc.void).void }
+  def with_pipes(out = STDOUT, err = STDERR, &block)
     previous_stdout = self.stdout
     previous_stderr = self.stderr
     self.stdout = out
@@ -209,39 +420,66 @@ class KubernetesCLI
     self.stderr = previous_stderr
   end
 
+  # T::Sig::WithoutRuntime.sig { returns(T.any(StringIO, IO)) }
   def stdout
     Thread.current[STDOUT_KEY] || STDOUT
   end
 
+  # T::Sig::WithoutRuntime.sig { params(new_stdout: T.nilable(T.any(StringIO, IO))).void }
   def stdout=(new_stdout)
     Thread.current[STDOUT_KEY] = new_stdout
   end
 
+  # T::Sig::WithoutRuntime.sig { returns(T.any(StringIO, IO)) }
   def stderr
     Thread.current[STDERR_KEY] || STDERR
   end
 
+  # T::Sig::WithoutRuntime.sig { params(new_stderr: T.nilable(T.any(StringIO, IO))).void }
   def stderr=(new_stderr)
     Thread.current[STDERR_KEY] = new_stderr
   end
 
   private
 
+  # T::Sig::WithoutRuntime.sig { returns(T::Hash[String, String]) }
   def env
     @env ||= {}
   end
 
+  # T::Sig::WithoutRuntime.sig { returns(T::Array[String]) }
   def base_cmd
     [executable, '--kubeconfig', kubeconfig_path]
   end
 
+  # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).void }
   def execc(cmd)
     run_before_callbacks(cmd)
     cmd_s = cmd.join(' ')
     exec(cmd_s)
   end
 
+  # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).void }
   def systemm(cmd)
+    if stdout == STDOUT && stderr == STDERR
+      systemm_default(cmd)
+    else
+      systemm_open3(cmd)
+    end
+  end
+
+  # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).void }
+  def systemm_default(cmd)
+    run_before_callbacks(cmd)
+    cmd_s = cmd.join(' ')
+    system(cmd_s).tap do
+      self.last_status = $?
+      run_after_callbacks(cmd)
+    end
+  end
+
+  # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).void }
+  def systemm_open3(cmd)
     run_before_callbacks(cmd)
     cmd_s = cmd.join(' ')
 
@@ -267,7 +505,27 @@ class KubernetesCLI
     end
   end
 
+  # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).returns(String) }
   def backticks(cmd)
+    if stdout == STDOUT && stderr == STDERR
+      backticks_default(cmd)
+    else
+      backticks_open3(cmd)
+    end
+  end
+
+  # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).returns(String) }
+  def backticks_default(cmd)
+    run_before_callbacks(cmd)
+    cmd_s = cmd.join(' ')
+    `#{cmd_s}`.tap do
+      self.last_status = $?
+      run_after_callbacks(cmd)
+    end
+  end
+
+  # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).returns(String) }
+  def backticks_open3(cmd)
     run_before_callbacks(cmd)
     cmd_s = cmd.join(' ')
     result = StringIO.new
@@ -296,10 +554,20 @@ class KubernetesCLI
     result.string
   end
 
+  # T::Sig::WithoutRuntime.sig {
+  #   params(
+  #     env: T::Hash[String, String],
+  #     cmd: T::Array[String],
+  #     opts: T::Hash[Symbol, T.untyped],
+  #     block: T.proc.params(p_stdin: IO).void
+  #   ).void
+  # }
   def open3_w(env, cmd, opts = {}, &block)
     run_before_callbacks(cmd)
     cmd_s = cmd.join(' ')
 
+    # unsafes here b/c popen3 takes an optional first argument hash
+    # with environment variables, which confuses the sh*t out of sorbet
     Open3.popen3(env, cmd_s, opts) do |p_stdin, p_stdout, p_stderr, wait_thread|
       Thread.new(stdout) do |t_stdout|
         begin
@@ -315,23 +583,26 @@ class KubernetesCLI
         end
       end
 
-      yield(p_stdin).tap do
-        p_stdin.close
-        self.last_status = wait_thread.value
-        run_after_callbacks(cmd)
-        wait_thread.join
-      end
+      yield(p_stdin)
+
+      p_stdin.close
+      self.last_status = wait_thread.value
+      run_after_callbacks(cmd)
+      wait_thread.join
     end
   end
 
+  # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).void }
   def run_before_callbacks(cmd)
     @before_execute.each { |cb| cb.call(cmd) }
   end
 
+  # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).void }
   def run_after_callbacks(cmd)
     @after_execute.each { |cb| cb.call(cmd, last_status) }
   end
 
+  # T::Sig::WithoutRuntime.sig { params(status: Process::Status).void }
   def last_status=(status)
     Thread.current[STATUS_KEY] = status
   end