remote_ruby 0.1

data/lib/remote_ruby/connection_adapter/eval_adapter.rb

@@ -0,0 +1,97 @@
+module RemoteRuby
+  # An adapter to expecute Ruby code in the current process in an isolated
+  # scope
+  class EvalAdapter < ConnectionAdapter
+    attr_reader :async, :working_dir
+
+    def initialize(working_dir: Dir.pwd, async: false)
+      @async = async
+      @working_dir = working_dir
+    end
+
+    def connection_name
+      ''
+    end
+
+    def open(code)
+      if async
+        run_async(code) do |out, err|
+          yield out, err
+        end
+      else
+        run_sync(code) do |out, err|
+          yield out, err
+        end
+      end
+    end
+
+    private
+
+    def run_code(code)
+      binder = Object.new
+
+      Dir.chdir(working_dir) do
+        binder.instance_eval(code)
+      end
+    end
+
+    def run_sync(code)
+      with_stringio do |tmp_stdout, tmp_stderr|
+        with_tmp_streams(tmp_stdout, tmp_stderr) do
+          run_code(code)
+        end
+
+        tmp_stdout.close_write
+        tmp_stderr.close_write
+        tmp_stdout.rewind
+        tmp_stderr.rewind
+        yield tmp_stdout, tmp_stderr
+      end
+    end
+
+    def run_async(code)
+      with_pipes do |out_read, out_write, err_read, err_write|
+        Thread.new do
+          with_tmp_streams(out_write, err_write) do
+            run_code(code)
+          end
+
+          out_write.close
+          err_write.close
+        end
+
+        yield out_read, err_read
+      end
+    end
+
+    def with_pipes
+      out_read, out_write = IO.pipe
+      err_read, err_write = IO.pipe
+      yield out_read, out_write, err_read, err_write
+    ensure
+      out_read.close
+      err_read.close
+    end
+
+    def with_stringio
+      out = StringIO.new
+      err = StringIO.new
+
+      yield out, err
+    ensure
+      out.close
+      err.close
+    end
+
+    def with_tmp_streams(out, err)
+      old_stdout = $stdout
+      old_stderr = $stderr
+      $stdout = out
+      $stderr = err
+      yield
+    ensure
+      $stdout = old_stdout
+      $stderr = old_stderr
+    end
+  end
+end

data/lib/remote_ruby/connection_adapter/local_stdin_adapter.rb

@@ -0,0 +1,21 @@
+module RemoteRuby
+  # An adapter to expecute Ruby code on the local macine
+  # inside a specified directory
+  class LocalStdinAdapter < ::RemoteRuby::StdinProcessAdapter
+    attr_reader :working_dir
+
+    def initialize(working_dir: '.')
+      @working_dir = working_dir
+    end
+
+    def connection_name
+      working_dir
+    end
+
+    private
+
+    def command
+      "cd \"#{working_dir}\" && ruby"
+    end
+  end
+end

data/lib/remote_ruby/connection_adapter/ssh_stdin_adapter.rb

@@ -0,0 +1,25 @@
+module RemoteRuby
+  # An adapter to execute Ruby code on the remote server via SSH
+  class SSHStdinAdapter < StdinProcessAdapter
+    attr_reader :server, :working_dir, :user, :key_file
+
+    def initialize(server:, working_dir: '~', user: nil, key_file: nil)
+      @working_dir = working_dir
+      @server = user.nil? ? server : "#{user}@#{server}"
+      @user = user
+      @key_file = key_file
+    end
+
+    def connection_name
+      "#{server}:#{working_dir}"
+    end
+
+    private
+
+    def command
+      command = 'ssh'
+      command = "#{command} -i #{key_file}" if key_file
+      "#{command} #{server} \"cd #{working_dir} && ruby\""
+    end
+  end
+end

data/lib/remote_ruby/connection_adapter/stdin_process_adapter.rb

