kubernetes-cli 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2b3ae42d2a905be32a61c55740bff526f43874dfd9c194391814fea0bb4d8a5
-  data.tar.gz: 624b91b4024dbed3b29ccdd8b2537b4e5a2f65d4df72d6a05f6e5141f7bb3c1c
+  metadata.gz: b93bf8e3f620c17f2781d2eb5f2748f970982a854d0aa622d3313b1d74104d3b
+  data.tar.gz: 9c7d170e2ab873b66cfbf6a12532260e3442781330c9e96363e472d354ff997a
 SHA512:
-  metadata.gz: 892beee416b11f888cb91fa454bbfde2d4d9464cad77de079a9c1ccbe3c3c05ce285c24fb1e0036a00c999fb344101013cfb10e14a8aadaea95e4ca336bd0351
-  data.tar.gz: ffbf3c1358d19e589b5763c3dbe51de8e622d1dccf9dfda05727cefc0ef3fc8fed4a037ff664a3f7e42e9a6052559e2d9f6a4dd8ca5cba8c4bf74e6e465fbe77
+  metadata.gz: 0156747413340bab08b571bf13db212d0a8397ceb0b733fbc152c7835080f203400f6f1554829c74dab4fe1b743b3f3eda3d2e11950896f01da6b9bedf5bc3ca
+  data.tar.gz: c21786be60e403d60d2c39fd7be371a7043539412000e9cff2ea197e37092fe38a2bc621a6413266aabd0b8633656375056ce46745ac65726eb08c3e31cd14e3

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 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.
 

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.2'
+  VERSION = '0.4.0'.freeze
 end

data/lib/kubernetes-cli.rb

@@ -1,65 +1,161 @@
+# typed: strict
+
+require 'json'
 require 'kubectl-rb'
 require 'open3'
+require 'shellwords'
 require 'stringio'
-require 'json'
 
 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
@@ -69,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}"
       )
 
@@ -79,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}"
       )
@@ -95,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(',')]
@@ -127,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
@@ -135,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,
@@ -152,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
@@ -166,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
@@ -183,6 +391,7 @@ class KubernetesCLI
     result
   end
 
+  # T::Sig::WithoutRuntime.sig { params(namespace: String, deployment: String).void }
   def restart_deployment(namespace, deployment)
     cmd = [
       executable,
@@ -193,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
@@ -210,38 +420,46 @@ 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)
@@ -250,6 +468,7 @@ class KubernetesCLI
     end
   end
 
+  # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).void }
   def systemm_default(cmd)
     run_before_callbacks(cmd)
     cmd_s = cmd.join(' ')
@@ -259,6 +478,7 @@ class KubernetesCLI
     end
   end
 
+  # T::Sig::WithoutRuntime.sig { params(cmd: T::Array[String]).void }
   def systemm_open3(cmd)
     run_before_callbacks(cmd)
     cmd_s = cmd.join(' ')
@@ -285,6 +505,7 @@ 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)
@@ -293,6 +514,7 @@ class KubernetesCLI
     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(' ')
@@ -302,6 +524,7 @@ class KubernetesCLI
     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(' ')
@@ -331,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
@@ -350,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