19941764447

Committed 04 Dec 2025 07:43PM UTC coverage: 95.253% (-0.06%) from 95.316%

Build # 19941764447

Build Type

push

github

Committed by

Nu-hin

Commit Message

Add code encryption

Run Details

55 of 59 new or added lines in 7 files covered. (93.22%)

1 existing line in 1 file now uncovered.

1204 of 1264 relevant lines covered (95.25%)

160.55 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

23.38

/lib/remote_ruby/ssh_adapter.rb

# frozen_string_literal: true

require 'net/ssh'
require 'remote_ruby/compat_io_reader'

module RemoteRuby
  # An adapter for executing Ruby code on a remote host via SSH
  class SSHAdapter < ConnectionAdapter
    UnableToExecuteError = Class.new(StandardError)

    attr_reader :host, :config, :working_dir, :user, :ruby_executable, :encryption_key_base64

    def initialize(host:, working_dir: nil, use_ssh_config_file: true, ruby_executable: 'ruby',
                   encryption_key_base64: nil, **params)
      super
      @host = host
      @working_dir = working_dir
      @config = Net::SSH.configuration_for(@host, use_ssh_config_file)
      @ruby_executable = ruby_executable
      @encryption_key_base64 = encryption_key_base64

      @config = @config.merge(params)
      @user = @config[:user]
    end

    def open(code, stdin, stdout, stderr)
      ret = nil
      Net::SSH.start(host, nil, config) do |ssh|
        with_temp_file(code, ssh) do |fname|
          res = run_code(ssh, fname, stdin, stdout, stderr)
          raise "Process exited with code #{res}" unless res.zero?

          ret = get_result(ssh, fname)
        end
      end
      ret
    end

    def connection_name
      "#{user}@#{host}:#{working_dir || '~'}> "
    end

    private

    def handle_stdin(chan, stdin)
      return if stdin.nil?

      if stdin.is_a?(StringIO)
        chan.send_data(stdin.string)
        chan.eof!
        return
      end

      stdin = RemoteRuby::CompatIOReader.new(stdin)

      chan.connection.listen_to(stdin.readable) do |io|
        data = io.read_nonblock(4096)
        chan.send_data(data)
      rescue EOFError
        chan.connection.stop_listening_to(stdin.readable)
        chan.eof!
      end

      chan.on_close do
        chan.connection.stop_listening_to(stdin.readable)
        stdin.join
      end
    end

    def handle_stdout(chan, stdout)
      return if stdout.nil?

      chan.on_data do |_, data|
        stdout.write(data)
      end
    end

    def handle_stderr(chan, stderr)
      return if stderr.nil?

      chan.on_extended_data do |_, _, data|
        stderr.write(data)
      end
    end

    def handle_exit_code(chan)
      chan.on_request('exit-status') do |_, data|
        yield data.read_long
      end
    end

    def run_remote_process(ssh, cmd, stdin, stdout, stderr)
      res = nil

      ssh.open_channel do |channel|
        channel.exec(cmd) do |ch, success|
          raise UnableToExecuteError unless success

          handle_stdin(ch, stdin)
          handle_stdout(ch, stdout)
          handle_stderr(ch, stderr)
          handle_exit_code(ch) do |code|
            res = code
          end
        end
      end.wait

      res
    end

    def run_code(ssh, fname, stdin, stdout, stderr)
      cmd = if encryption_key_base64.nil?
              "cd '#{working_dir}' && #{ruby_executable} \"#{fname}\""
            else
              "cd '#{working_dir}' && #{ruby_executable} \"#{fname}\" \"#{encryption_key_base64}\""
            end
      run_remote_process(ssh, cmd, stdin, stdout, stderr)
    end

    def get_result(ssh, fname)
      ssh.exec!("cat \"#{fname}\"")
    end

    def with_temp_file(code, ssh)
      out = StringIO.new
      cmd = 'f=$(mktemp --tmpdir remote_ruby.XXXXXX) && cat > $f && echo $f'
      run_remote_process(ssh, cmd, StringIO.new(code), out, nil)
      fname = out.string.strip

      yield fname
    ensure
      ssh.exec!("rm \"#{fname}\"")
    end
  end
end

