remote_ruby 0.3.0 → 1.0.0

data/lib/remote_ruby/adapter_builder.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RemoteRuby
+  # Builds connection adapter based on the provided parameters.
+  # Can wrap the adapter in caching and text mode adapters.
+  class AdapterBuilder
+    attr_reader :adapter_params, :use_cache, :save_cache, :text_mode
+
+    def initialize(adapter_klass: nil, use_cache: false, save_cache: false, **params)
+      @adapter_klass = adapter_klass
+      @use_cache = use_cache
+      @save_cache = save_cache
+      @adapter_params = params
+
+      RemoteRuby.ensure_cache_dir if save_cache
+    end
+
+    def adapter_klass
+      return @adapter_klass if @adapter_klass
+
+      if adapter_params[:host]
+        ::RemoteRuby::SSHAdapter
+      else
+        ::RemoteRuby::TmpFileAdapter
+      end
+    end
+
+    def build(code_hash)
+      res = adapter_klass.new(**adapter_params)
+
+      cache_mode = use_cache && cache_exists?(code_hash)
+
+      if cache_mode
+        cache_adapter(code_hash, res.connection_name)
+      elsif save_cache
+        caching_adapter(res, code_hash)
+      else
+        res
+      end
+    end
+
+    def cache_adapter(code_hash, connection_name)
+      ::RemoteRuby::CacheAdapter.new(
+        cache_path: cache_path(code_hash),
+        connection_name: connection_name
+      )
+    end
+
+    def caching_adapter(adapter, code_hash)
+      ::RemoteRuby::CachingAdapter.new(
+        adapter: adapter,
+        cache_path: cache_path(code_hash)
+      )
+    end
+
+    def context_hash(code_hash)
+      Digest::MD5.hexdigest(
+        self.class.name +
+        adapter_klass.name.to_s +
+        adapter_params.to_s +
+        code_hash
+      )
+    end
+
+    def cache_path(code_hash)
+      hsh = context_hash(code_hash)
+      File.join(RemoteRuby.cache_dir, hsh)
+    end
+
+    def cache_exists?(code_hash)
+      hsh = cache_path(code_hash)
+      File.exist?("#{hsh}.stdout") || File.exist?("#{hsh}.stderr") || File.exist?("#{hsh}.result")
+    end
+  end
+end

data/lib/remote_ruby/cache_adapter.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RemoteRuby
+  # An adapter which takes stdout, stderr and result streams
+  # from files and ignores all stdin. Only used to read from cache.
+  class CacheAdapter < ConnectionAdapter
+    attr_reader :connection_name
+
+    def initialize(cache_path:, connection_name:)
+      super
+      @cache_path = cache_path
+      @connection_name = connection_name
+    end
+
+    def open(_code, _stdin, stdout, stderr)
+      IO.copy_stream(stdout_file_path, stdout)
+      IO.copy_stream(stderr_file_path, stderr)
+
+      File.binread(result_file_path) if result_file_path
+    end
+
+    private
+
+    attr_reader :cache_path
+
+    def stdout_file_path
+      fp = "#{cache_path}.stdout"
+      File.exist?(fp) ? fp : File::NULL
+    end
+
+    def stderr_file_path
+      fp = "#{cache_path}.stderr"
+      File.exist?(fp) ? fp : File::NULL
+    end
+
+    def result_file_path
+      fp = "#{cache_path}.result"
+      File.exist?(fp) ? fp : File::NULL
+    end
+  end
+end

data/lib/remote_ruby/{connection_adapter/caching_adapter.rb → caching_adapter.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'remote_ruby/stream_cacher'
+require 'remote_ruby/tee_writer'
 
 module RemoteRuby
   # An adapter decorator which extends the adapter passed in to its
@@ -12,17 +12,21 @@ module RemoteRuby
       @adapter = adapter
     end
 
-    def connection_name
-      adapter.connection_name
-    end
+    def open(code, stdin, stdout, stderr)
+      res = nil
+      with_cache do |stdout_cache, stderr_cache, result_cache|
+        tee_out = ::RemoteRuby::TeeWriter.new(stdout, stdout_cache)
+        tee_err = ::RemoteRuby::TeeWriter.new(stderr, stderr_cache)
 
-    def open(code)
-      with_cache do |stdout_cache, stderr_cache|
-        adapter.open(code) do |stdout, stderr|
-          yield ::RemoteRuby::StreamCacher.new(stdout, stdout_cache),
-          ::RemoteRuby::StreamCacher.new(stderr, stderr_cache)
-        end
+        res = adapter.open(code, stdin, tee_out, tee_err)
+        result_cache.write(res)
       end
+
+      res
+    end
+
+    def connection_name
+      adapter.connection_name
     end
 
     private
@@ -30,13 +34,15 @@ module RemoteRuby
     attr_reader :cache_path, :adapter
 
     def with_cache
-      stderr_cache = File.open(stderr_file_path, 'w')
-      stdout_cache = File.open(stdout_file_path, 'w')
+      stderr_cache = File.open(stderr_file_path, 'wb')
+      stdout_cache = File.open(stdout_file_path, 'wb')
+      result_cache = File.open(result_file_path, 'wb')
 
-      yield stdout_cache, stderr_cache
+      yield stdout_cache, stderr_cache, result_cache
     ensure
       stdout_cache.close
       stderr_cache.close
+      result_cache.close
     end
 
     def stdout_file_path
@@ -46,5 +52,9 @@ module RemoteRuby
     def stderr_file_path
       "#{cache_path}.stderr"
     end
+
+    def result_file_path
+      "#{cache_path}.result"
+    end
   end
 end

data/lib/remote_ruby/code_templates/compiler/main.rb.erb

@@ -1,44 +1,32 @@
 # Set up Bundler if Gemfile is present
 require 'bundler/setup' if File.exist?('Gemfile')
 
-require 'base64'
+<%= inline_file('remote_context.rb') %>
 
-__marshalled_locals_names__ = []
+__context__ = RemoteRuby::RemoteContext.new(__FILE__)
 
 # Unmarshalling local variables
 <% client_locals_base64.each do |name, base64_val| %>
-<%= name %> = begin
-  val = Marshal.load(Base64.strict_decode64('<%= base64_val %>'))
-  __marshalled_locals_names__ << :<%= name %>
-  val
-rescue ArgumentError
-  warn("Warning: could not resolve type for '<%=name %>' variable")
-  nil
-end
+<%= name %> = __context__.unmarshal(:<%= name %>, '<%= base64_val %>')
 <% end %>
 
-__return_val__ = begin
+$stdout.sync = true
+$stderr.sync = true
 
-<% if code_headers.any? %>
-  # Start of flavour-added code
- <%= code_headers.join %>
-  # End of flavour-added code
-<% end %>
+__context__.execute do
+<% if plugins.any? %>
+  # Start of plugin-added code
+<%plugins.each do |pl| %>
+  # <%= pl.class.name %>
+<%= pl.code_header.gsub(/^/,'  ') %>
+  # End of <%= pl.class.name %>
+<%end%>
+  # End of plugin-added code
 
+<% end %>
   # Start of client code
-<%= ruby_code %>
+<%= ruby_code.gsub(/^/, '  ') %>
   # End of client code
 end
 
-__marshalled_locals_names__ << :__return_val__
-
-# Marshalling local variables and result
-
-$stdout.puts "%%%MARSHAL"
-
-__marshalled_locals_names__.each do |lv|
-  data = Marshal.dump(eval(lv.to_s))
-  data_length = data.size
-  $stdout.puts "#{lv}:#{data_length}"
-  $stdout.write(data)
-end
+File.binwrite(__FILE__, __context__.dump)

data/lib/remote_ruby/compat_io_reader.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RemoteRuby
+  # Wraps any object that responds to #readpartial with a readable IO object
+  class CompatIOReader
+    attr_reader :readable
+
+    def initialize(io)
+      if io.is_a?(IO)
+        @readable = io
+        return
+      end
+
+      raise 'Object must respond to #readpartial' unless io.respond_to?(:readpartial)
+
+      @readable, @writeable = IO.pipe
+      @thread = start(io)
+    end
+
+    def join
+      return unless @writeable
+
+      @writeable.close
+      @thread.join
+      @readable.close
+    end
+
+    private
+
+    def start(io)
+      Thread.new do
+        IO.copy_stream(io, @writeable)
+      end
+    end
+  end
+end

data/lib/remote_ruby/compat_io_writer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RemoteRuby
+  # Wraps any object that responds to #write with a writeable IO object
+  class CompatIOWriter
+    attr_reader :writeable
+
+    def initialize(io)
+      if io.is_a?(IO)
+        @writeable = io
+        return
+      end
+
+      raise 'Object must respond to #write' unless io.respond_to?(:write)
+
+      @readable, @writeable = IO.pipe
+      @thread = start(io)
+    end
+
+    def join
+      return unless @readable
+
+      @readable.close
+      @thread.join
+      @writeable.close
+    end
+
+    private
+
+    def start(io)
+      Thread.new do
+        IO.copy_stream(@readable, io)
+      rescue IOError
+        nil
+      end
+    end
+  end
+end

data/lib/remote_ruby/compiler.rb

@@ -8,10 +8,10 @@ module RemoteRuby
   # Receives client Ruby code, locals and their values and creates Ruby code
   # to be executed on the remote host.
   class Compiler
-    def initialize(ruby_code, client_locals: {}, flavours: [])
+    def initialize(ruby_code, client_locals: {}, plugins: [])
       @ruby_code = ruby_code
       @client_locals = client_locals
-      @flavours = flavours
+      @plugins = plugins
     end
 
     def code_hash
@@ -23,10 +23,14 @@ module RemoteRuby
 
       template_file =
         ::RemoteRuby.lib_path('remote_ruby/code_templates/compiler/main.rb.erb')
-      template = ERB.new(File.read(template_file))
+      template = ERB.new(File.read(template_file), trim_mode: '<>')
       @compiled_code = template.result(binding)
     end
 
+    def inline_file(fname)
+      File.read(::RemoteRuby.lib_path('remote_ruby', fname))
+    end
+
     def client_locals_base64
       return @client_locals_base64 if @client_locals_base64
 
@@ -44,7 +48,7 @@ module RemoteRuby
 
     private
 
-    attr_reader :ruby_code, :client_locals, :flavours
+    attr_reader :ruby_code, :client_locals, :plugins
 
     def process_local(name, data)
       bin_data = Marshal.dump(data)
@@ -52,9 +56,5 @@ module RemoteRuby
     rescue TypeError => e
       warn "Cannot send variable '#{name}': #{e.message}"
     end
-
-    def code_headers
-      flavours.map(&:code_header)
-    end
   end
 end

data/lib/remote_ruby/connection_adapter.rb

@@ -1,30 +1,30 @@
 # frozen_string_literal: true
 
 module RemoteRuby
-  # Base class for other connection adapters.
+  # Base class for connection adapters.
   class ConnectionAdapter
     # Initializers of adapters should receive only keyword arguments.
     # May be overriden in a child class.
     def initialize(**args); end
 
-    # This will be displayed as a prefix when adapter writes something to
-    # emulated standard output or standard error. May be overriden in a child
-    # class.
-    def connection_name
-      self.class.name
+    # Override in child class.
+    # Accepts compiled Ruby code as string,
+    # readable IO for stdin, writable IO for stdout and stderr.
+    # Should return a binary result stream.
+    def open(_code, _stdin, _stdout, _stderr)
+      # :nocov:
+      raise NotImplementedError
+      # :nocov:
     end
 
-    # Override in child class. Receives Ruby code as string and yields
-    # two readable streams: for emulated standard output and standard error.
-    def open(_code)
-      raise NotImplementedError
+    def connection_name
+      "#{self.class.name} "
     end
   end
 end
 
-require 'remote_ruby/connection_adapter/eval_adapter'
-require 'remote_ruby/connection_adapter/stdin_process_adapter'
-require 'remote_ruby/connection_adapter/ssh_stdin_adapter'
-require 'remote_ruby/connection_adapter/local_stdin_adapter'
-require 'remote_ruby/connection_adapter/cache_adapter'
-require 'remote_ruby/connection_adapter/caching_adapter'
+require 'remote_ruby/cache_adapter'
+require 'remote_ruby/caching_adapter'
+require 'remote_ruby/ssh_adapter'
+require 'remote_ruby/tmp_file_adapter'
+require 'remote_ruby/text_mode_adapter'

data/lib/remote_ruby/execution_context.rb

@@ -7,53 +7,65 @@ require 'remote_ruby/compiler'
 require 'remote_ruby/connection_adapter'
 require 'remote_ruby/locals_extractor'
 require 'remote_ruby/source_extractor'
-require 'remote_ruby/flavour'
-require 'remote_ruby/runner'
+require 'remote_ruby/plugin'
+require 'remote_ruby/remote_context'
+require 'remote_ruby/remote_error'
+require 'remote_ruby/adapter_builder'
+require 'remote_ruby/text_mode_builder'
 
 module RemoteRuby
   # This class is responsible for executing blocks on the remote host with the
   # specified adapters. This is the entrypoint to RemoteRuby logic.
   class ExecutionContext
     def initialize(**params)
-      add_flavours(params)
-      @use_cache = params.delete(:use_cache)   || false
-      @save_cache = params.delete(:save_cache) || false
-      @cache_dir = params.delete(:cache_dir)   || File.join(Dir.pwd, 'cache')
-      @out_stream = params.delete(:out_stream) || $stdout
-      @err_stream = params.delete(:err_stream) || $stderr
-      @adapter_klass = params.delete(:adapter) || ::RemoteRuby::SSHStdinAdapter
-      @params = params
-
-      FileUtils.mkdir_p(@cache_dir)
+      add_plugins(params)
+      configure_streams(params)
+      @dump_code = params.delete(:dump_code) || false
+      @text_mode_builder = RemoteRuby::TextModeBuilder.new(
+        out_tty: out_stream.tty?,
+        err_tty: err_stream.tty?,
+        params: params
+      )
+      @adapter_builder = RemoteRuby::AdapterBuilder.new(**params)
     end
 
     def execute(locals = nil, &block)
       source = code_source(block)
       locals ||= extract_locals(block)
 
-      result = execute_code(source, **locals)
+      compiler = build_compiler(source, locals)
+      context = execute_code(compiler)
+
+      assign_locals(locals.keys, context.locals, block)
 
-      assign_locals(locals.keys, result[:locals], block)
+      if context.error?
+        raise RemoteRuby::RemoteError.new(
+          compiler.compiled_code,
+          context,
+          code_path(compiler.code_hash)
+        )
+      end
 
-      result[:result]
+      context.result
     end
 
     private
 
-    attr_reader :params, :adapter_klass, :use_cache, :save_cache, :cache_dir,
-                :out_stream, :err_stream, :flavours
+    attr_reader :dump_code, :in_stream, :out_stream, :err_stream, :plugins, :adapter_builder, :text_mode_builder
 
-    def assign_locals(local_names, values, block)
-      local_names.each do |local|
-        next unless values.key?(local)
+    def add_plugins(params)
+      @plugins = ::RemoteRuby::Plugin.build_plugins(params)
+    end
 
-        block.binding.local_variable_set(local, values[local])
-      end
+    def configure_streams(params)
+      @in_stream = params.delete(:in_stream)         || $stdin
+      @out_stream = params.delete(:out_stream)       || $stdout
+      @err_stream = params.delete(:err_stream)       || $stderr
     end
 
     def extract_locals(block)
       extractor =
-        ::RemoteRuby::LocalsExtractor.new(block, ignore_types: self.class)
+        ::RemoteRuby::LocalsExtractor.new(block, ignore_types: RemoteRuby.ignored_types)
       extractor.locals
     end
 
@@ -62,74 +74,44 @@ module RemoteRuby
       source_extractor.extract(&block)
     end
 
-    def context_hash(code_hash)
-      Digest::MD5.hexdigest(
-        self.class.name +
-        adapter_klass.name.to_s +
-        params.to_s +
-        code_hash
-      )
-    end
-
-    def cache_path(code_hash)
-      hsh = context_hash(code_hash)
-      File.join(cache_dir, hsh)
-    end
-
-    def cache_exists?(code_hash)
-      hsh = cache_path(code_hash)
-      File.exist?("#{hsh}.stdout") || File.exist?("#{hsh}.stderr")
-    end
-
-    def compiler(ruby_code, client_locals)
+    def build_compiler(ruby_code, client_locals)
       RemoteRuby::Compiler.new(
         ruby_code,
         client_locals: client_locals,
-        flavours: flavours
+        plugins: plugins
       )
     end
 
-    def execute_code(ruby_code, client_locals = {})
-      compiler = compiler(ruby_code, client_locals)
+    def execute_code(compiler)
+      write_code(compiler.code_hash, compiler.compiled_code)
 
-      runner = ::RemoteRuby::Runner.new(
-        code: compiler.compiled_code,
-        adapter: adapter(compiler.code_hash),
-        out_stream: out_stream,
-        err_stream: err_stream
-      )
+      adapter = adapter_builder.build(compiler.code_hash)
+      adapter = text_mode_builder.build(adapter)
 
-      runner.run
+      # rubocop:disable Security/MarshalLoad
+      Marshal.load(adapter.open(compiler.compiled_code, in_stream, out_stream, err_stream))
+      # rubocop:enable Security/MarshalLoad
     end
 
-    def adapter(code_hash)
-      actual_adapter = adapter_klass.new(**params)
+    def assign_locals(local_names, values, block)
+      local_names.each do |local|
+        next unless values.key?(local)
 
-      if use_cache && cache_exists?(code_hash)
-        cache_adapter(actual_adapter, code_hash)
-      elsif save_cache
-        caching_adapter(actual_adapter, code_hash)
-      else
-        actual_adapter
+        block.binding.local_variable_set(local, values[local])
       end
     end
 
-    def cache_adapter(adapter, code_hash)
-      ::RemoteRuby::CacheAdapter.new(
-        connection_name: adapter.connection_name,
-        cache_path: cache_path(code_hash)
-      )
-    end
+    def code_path(code_hash)
+      return nil unless dump_code
 
-    def caching_adapter(adapter, code_hash)
-      ::RemoteRuby::CachingAdapter.new(
-        adapter: adapter,
-        cache_path: cache_path(code_hash)
-      )
+      File.join(RemoteRuby.code_dir, "#{code_hash}.rb")
     end
 
-    def add_flavours(params)
-      @flavours = ::RemoteRuby::Flavour.build_flavours(params)
+    def write_code(code_hash, code)
+      return unless dump_code
+
+      RemoteRuby.ensure_code_dir
+      File.write(code_path(code_hash), code)
     end
   end
 end

data/lib/remote_ruby/extensions.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'remote_ruby/execution_context'
+
+module RemoteRuby
+  # Module to include in the global scope to provide the `remotely` method
+  module Extensions
+    def remotely(args = {}, &block)
+      locals = args.delete(:locals)
+      execution_context = ::RemoteRuby::ExecutionContext.new(**args)
+      execution_context.execute(locals, &block)
+    end
+  end
+end

data/lib/remote_ruby/parser_factory.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RemoteRuby
+  # Serves to dynamically require the parser gem and configure it.
+  # This is done in a separate module to have a possibility
+  # to suppress parser gem warnings about Ruby compatibility.
+  module ParserFactory
+    def self.require_parser
+      begin
+        prev = $VERBOSE
+        $VERBOSE = nil if RemoteRuby.suppress_parser_warnings
+        require 'parser/current'
+        require 'unparser'
+      ensure
+        $VERBOSE = prev
+      end
+
+      # 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
+    end
+  end
+end

data/lib/remote_ruby/plugin.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RemoteRuby
+  # Base class for Plugins to execution context to insert additonal
+  # code to the generated remote code.
+  class Plugin
+    class << self
+      def build_plugins(args = {})
+        res = []
+
+        RemoteRuby.plugins.each do |name, klass|
+          options = args.delete(name)
+
+          res << klass.new(**options) if options
+        end
+
+        res
+      end
+    end
+
+    def initialize(**args); end
+
+    def code_header; end
+  end
+end