@@ -0,0 +1,33 @@
+require 'open3'
+
+module RemoteRuby
+  # Base class for adapters which launch an external process to execute
+  # Ruby code and send the code to its standard input.
+  class StdinProcessAdapter < ::RemoteRuby::ConnectionAdapter
+    include Open3
+
+    def open(code)
+      result = nil
+
+      popen3(command) do |stdin, stdout, stderr, wait_thr|
+        stdin.write(code)
+        stdin.close
+
+        yield stdout, stderr
+
+        result = wait_thr.value
+      end
+
+      return if result.success?
+
+      raise "Remote connection exited with code #{result}"
+    end
+
+    protected
+
+    # Command to run an external process. Override in a child class.
+    def command
+      raise NotImplementedError
+    end
+  end
+end

data/lib/remote_ruby/connection_adapter.rb

@@ -0,0 +1,28 @@
+module RemoteRuby
+  # Base class for other 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
+    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
+    end
+  end
+end
+
+require 'remote_ruby/connection_adapter/eval_adapter.rb'
+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'

data/lib/remote_ruby/execution_context.rb

@@ -0,0 +1,134 @@
+require 'digest'
+require 'fileutils'
+
+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'
+
+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
+    # rubocop:disable Metrics/CyclomaticComplexity
+    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)
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+
+    def execute(locals = nil, &block)
+      source = code_source(block)
+      locals ||= extract_locals(block)
+
+      result = execute_code(source, **locals)
+
+      assign_locals(locals.keys, result[:locals], block)
+
+      result[:result]
+    end
+
+    private
+
+    attr_reader :params, :adapter_klass, :use_cache, :save_cache, :cache_dir,
+                :out_stream, :err_stream, :flavours
+
+    def assign_locals(local_names, values, block)
+      local_names.each do |local|
+        next unless values.key?(local)
+        block.binding.local_variable_set(local, values[local])
+      end
+    end
+
+    def extract_locals(block)
+      extractor =
+        ::RemoteRuby::LocalsExtractor.new(block, ignore_types: self.class)
+      extractor.locals
+    end
+
+    def code_source(block)
+      source_extractor = ::RemoteRuby::SourceExtractor.new
+      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)
+      RemoteRuby::Compiler.new(
+        ruby_code,
+        client_locals: client_locals,
+        flavours: flavours
+      )
+    end
+
+    def execute_code(ruby_code, client_locals = {})
+      compiler = compiler(ruby_code, client_locals)
+
+      runner = ::RemoteRuby::Runner.new(
+        code: compiler.compiled_code,
+        adapter: adapter(compiler.code_hash),
+        out_stream: out_stream,
+        err_stream: err_stream
+      )
+
+      runner.run
+    end
+
+    def adapter(code_hash)
+      actual_adapter = adapter_klass.new(params)
+
+      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
+      end
+    end
+
+    def cache_adapter(adapter, code_hash)
+      ::RemoteRuby::CacheAdapter.new(
+        connection_name: adapter.connection_name,
+        cache_path: cache_path(code_hash)
+      )
+    end
+
+    def caching_adapter(adapter, code_hash)
+      ::RemoteRuby::CachingAdapter.new(
+        adapter: adapter,
+        cache_path: cache_path(code_hash)
+      )
+    end
+
+    def add_flavours(params)
+      @flavours = ::RemoteRuby::Flavour.build_flavours(params)
+    end
+  end
+end

data/lib/remote_ruby/flavour/rails_flavour.rb

@@ -0,0 +1,19 @@
+module RemoteRuby
+  # Flavour to load Rails environment
+  class RailsFlavour < ::RemoteRuby::Flavour
+    def initialize(environment: :development)
+      @environment = environment
+    end
+
+    def code_header
+      <<-RUBY
+  ENV['RAILS_ENV'] = '#{environment}'
+  require './config/environment'
+      RUBY
+    end
+
+    private
+
+    attr_reader :environment
+  end
+end

data/lib/remote_ruby/flavour.rb

@@ -0,0 +1,25 @@
+module RemoteRuby
+  # Base class for Flavours: addons to execution context to insert additonal
+  # code to the generated remote code.
+  class Flavour
+    def self.build_flavours(params = {})
+      res = []
+
+      {
+        rails: RemoteRuby::RailsFlavour
+      }.each do |name, klass|
+        options = params.delete(name)
+
+        res << klass.new(**options) if options
+      end
+
+      res
+    end
+
+    def initialize(params: {}); end
+
+    def code_header; end
+  end
+end
+
+require 'remote_ruby/flavour/rails_flavour'

data/lib/remote_ruby/locals_extractor.rb

@@ -0,0 +1,41 @@
+module RemoteRuby
+  # Extracts local variable from given context
+  class LocalsExtractor
+    attr_reader :block, :ignore_types
+
+    def initialize(block, ignore_types: [])
+      @block = block
+      @ignore_types = Array(ignore_types)
+    end
+
+    def locals
+      locals = {}
+
+      local_variable_names.each do |name|
+        value = block.binding.eval(name.to_s)
+        next if ignored_type?(value)
+        locals[name] = value
+      end
+
+      locals
+    end
+
+    private
+
+    def local_variable_names
+      if RUBY_VERSION >= '2.2'
+        block.binding.local_variables
+      else
+        # A hack to support Ruby 2.1 due to the absence
+        # of Binding#local_variables method. For some reason
+        # just calling `block.binding.send(:local_variables)`
+        # returns variables of the current context.
+        block.binding.eval('binding.send(:local_variables)')
+      end
+    end
+
+    def ignored_type?(var)
+      ignore_types.any? { |klass| var.is_a? klass }
+    end
+  end
+end

data/lib/remote_ruby/runner.rb

@@ -0,0 +1,53 @@
+require 'colorize'
+
+require 'remote_ruby/unmarshaler'
+
+module RemoteRuby
+  # Runner class is responsible for running a prepared Ruby code with given
+  # connection adapter, reading output and unmarshalling result and local
+  # variables values.
+  class Runner
+    def initialize(code:, adapter:, out_stream: $stdout, err_stream: $stderr)
+      @code = code
+      @adapter = adapter
+      @out_stream = out_stream
+      @err_stream = err_stream
+    end
+
+    def run
+      locals = nil
+
+      adapter.open(code) do |stdout, stderr|
+        out_thread = read_stream(stdout, out_stream, :green)
+        err_thread = read_stream(stderr, err_stream, :red)
+        [out_thread, err_thread].each(&:join)
+        locals = out_thread[:locals]
+      end
+
+      { result: locals[:__return_val__], locals: locals }
+    end
+
+    private
+
+    attr_reader :code, :adapter, :out_stream, :err_stream
+
+    def read_stream(read_from, write_to, color)
+      Thread.new do
+        until read_from.eof?
+          line = read_from.readline
+
+          if line.start_with?('%%%MARSHAL')
+            Thread.current[:locals] ||= unmarshal(read_from)
+          else
+            write_to.puts "#{adapter.connection_name.send(color)}>\t#{line}"
+          end
+        end
+      end
+    end
+
+    def unmarshal(stdout)
+      unmarshaler = RemoteRuby::Unmarshaler.new(stdout)
+      unmarshaler.unmarshal
+    end
+  end
+end

data/lib/remote_ruby/source_extractor.rb

@@ -0,0 +1,39 @@
+require 'method_source'
+require 'parser/current'
+require 'unparser'
+
+module RemoteRuby
+  # Receives a block and extracts Ruby code (as a string) with this block's
+  # source
+  class SourceExtractor
+    def extract(&block)
+      ast = Parser::CurrentRuby.parse(block.source)
+      block_node = find_block(ast)
+
+      return '' unless block_node
+
+      _, body = parse(block_node)
+      Unparser.unparse(body)
+    end
+
+    private
+
+    def find_block(node)
+      return nil unless node.is_a? AST::Node
+      return node if node.type == :block
+
+      node.children.each do |child|
+        res = find_block(child)
+        return res if res
+      end
+
+      nil
+    end
+
+    def parse(node)
+      args = node.children[1].children
+      body = node.children[2]
+      [args, body]
+    end
+  end
+end