1	# frozen_string_literal: true
2
3	require 'net/ssh'	20✔
4	require 'remote_ruby/compat_io_reader'	20✔
5
6	module RemoteRuby	20✔
7	# An adapter for executing Ruby code on a remote host via SSH
8	class SSHAdapter < ConnectionAdapter	20✔
9	UnableToExecuteError = Class.new(StandardError)	20✔
10
11	attr_reader :host, :config, :working_dir, :user, :ruby_executable, :encryption_key_base64	20✔
12
13	def initialize(host:, working_dir: nil, use_ssh_config_file: true, ruby_executable: 'ruby',	20✔
14	encryption_key_base64: nil, **params)
15	super	×
16	@host = host	×
17	@working_dir = working_dir	×
18	@config = Net::SSH.configuration_for(@host, use_ssh_config_file)	×
19	@ruby_executable = ruby_executable	×
NEW 20	@encryption_key_base64 = encryption_key_base64	×
21
22	@config = @config.merge(params)	×
23	@user = @config[:user]	×
24	end
25
26	def open(code, stdin, stdout, stderr)	20✔
27	ret = nil	×
28	Net::SSH.start(host, nil, config) do \|ssh\|	×
29	with_temp_file(code, ssh) do \|fname\|	×
30	res = run_code(ssh, fname, stdin, stdout, stderr)	×
31	raise "Process exited with code #{res}" unless res.zero?	×
32
33	ret = get_result(ssh, fname)	×
34	end
35	end
36	ret	×
37	end
38
39	def connection_name	20✔
40	"#{user}@#{host}:#{working_dir \|\| '~'}> "	×
41	end
42
43	private	20✔
44
45	def handle_stdin(chan, stdin)	20✔
46	return if stdin.nil?	×
47
48	if stdin.is_a?(StringIO)	×
49	chan.send_data(stdin.string)	×
50	chan.eof!	×
51	return	×
52	end
53
54	stdin = RemoteRuby::CompatIOReader.new(stdin)	×
55
56	chan.connection.listen_to(stdin.readable) do \|io\|	×
57	data = io.read_nonblock(4096)	×
58	chan.send_data(data)	×
59	rescue EOFError
60	chan.connection.stop_listening_to(stdin.readable)	×
61	chan.eof!	×
62	end
63
64	chan.on_close do	×
65	chan.connection.stop_listening_to(stdin.readable)	×
66	stdin.join	×
67	end
68	end
69
70	def handle_stdout(chan, stdout)	20✔
71	return if stdout.nil?	×
72
73	chan.on_data do \|_, data\|	×
74	stdout.write(data)	×
75	end
76	end
77
78	def handle_stderr(chan, stderr)	20✔
79	return if stderr.nil?	×
80
81	chan.on_extended_data do \|_, _, data\|	×
82	stderr.write(data)	×
83	end
84	end
85
86	def handle_exit_code(chan)	20✔
87	chan.on_request('exit-status') do \|_, data\|	×
88	yield data.read_long	×
89	end
90	end
91
92	def run_remote_process(ssh, cmd, stdin, stdout, stderr)	20✔
93	res = nil	×
94
95	ssh.open_channel do \|channel\|	×
96	channel.exec(cmd) do \|ch, success\|	×
97	raise UnableToExecuteError unless success	×
98
99	handle_stdin(ch, stdin)	×
100	handle_stdout(ch, stdout)	×
101	handle_stderr(ch, stderr)	×
102	handle_exit_code(ch) do \|code\|	×
103	res = code	×
104	end
105	end
106	end.wait
107
108	res	×
109	end
110
111	def run_code(ssh, fname, stdin, stdout, stderr)	20✔
NEW 112	cmd = if encryption_key_base64.nil?	×
NEW 113	"cd '#{working_dir}' && #{ruby_executable} \"#{fname}\""	×
114	else
NEW 115	"cd '#{working_dir}' && #{ruby_executable} \"#{fname}\" \"#{encryption_key_base64}\""	×
116	end
UNCOV 117	run_remote_process(ssh, cmd, stdin, stdout, stderr)	×
118	end
119
120	def get_result(ssh, fname)	20✔
121	ssh.exec!("cat \"#{fname}\"")	×
122	end
123
124	def with_temp_file(code, ssh)	20✔
125	out = StringIO.new	×
126	cmd = 'f=$(mktemp --tmpdir remote_ruby.XXXXXX) && cat > $f && echo $f'	×
127	run_remote_process(ssh, cmd, StringIO.new(code), out, nil)	×
128	fname = out.string.strip	×
129
130	yield fname	×
131	ensure
132	ssh.exec!("rm \"#{fname}\"")	×
133	end
134	end
135	end

Nu-hin / remote_ruby / 19941764447

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous