remote_ruby 0.2.1 → 1.0.0

data/lib/remote_ruby/{flavour/rails_flavour.rb → rails_plugin.rb}

@@ -1,17 +1,19 @@
 # frozen_string_literal: true
 
+require 'remote_ruby/plugin'
+
 module RemoteRuby
-  # Flavour to load Rails environment
-  class RailsFlavour < ::RemoteRuby::Flavour
+  # Plugin to load Rails environment
+  class RailsPlugin < ::RemoteRuby::Plugin
     def initialize(environment: :development)
       super
       @environment = environment
     end
 
     def code_header
-      <<-RUBY
-  ENV['RAILS_ENV'] = '#{environment}'
-  require './config/environment'
+      <<~RUBY
+        ENV['RAILS_ENV'] = '#{environment}'
+        require './config/environment'
       RUBY
     end
 

data/lib/remote_ruby/remote_context.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module RemoteRuby
+  # This class is inlined to the remote script and used
+  # to collect errors and other information about the remote run.
+  # It is serialized and sent back to the client.
+  class RemoteContext
+    attr_reader :file_name, :has_error, :error_class, :error_message, :error_backtrace, :locals, :result
+
+    def initialize(filename)
+      @file_name = filename
+      @has_error = false
+      @locals = {}
+    end
+
+    def error?
+      @has_error
+    end
+
+    def handle_error(err)
+      @error_class = err.class.to_s
+      @error_message = err.message
+      @error_backtrace = err.backtrace
+      @has_error = true
+    end
+
+    def execute(&block)
+      @result = begin
+        block.call
+      rescue StandardError => e
+        handle_error(e)
+      ensure
+        locals.each_key do |name|
+          locals[name] = block.binding.local_variable_get(name)
+        end
+      end
+    end
+
+    def dump
+      Marshal.dump(self)
+    end
+
+    def unmarshal(name, data)
+      locals[name] = Marshal.load(Base64.strict_decode64(data)) # rubocop:disable Security/MarshalLoad
+    rescue ArgumentError
+      warn("Warning: could not resolve type for '#{name}' variable")
+      nil
+    end
+  end
+end

data/lib/remote_ruby/remote_error.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'stringio'
+module RemoteRuby
+  # Raised when an error occurs during remote execution
+  # Wraps the original error and provides additional information
+  # about the error and the source code that caused it.
+  # Allows to display the source code around the line that caused the error.
+  class RemoteError < StandardError
+    attr_reader :code_source, :remote_context, :source_path, :stack_trace_regexp
+
+    def initialize(code_source, remote_context, source_path)
+      @code_source = code_source
+      @remote_context = remote_context
+      @source_path = source_path
+      @stack_trace_regexp = /^#{Regexp.escape(remote_context.file_name)}:(?<line_number>\d+):in (?<method_name>.*)$/
+      super(build_message)
+    end
+
+    private
+
+    def format_source(line_no, context_lines: 3)
+      code_source.lines.each.with_index(1).drop(line_no - context_lines - 1)
+                 .take((2 * context_lines) + 1).map do |line, index|
+        if index == line_no
+          "#{index}: >> #{line}"
+        else
+          "#{index}:    #{line}"
+        end
+      end
+    end
+
+    def build_message
+      res = StringIO.new
+      res.puts "Remote error: #{remote_context.error_class}"
+      res.puts remote_context.error_message
+
+      write_backtrace(res)
+
+      res.string
+    end
+
+    def write_backtrace(res)
+      remote_context.error_backtrace.each do |line|
+        res.puts
+        res.puts "from #{line}"
+
+        next unless (m = stack_trace_regexp.match(line))
+
+        res.puts "(See #{source_path}:#{m[:line_number]}:in #{m[:method_name]}" if source_path
+        res.puts format_source(m[:line_number].to_i)
+      end
+    end
+  end
+end

data/lib/remote_ruby/source_extractor.rb

@@ -1,24 +1,14 @@
 # frozen_string_literal: true
 
 require 'method_source'
-require 'parser/current'
-require 'unparser'
-
-# Opt-in to most recent AST format
-Parser::Builders::Default.emit_lambda              = true
-Parser::Builders::Default.emit_procarg0            = true
-Parser::Builders::Default.emit_encoding            = true
-Parser::Builders::Default.emit_index               = true
-Parser::Builders::Default.emit_arg_inside_procarg0 = true
-Parser::Builders::Default.emit_forward_arg         = true
-Parser::Builders::Default.emit_kwargs              = true
-Parser::Builders::Default.emit_match_pattern       = true
+require 'remote_ruby/parser_factory'
 
 module RemoteRuby
   # Receives a block and extracts Ruby code (as a string) with this block's
   # source
   class SourceExtractor
     def extract(&block)
+      RemoteRuby::ParserFactory.require_parser
       ast = Parser::CurrentRuby.parse(block.source)
       block_node = find_block(ast)
 

data/lib/remote_ruby/ssh_adapter.rb

@@ -0,0 +1,128 @@
+# 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
+
+    def initialize(host:, working_dir: nil, use_ssh_config_file: true, **params)
+      super
+      @host = host
+      @working_dir = working_dir
+      @config = Net::SSH.configuration_for(@host, use_ssh_config_file)
+
+      @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 #{status}" 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 = "cd '#{working_dir}' && ruby \"#{fname}\""
+      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

data/lib/remote_ruby/stream_prefixer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RemoteRuby
+  # Decorates the source stream prepending a prefix to each line
+  # read from the source
+  class StreamPrefixer
+    attr_reader :stream, :prefix
+
+    def initialize(stream, prefix)
+      @stream = stream
+      @prefix = prefix
+      @prefix_needed = true
+    end
+
+    def write(data)
+      res = 0
+      data.each_line do |line|
+        res += stream.write(prefix) if @prefix_needed
+        @prefix_needed = line.end_with?("\n")
+        res += stream.write(line)
+      end
+      res
+    end
+  end
+end

data/lib/remote_ruby/tee_writer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RemoteRuby
+  # Implements a tee writer that writes to multiple writers
+  class TeeWriter
+    attr_reader :writers
+
+    def initialize(*writers)
+      @writers = writers
+    end
+
+    def write(*args)
+      writers.map { |writer| writer.write(*args) }.min
+    end
+  end
+end

data/lib/remote_ruby/text_mode_adapter.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'remote_ruby/stream_prefixer'
+require 'colorize'
+
+module RemoteRuby
+  # Decorates a connection adapter.
+  # Reads the output streams line-by-line and prefixes them according to the settings.
+  class TextModeAdapter < ConnectionAdapter
+    DEFAULT_SETTINGS = {
+      stdout_mode: { color: :green, mode: :italic },
+      stderr_mode: { color: :red, mode: :italic },
+      cache_mode: { color: :blue, mode: :bold },
+      cache_prefix: '[C] '
+    }.freeze
+
+    attr_reader :adapter, :stdout_prefix, :stderr_prefix, :cache_prefix, :stdout_mode, :stderr_mode,
+                :cache_mode
+
+    def initialize(adapter, **params)
+      super()
+      @adapter = adapter
+      @stdout_prefix = params[:stdout_prefix]
+      @stderr_prefix = params[:stderr_prefix]
+      @cache_prefix = params[:cache_prefix]
+      @stdout_mode = params[:stdout_mode]
+      @stderr_mode = params[:stderr_mode]
+      @cache_mode = params[:cache_mode]
+    end
+
+    def open(code, stdin, stdout, stderr)
+      stdout_pref = "#{cache_prefix_string}#{stdout_prefix_string}"
+      stderr_pref = "#{cache_prefix_string}#{stderr_prefix_string}"
+      stdout = StreamPrefixer.new(stdout, stdout_pref) unless stdout_prefix_string.nil?
+      stderr = StreamPrefixer.new(stderr, stderr_pref) unless stderr_prefix_string.nil?
+
+      adapter.open(code, stdin, stdout, stderr)
+    end
+
+    private
+
+    def stdout_prefix_string
+      return nil if stdout_prefix.nil? || stdout_prefix.empty?
+      return stdout_prefix if stdout_mode.nil?
+
+      stdout_prefix.colorize(stdout_mode)
+    end
+
+    def stderr_prefix_string
+      return nil if stderr_prefix.nil? || stderr_prefix.empty?
+      return stderr_prefix if stderr_mode.nil?
+
+      stderr_prefix.colorize(stderr_mode)
+    end
+
+    def cache_prefix_string
+      return nil if cache_prefix.nil? || cache_prefix.empty?
+      return cache_prefix if cache_mode.nil?
+
+      cache_prefix.colorize(cache_mode)
+    end
+  end
+end

data/lib/remote_ruby/text_mode_builder.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RemoteRuby
+  # Wraps the connection adapter in a text mode adapter if text mode is enabled.
+  class TextModeBuilder
+    attr_reader :out_tty, :err_tty, :text_mode
+
+    def initialize(params:, out_tty: true, err_tty: true)
+      @out_tty = out_tty
+      @err_tty = err_tty
+      @text_mode = params.delete(:text_mode) || false
+    end
+
+    def build(adapter)
+      return adapter unless text_mode
+
+      cache_mode = adapter.is_a? CacheAdapter
+
+      tm_params = text_mode_params(adapter, cache_mode, out_tty, err_tty)
+
+      return adapter unless tm_params[:stdout_prefix] || tm_params[:stderr_prefix]
+
+      ::RemoteRuby::TextModeAdapter.new(adapter, **tm_params)
+    end
+
+    private
+
+    def text_mode_params(adapter, cache_mode, out_tty, err_tty)
+      tm_params = ::RemoteRuby::TextModeAdapter::DEFAULT_SETTINGS.merge(
+        stdout_prefix: adapter.connection_name,
+        stderr_prefix: adapter.connection_name
+      )
+
+      tm_params = tm_params.merge(text_mode) if text_mode.is_a? Hash
+
+      disable_unless_tty = tm_params.delete(:disable_unless_tty) { |_| true }
+
+      tm_params[:stdout_prefix] = nil if disable_unless_tty && !out_tty
+      tm_params[:stderr_prefix] = nil if disable_unless_tty && !err_tty
+      tm_params[:cache_prefix] = nil unless cache_mode
+      tm_params
+    end
+  end
+end