data/lib/remote_ruby/stream_cacher.rb

@@ -0,0 +1,34 @@
+module RemoteRuby
+  # Decorates the source stream and writes to the cache stream as
+  # the source is being read
+  class StreamCacher
+    def initialize(source_stream, cache_stream)
+      @source_stream = source_stream
+      @cache_stream = cache_stream
+    end
+
+    def read(*args)
+      res = source_stream.read(*args)
+      cache_stream.write(res)
+      res
+    end
+
+    def readline
+      res = source_stream.readline
+      cache_stream.write(res)
+      res
+    end
+
+    def eof?
+      source_stream.eof?
+    end
+
+    def close
+      source_stream.close
+    end
+
+    private
+
+    attr_reader :source_stream, :cache_stream
+  end
+end

data/lib/remote_ruby/unmarshaler.rb

@@ -0,0 +1,58 @@
+module RemoteRuby
+  # Unmarshals variables from given stream
+  class Unmarshaler
+    UnmarshalError = Class.new(StandardError)
+
+    def initialize(stream, terminator = nil)
+      @stream = stream
+      @terminator = terminator
+    end
+
+    def unmarshal
+      res = {}
+
+      until stream.eof?
+        line = stream.readline
+
+        break if terminator && line == terminator
+
+        var = read_var(line)
+        res[var.first] = var[1]
+      end
+
+      res
+    end
+
+    private
+
+    attr_reader :stream, :terminator
+
+    def read_var(line)
+      varname, length = read_var_header(line)
+      data = read_var_data(length)
+      [varname.to_sym, data]
+    rescue ArgumentError => e
+      raise UnmarshalError,
+            "Could not resolve type for #{varname} variable: #{e.message}"
+    rescue TypeError
+      raise UnmarshalError, 'Incorrect data format'
+    end
+
+    def read_var_header(line)
+      varname, length = line.split(':')
+
+      if varname.nil? || length.nil?
+        raise UnmarshalError, "Incorrect header '#{line}'"
+      end
+
+      [varname, length]
+    end
+
+    # rubocop:disable Security/MarshalLoad
+    def read_var_data(length)
+      data = stream.read(length.to_i)
+      Marshal.load(data)
+    end
+    # rubocop:enable Security/MarshalLoad
+  end
+end

data/lib/remote_ruby/version.rb

@@ -0,0 +1,3 @@
+module RemoteRuby
+  VERSION = '0.1'.freeze
+end

data/lib/remote_ruby.rb

@@ -0,0 +1,25 @@
+require 'remote_ruby/version'
+require 'remote_ruby/execution_context'
+
+# 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
+
+  def self.root(*params)
+    root_dir = ::Gem::Specification.find_by_name('remote_ruby').gem_dir
+    File.join(root_dir, *params)
+  end
+
+  def self.lib_path(*params)
+    File.join(root, 'lib', *params)
+  end
+end
+
+# rubocop:disable Style/MixinUsage
+include RemoteRuby
+# rubocop:enable Style/MixinUsage

data/remote_ruby.gemspec

@@ -0,0 +1,29 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'remote_ruby/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'remote_ruby'
+  spec.version       = RemoteRuby::VERSION
+  spec.authors       = ['Nikita Chernukhin']
+  spec.email         = ['nuinuhin@gmail.com']
+
+  spec.summary       = 'Execute Ruby code on the remote servers.'
+  spec.description   =
+    'Execute Ruby code on the remote servers from local Ruby script.'
+  spec.homepage      = 'https://github.com/nu-hin/remote_ruby'
+  spec.license       = 'MIT'
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+
+  spec.bindir        = 'bin'
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'colorize', '~> 0.8'
+  spec.add_runtime_dependency 'method_source', '~> 0.9'
+  spec.add_runtime_dependency 'parser', '~> 2.5'
+  spec.add_runtime_dependency 'unparser', '~> 0.2'
+end