kubeclient_exec 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e26fa27357945aaf399dd95d64016c5e210c050812c25c5da4243bcbb6e2917c
+  data.tar.gz: c98b695f374b80b688206096fe50614d3edd0f2d7f09fa1abe3a0f043015d76e
+SHA512:
+  metadata.gz: 86b3b7d38cfbbdeb90479185da1d958f517774263a6f5638008bb2cceae7dc0e412a629883bea7080ccf306d4df703ae643ef0685c06cd98729c5f1f4b8bc42b
+  data.tar.gz: 4f8adcd36dc6dfa16390330eb5eec1d11bfcf17d7f702adb6fc3a11fd5d5ba165dffab2ce46401bf38b178c8c6a466160b4152098e196fdb2a0564fe821021fa

data/lib/kubeclient_exec/copy/copy.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative 'tar'
+
+module KubeclientExec
+  module Copy
+    include Tar
+
+    DEFAULT_CP_OPTIONS = {
+      container: nil,
+      reverse_direction: false,
+      suppress_errors: true,
+      tls: {
+        cert_chain_file: nil,
+        private_key_file: nil,
+        verify_peer: true
+      }
+    }
+
+    def cp_pod(local_path, remote_path, name, namespace, options: {})
+      # Reverse merge with the default options
+      options.merge!(Copy::DEFAULT_CP_OPTIONS) { |_, option, _| option }
+
+      if options[:reverse_direction]
+        cp_from_pod(local_path, remote_path, name, namespace, options)
+      else
+        cp_to_pod(local_path, remote_path, name, namespace, options)
+      end
+    end
+
+    private
+    def cp_to_pod(local_path, remote_path, name, namespace, options)
+      copy_file = false
+
+      if File.file?(local_path)
+        copy_file = true
+      elsif !File.directory?(local_path)
+        raise 'Did not find local path!'
+      end
+
+      tar_file = tar(local_path, remote_path, copy_file)
+
+      if copy_file
+        exec_pod("tar xf - -C #{remote_path.split('/')[0...-1].join('/')}", name, namespace, options: { tty: false }.merge!(options)) do |executor|
+          executor.write(tar_file.string)
+
+          # Feels like there should be a better way for this
+          EM.add_periodic_timer(0.1) do
+            if executor.done?
+              executor.stop
+            end
+          end
+        end
+      else
+        exec_pod("tar xf - -C #{remote_path}", name, namespace, options: { tty: false }.merge!(options)) do |executor|
+          executor.write(tar_file.string)
+
+          # Feels like there should be a better way for this
+          EM.add_periodic_timer(0.1) do
+            if executor.done?
+              executor.stop
+            end
+          end
+        end
+      end
+    end
+
+    def cp_from_pod(local_path, remote_path, name, namespace, options)
+      result = nil
+
+      exec_pod("tar cf - #{remote_path}", name, namespace, options: { tty: false }.merge!(options)) do |executor|
+        count = 0
+
+        executor.on_stdout do |data|
+          if count == 1
+            if local_path.is_a? String
+              untar(StringIO.new(data), local_path)
+            elsif local_path == :single_result
+              result = single_untar(StringIO.new(data))
+            end
+            executor.stop
+          end
+
+          count += 1
+        end
+      end
+
+      result
+    end
+  end
+end

data/lib/kubeclient_exec/copy/tar.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'rubygems/package'
+
+# Greatly inspired by Github.com/sinisterchipmunk
+# Source: https://gist.github.com/sinisterchipmunk/1335041/5be4e6039d899c9b8cca41869dc6861c8eb71f13
+#
+# Copyright (C) 2011 by Colin MacKenzie IV
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+module KubeclientExec
+  module Copy
+    module Tar
+      def tar(src, dst, copy_file)
+        tar_file = StringIO.new
+
+        Gem::Package::TarWriter.new(tar_file) do |tar|
+          if copy_file
+            relative_file = dst.split('/').last
+
+            tar.add_file relative_file, File.stat(src).mode do |tf|
+              File.open(src, "rb") { |f| tf.write f.read }
+            end
+          else
+            Dir[File.join(src, "**/*")].each do |file|
+              mode = File.stat(file).mode
+              relative_file = file.sub /^#{Regexp::escape src}\/?/, ''
+
+              if File.directory?(file)
+                tar.mkdir relative_file, mode
+              else
+                tar.add_file relative_file, mode do |tf|
+                  File.open(file, "rb") { |f| tf.write f.read }
+                end
+              end
+            end
+          end
+        end
+
+        tar_file.rewind
+        tar_file
+      end
+
+      def untar(io, destination)
+        Gem::Package::TarReader.new(io) do |tar|
+          tar.each do |tarfile|
+            destination_file = File.join(destination, tarfile.full_name)
+
+            if tarfile.directory?
+              FileUtils.mkdir_p(destination_file)
+            else
+              destination_directory = File.dirname(destination_file)
+
+              FileUtils.mkdir_p destination_directory unless File.directory?(destination_directory)
+
+              File.open(destination_file, "wb") do |f|
+                f.write(tarfile.read)
+              end
+            end
+          end
+        end
+      end
+
+      def single_untar(io)
+        Gem::Package::TarReader.new(io) do |tar|
+          tar.each do |tarfile|
+            return tarfile.read
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kubeclient_exec/execute/execute.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'executor'
+
+module KubeclientExec
+  module Execute
+    DEFAULT_EXEC_OPTIONS = {
+      container: nil,
+      stdin: true,
+      stdout: true,
+      stderror: true,
+      tty: true,
+      suppress_errors: true,
+      tls: {
+        cert_chain_file: nil,
+        private_key_file: nil,
+        verify_peer: true
+      }
+    }
+
+    def exec_pod(command, name, namespace, options: {}, &block)
+      ns_prefix = build_namespace_prefix(namespace)
+      client = rest_client["#{ns_prefix}pods/#{name}/exec"]
+      url = URI.parse(client.url)
+
+      # Reverse merge with the default options
+      options.merge!(Execute::DEFAULT_EXEC_OPTIONS) { |_, option, _| option }
+
+      kubeclient_options = { headers: @headers, tls: options[:tls] }
+
+      url.query = (options.filter { |k| ![:suppress_errors, :tls].include?(k) }.compact.map { |k, v| "#{k}=#{v}"} << command.split(' ').map { |c| "command=#{c}"}).join('&')
+
+      if url.to_s.start_with?('https')
+        url = "wss" + url.to_s[5..-1]
+      end
+
+      last_output = { last_stdout: nil, last_stderr: nil }
+
+      EM.run do
+        executor = if block_given?
+            Executor.new(command, url, kubeclient_options, options) do |executor|
+              block.call(executor)
+            end
+        else
+            Executor.new(command, url, kubeclient_options, options.merge!(mode: :adhoc))
+        end
+
+        EM.add_shutdown_hook do
+          last_output[:last_stdout] = executor.last_stdout
+          last_output[:last_stderr] = executor.last_stderr
+        end
+      end
+
+      last_output
+    end
+  end
+end