data/lib/remote_ruby/tmp_file_adapter.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+require 'remote_ruby/compat_io_reader'
+require 'remote_ruby/compat_io_writer'
+
+module RemoteRuby
+  # An adapter to expecute Ruby code on the local machine
+  # inside a temporary file
+  class TmpFileAdapter < ::RemoteRuby::ConnectionAdapter
+    attr_reader :working_dir
+
+    def initialize(working_dir: Dir.pwd)
+      super
+      @working_dir = working_dir
+    end
+
+    def open(code, stdin, stdout, stderr)
+      result = nil
+
+      stdin = RemoteRuby::CompatIOReader.new(stdin)
+      stdout = RemoteRuby::CompatIOWriter.new(stdout)
+      stderr = RemoteRuby::CompatIOWriter.new(stderr)
+
+      with_temp_file(code) do |filename|
+        pid = Process.spawn(
+          command(filename),
+          in: stdin.readable,
+          out: stdout.writeable,
+          err: stderr.writeable
+        )
+
+        _, status = Process.wait2(pid)
+        raise "Process exited with code #{status}" unless status.success?
+
+        [stdin, stdout, stderr].each(&:join)
+
+        result = File.binread(filename)
+      end
+      result
+    end
+
+    def connection_name
+      "#{ENV.fetch('USER', nil)}@localhost:#{working_dir}> "
+    end
+
+    protected
+
+    def with_temp_file(code)
+      f = Tempfile.create('remote_ruby')
+      f.write(code)
+      f.close
+      yield f.path
+    ensure
+      File.unlink(f.path)
+    end
+
+    def command(code_path)
+      "cd \"#{working_dir}\" && ruby \"#{code_path}\""
+    end
+  end
+end

data/lib/remote_ruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RemoteRuby
-  VERSION = '0.2.1'
+  VERSION = '1.0.0'
 end

data/lib/remote_ruby.rb

@@ -1,27 +1,69 @@
 # frozen_string_literal: true
 
 require 'remote_ruby/version'
-require 'remote_ruby/execution_context'
+require 'remote_ruby/rails_plugin'
+require 'remote_ruby/extensions'
 
 # Namespace module for other RemoteRuby classes. Also contains methods, which
 # are included in the global scope
 module RemoteRuby
-  def remotely(args = {}, &block)
-    locals = args.delete(:locals)
-    execution_context = ::RemoteRuby::ExecutionContext.new(**args)
-    execution_context.execute(locals, &block)
-  end
+  DEFAULT_CONFIG_DIR_NAME = '.remote_ruby'
+  DEFAULT_CACHE_DIR_NAME = 'cache'
+  DEFAULT_CODE_DIR_NAME = 'code'
 
-  def self.root(*params)
-    root_dir = ::Gem::Specification.find_by_name('remote_ruby').gem_dir
-    File.join(root_dir, *params)
-  end
+  class << self
+    attr_reader :plugins, :ignored_types
+    attr_accessor :cache_dir, :code_dir, :suppress_parser_warnings
+
+    def root(*params)
+      root_dir = ::Gem::Specification.find_by_name('remote_ruby').gem_dir
+      File.join(root_dir, *params)
+    end
+
+    def ensure_cache_dir
+      FileUtils.mkdir_p(cache_dir)
+    end
+
+    def ensure_code_dir
+      FileUtils.mkdir_p(code_dir)
+    end
+
+    def lib_path(*params)
+      File.join(root, 'lib', *params)
+    end
+
+    def clear_cache
+      FileUtils.rm_rf(cache_dir)
+    end
 
-  def self.lib_path(*params)
-    File.join(root, 'lib', *params)
+    def clear_code
+      FileUtils.rm_rf(code_dir)
+    end
+
+    def register_plugin(name, klass)
+      @plugins ||= {}
+      @plugins[name] = klass
+    end
+
+    def ignore_types(*types)
+      @ignored_types ||= []
+      @ignored_types.concat(types)
+    end
+
+    def configure
+      yield self
+    end
   end
 end
 
-# rubocop:disable Style/MixinUsage
-include RemoteRuby
-# rubocop:enable Style/MixinUsage
+RemoteRuby.configure do |config|
+  config_dir = File.join(Dir.pwd, RemoteRuby::DEFAULT_CONFIG_DIR_NAME)
+  config.cache_dir = File.join(config_dir, RemoteRuby::DEFAULT_CACHE_DIR_NAME)
+  config.code_dir = File.join(config_dir, RemoteRuby::DEFAULT_CODE_DIR_NAME)
+
+  config.ignore_types RemoteRuby::ExecutionContext
+
+  config.suppress_parser_warnings = false
+
+  config.register_plugin(:rails, RemoteRuby::RailsPlugin)
+end