data/lib/kubeclient_exec/execute/executor.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'eventmachine'
+
+module KubeclientExec
+  module Execute
+    class Executor
+      EXEC_STDIN = 0
+      EXEC_STDOUT = 1
+      EXEC_STDERR = 2
+      EXEC_DCKERR = 3 # Not sure about this one
+
+      attr_reader :last_stdout, :last_stderr, :last_command
+
+      def initialize(command, url, kubeclient_options, options, &block)
+        @last_command = command
+        @url = url
+        @kubeclient_options = kubeclient_options
+        @options = options
+        @on_open = block
+        @suppress_errors = options[:suppress_errors]
+
+        if options[:mode] == :adhoc
+          @on_stdout = ->(_) { stop }
+          @on_stderr = ->(_) { stop }
+        end
+
+        setup
+      end
+
+      def execute(command)
+        raise 'ws not initialized' unless @ws
+
+        @last_command = command
+
+        @ws.send((command + "\n").unpack("C*").unshift(EXEC_STDIN))
+      end
+
+      def write(content)
+        raise 'ws not initialized' unless @ws
+
+        @ws.send(content.unpack("C*").unshift(EXEC_STDIN))
+      end
+
+      def on_stdout(&block)
+        @on_stdout = block
+      end
+
+      def on_stderr(&block)
+        @on_stderr = block
+      end
+
+      def on_close(&block)
+        @on_close = block
+      end
+
+      def stop
+        @ws.close if @ws
+        @on_close.call if @on_close
+        EM.stop_event_loop
+      end
+
+      def done?
+        @ws.instance_variable_get(:@driver).instance_variable_get(:@queue).empty?
+      end
+
+      private
+      def setup
+        @ws = Faye::WebSocket::Client.new(@url, nil, {
+          ping: 10,
+          headers: @kubeclient_options[:headers],
+          tls: {
+            cert_chain_file: @kubeclient_options[:tls][:cert_chain_file],
+            private_key_file: @kubeclient_options[:tls][:private_key_file],
+            verify_peer: @kubeclient_options[:tls][:verify_peer],
+          }
+        })
+
+        @ws.on(:message) do |msg|
+          if msg.type == :close
+            stop
+            return
+          end
+
+          next if msg.data.empty?
+
+          type = msg.data.shift
+          content = msg.data.pack("C*").force_encoding('utf-8')
+
+          if content.empty?
+            if @options[:mode] == :adhoc
+              @last_stdout = 1 if type == EXEC_STDOUT
+              @last_stderr = 1 if type == EXEC_STDERR || EXEC_DCKERR
+              stop
+            end
+          end
+
+          case type
+          when EXEC_STDOUT
+            @last_stdout = content
+            @on_stdout.call(content) if @on_stdout
+          when EXEC_STDERR, EXEC_DCKERR
+            @last_stderr = content
+            @on_stderr.call(content) if @on_stderr
+          else
+            raise "Unsupported or Unknown channel"
+          end
+        end
+
+        @ws.on(:error) do |event|
+          raise "Error: #{event.inspect}" unless @suppress_errors
+        end
+
+        @ws.on(:close) do
+          stop
+        end
+
+        @ws.on(:open) do
+          @on_open.call(self) if @on_open
+        end
+      end
+    end
+  end
+end

data/lib/kubeclient_exec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'kubeclient'
+require 'faye/websocket'
+require_relative 'kubeclient_exec/execute/execute'
+require_relative 'kubeclient_exec/copy/copy'
+
+module KubeclientExec
+  include KubeclientExec::Execute
+  include KubeclientExec::Copy
+end
+
+Kubeclient::Client.include(KubeclientExec)

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: kubeclient_exec
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Wout Ceulemans
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-02-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: kubeclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.11.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.11.0
+- !ruby/object:Gem::Dependency
+  name: faye-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.3
+description: 
+email: me@wout.dev
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/kubeclient_exec.rb
+- lib/kubeclient_exec/copy/copy.rb
+- lib/kubeclient_exec/copy/tar.rb
+- lib/kubeclient_exec/execute/execute.rb
+- lib/kubeclient_exec/execute/executor.rb
+homepage: https://github.com/WoutDev/kubeclient_exec
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key: 
+specification_version: 4
+summary: An extension to the kubeclient gem that adds exec_pod and cp_pod functionality.
+test_files: []