drbssh 0.5.0

data/.gitignore

@@ -0,0 +1,6 @@
+.bundle
+.vagrant
+.yardoc
+Gemfile.lock
+doc
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source :rubygems
+
+# Specify your gem's dependencies in rush.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,7 @@
+# -*- mode: ruby; tab-width: 2; indent-tabs-mode: nil -*-
+
+guard 'rspec', :version => 2, :cli => '--color' do
+  watch(/^spec\/(.*)_spec.rb/)
+  watch(/^lib\/(.*)\.rb/)         { |m| "spec/#{m[1]}_spec.rb" }
+  watch(/^spec\/spec_helper.rb/)  { "spec" }
+end

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2012 Kenneth Vestergaard
+
+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.

data/README.md

@@ -0,0 +1,31 @@
+# `drbssh`
+
+A protocol implementation for Distributed Ruby (DRb), supporting SSH-connections.
+
+## Usage
+
+```ruby
+	DRb.start_service 'drbssh://'
+	remote = DRbObject.new_with_uri("drbssh://remote/")
+	remote.eval('1+1')
+
+	remote = DRbObject.new_with_uri("drbssh://remote/path/to/ruby")
+```
+
+## Description
+
+`drbssh` makes it possible to create DRb-connections via SSH, with support for
+bi-directional communication. In contrast to other DRb protocols, DRbSSH *requires*
+that a local server is started before creating `DRbObject`s.
+
+A newly-created `DRbObject` pointing at a remote server will be pointing at an
+instance of `Binding`, representing the top-level of a newly-started Ruby
+interpreter. The only interesting function exposed is `eval`.
+
+## Development
+
+Uses a Vagrant VM with an Ubuntu-installation to serve as the remote end-point in tests.
+
+## TODOS
+
+* Use Net::SSH if installed/possible?

data/Vagrantfile

@@ -0,0 +1,38 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+Vagrant::Config.run do |config|
+  # All Vagrant configuration is done here. The most common configuration
+  # options are documented and commented below. For a complete reference,
+  # please see the online documentation at vagrantup.com.
+
+  # Every Vagrant virtual environment requires a box to build off of.
+  config.vm.box = "ubuntu-11.10+zfs-64bit"
+
+  # The url from where the 'config.vm.box' box will be fetched if it
+  # doesn't already exist on the user's system.
+  # config.vm.box_url = "http://domain.com/path/to/above.box"
+
+  # Boot with a GUI so you can see the screen. (Default is headless)
+  # config.vm.boot_mode = :gui
+
+  # Assign this VM to a host-only network IP, allowing you to access it
+  # via the IP. Host-only networks can talk to the host machine as well as
+  # any other machines on the same network, but cannot be accessed (through this
+  # network interface) by any external networks.
+  # config.vm.network :hostonly, "33.33.33.10"
+
+  # Assign this VM to a bridged network, allowing you to connect directly to a
+  # network using the host's network device. This makes the VM appear as another
+  # physical device on your network.
+  # config.vm.network :bridged
+
+  # Forward a port from the guest to the host, which allows for outside
+  # computers to access the VM, whereas host only networking does not.
+  # config.vm.forward_port 80, 8080
+
+  # Share an additional folder to the guest VM. The first argument is
+  # an identifier, the second is the path on the guest to mount the
+  # folder, and the third is the path on the host to the actual folder.
+  # config.vm.share_folder "v-data", "/vagrant_data", "../data"
+end

data/drbssh.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require 'rake'
+
+Gem::Specification.new do |s|
+	s.name        = "drbssh"
+	s.version     = "0.5.0"
+	s.platform    = Gem::Platform::RUBY
+	s.authors     = %w(kvs)
+	s.email       = %w(kvs@binarysolutions.dk)
+	s.homepage    = "https://github.com/kvs/drbssh"
+	s.summary     = "An SSH protocol driver for DRb"
+	s.description = %q{Allows DRb to create and use an SSH-connection.}
+
+	s.files            = `git ls-files`.split("\n")
+	s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
+	s.executables      = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+	s.require_paths    = ["lib"]
+
+	s.add_development_dependency "rspec", ["~> 2.8.0"]
+	s.add_development_dependency "guard-rspec"
+end

data/lib/drbssh.rb

@@ -0,0 +1,262 @@
+# -*- mode: ruby; tab-width: 4; indent-tabs-mode: t -*-
+
+require 'drb'
+require 'socket'
+
+# DRb protocol handler for using a persistent SSH connection to a remote server. Creates a duplex
+# connection so DRbUndumped objects can contact the initiating machine back through the same link.
+#
+# Contains all needed classes and no external dependencies, since this file will be read and sent
+# to the remote end, to bootstrap its protocol support without requiring anything but Ruby
+# installed.
+
+module DRb
+
+	class DRbSSHProtocol
+		def self.server; @server; end
+
+		# Open a client connection to the server at +uri+, using configuration +config+, and return it.
+		def self.open(uri, config)
+			raise DRbServerNotFound, "need to run a DRbSSH server first" if @server.nil? or @server.closed?
+
+			DRb.thread['DRbSSHLocalClient'] || DRbSSHRemoteClient.new(uri, @server)
+		end
+
+		# Open a server listening at +uri+, using configuration +config+, and return it.
+		def self.open_server(uri, config)
+			@server = nil if !@server.nil? and @server.closed?
+
+			raise DRbConnError, "server already running with different uri" if !@server.nil? and @server.uri != uri
+
+			@server ||= DRbSSHServer.new(uri, config)
+		end
+
+		# Parse +uri+ into a [uri, option] pair.
+		def self.uri_option(uri, config)
+			host, path = split_uri(uri)
+			host ||= Socket.gethostname
+			[ "drbssh://#{host}/#{path}", nil ]
+		end
+
+		# Split URI into component pairs
+		def self.split_uri(uri)
+			if uri.match('^drbssh://([^/?]+)?(?:/(.+))?$')
+				[ $1, $2 ]
+			else
+				raise DRbBadScheme,uri unless uri =~ /^drbssh:/
+				raise DRbBadURI, "can't parse uri: " + uri
+			end
+		end
+	end
+	DRbProtocol.add_protocol(DRbSSHProtocol)
+
+
+	# Base class for the DRbSSH clients.
+	class DRbSSHClient
+		attr_reader :receiveq
+		attr_reader :sendq
+		attr_reader :read_fd
+		attr_reader :write_fd
+
+		def initialize(server)
+			@receiveq, @sendq = Queue.new, Queue.new
+			@write_fd.sync = true
+
+			server.client_queue.push(self)
+		end
+
+		def send_request(ref, msg_id, arg, b)
+			@sendq.push(['req', [ref, msg_id, arg, b]])
+		end
+
+		def recv_reply
+			@receiveq.pop
+		end
+
+		def alive?
+			!self.read_fd.closed? && !self.write_fd.closed?
+		end
+	end
+
+
+	# DRbSSH remote client - does the heavy lifting of SSH'ing to a remote server and bootstrapping
+	# its Ruby interpreter for DRb communication.
+	class DRbSSHRemoteClient < DRbSSHClient
+		# Create an SSH-connection to +uri+, and spawn a server, so client has something to talk to
+		def initialize(uri, server)
+			# child-to-parent, parent-to-child
+			ctp_rd, ctp_wr = IO.pipe
+			ptc_rd, ptc_wr = IO.pipe
+
+			host, cmd = DRbSSHProtocol.split_uri(uri)
+
+			# Read the source-code for this file, and add bits for initialising the remote side.
+			# Since DRbSSHServer is doing all the filedescriptor read/writing, we need to start
+			# a DRbSSHLocalClient immediately.
+			self_code = <<-EOT
+				#{File.read(__FILE__)};
+				DRb.start_service("#{uri}", binding)
+				DRb.thread['DRbSSHLocalClient'] = DRb::DRbSSHLocalClient.new(DRb::DRbSSHProtocol.server)
+				DRb.thread.join
+			EOT
+
+			# Fork to create an SSH child-process
+			if fork.nil?
+				# In child - cleanup filehandles, reopen stdin/stdout, and exec ssh to connect to remote
+
+				ctp_rd.close
+				ptc_wr.close
+
+				$stdin.reopen(ptc_rd)
+				$stdout.reopen(ctp_wr)
+
+				cmd = ['ruby'] if cmd.nil? or cmd.empty?
+
+				# exec Ruby on remote end, and read bootstrap code.
+				exec("ssh", "-oBatchMode=yes", "-T", host, "exec", *cmd, '-e', "\"eval STDIN.read(#{self_code.bytesize})\"")
+				exit
+			else
+				# In parent - cleanup filehandles, write bootstrap-code, and hand over to superclass.
+
+				ctp_wr.close
+				ptc_rd.close
+
+				# Bootstrap remote Ruby.
+				ptc_wr.write(self_code)
+
+				@read_fd, @write_fd = ctp_rd, ptc_wr
+
+				super(server)
+			end
+		end
+
+		# Close client.
+		def close
+			# Closing the filedescriptors should trigger an IOError in the server-thread
+			# waiting, which makes it close the client attached.
+			self.read_fd.close
+			self.write_fd.close
+		end
+	end
+
+
+	# DRbSSH client used to contact local objects - used on remote side.
+	class DRbSSHLocalClient < DRbSSHClient
+		# Use stdin/stdout to talk with the local side of an SSH-connection.
+		def initialize(server)
+			@read_fd, @write_fd = $stdin, $stdout
+
+			super(server)
+		end
+
+		# Kill Ruby if client is asked to close.
+		def close
+			Kernel.exit 0
+		end
+	end
+
+
+	# Common DRb protocol server for DRbSSH. Waits on incoming clients on a thread-safe `Queue`,
+	# and spawns a new connection handler for each.
+	class DRbSSHServer
+		attr_reader :uri
+		attr_reader :client_queue
+
+		# Create new server.
+		def initialize(uri, config)
+			@uri = uri
+			@config = config
+			@client_queue = Queue.new
+			@clients = []
+		end
+
+		# Wait for clients to register themselves on the client_queue.
+		def accept
+			client = @client_queue.pop
+			@clients << DRbSSHServerConn.new(uri, @config, client)
+			@clients.last
+		end
+
+		# Close server by closing all clients.
+		def close
+			@clients.map(&:close)
+			@clients = nil
+		end
+
+		# Server is closed if +close+ has been called earlier.
+		def closed?
+			@clients.nil?
+		end
+	end
+
+
+	# DRbSSH protocol server per-connection class. Handles client-to-client communications
+	# by utilizing thread-safe Queue's for the input and output, and by adding a small
+	# 'rep' or 'req' packet before sending, so we can have two-way DRb duplexed over a
+	# single pair of filedescriptors.
+	class DRbSSHServerConn
+		attr_reader :uri
+
+		# Create a new server-connection for the specified +client+.
+		def initialize(uri, config, client)
+			@uri = uri
+			@client = client
+			@srv_requestq = Queue.new
+
+			msg = DRbMessage.new(config)
+
+			# Read-thread
+			Thread.new do
+				# Read from client, and delegate request/reply to the correct place.
+				begin
+					loop do
+						type = msg.load(client.read_fd)
+						if type == 'req'
+							@srv_requestq.push(msg.recv_request(client.read_fd))
+						else
+							client.receiveq.push(msg.recv_reply(client.read_fd))
+						end
+					end
+				rescue
+					client.close
+				end
+			end
+
+			# Write-thread
+			Thread.new do
+				# Wait for outgoing data on send queue, and add header-packet before
+				# writing.
+				begin
+					loop do
+						type, data = client.sendq.pop
+
+						client.write_fd.write(msg.dump(type))
+
+						if type == 'req'
+							msg.send_request(client.write_fd, *data)
+						else
+							msg.send_reply(client.write_fd, *data)
+						end
+					end
+				rescue
+					client.close
+				end
+			end
+		end
+
+		# Delegate shutdown to client.
+		def close
+			@client.close
+		end
+
+		# Wait for a request to appear on the request-queue
+		def recv_request
+			@srv_requestq.pop
+		end
+
+		# Queue client-reply
+		def send_reply(succ, result)
+			@client.sendq.push(['rep', [succ, result]])
+		end
+	end
+end

data/spec/drbssh_spec.rb

@@ -0,0 +1,77 @@
+# -*- mode: ruby; tab-width: 4; indent-tabs-mode: t -*-
+
+require 'drbssh'
+
+describe DRb::DRbSSHProtocol do
+	it "responds to drbssh:// URIs" do
+		described_class.uri_option("drbssh://localhost/ruby", {}).should eq [ "drbssh://localhost/ruby", nil ]
+		described_class.uri_option("drbssh://localhost", {}).should eq [ "drbssh://localhost/", nil ]
+		described_class.uri_option("drbssh://", {}).first.should match(/^drbssh:\/\//)
+
+		expect { described_class.uri_option("druby://localhost/ruby", {}) }.to raise_exception DRb::DRbBadScheme
+	end
+
+	it "starts and stops when requested" do
+		expect { DRb.current_server }.to raise_exception DRb::DRbServerNotFound
+		DRb.start_service("drbssh://localhost")
+		DRb.current_server.instance_variable_get("@protocol").should be_an_instance_of DRb::DRbSSHServer
+		DRb.stop_service
+		expect { DRb.current_server }.to raise_exception DRb::DRbServerNotFound
+	end
+
+	it "disallows running two drbssh-servers" do
+		DRb.start_service("drbssh://localhost")
+		expect { DRb.start_service("drbssh://localhost2") }.to raise_exception DRb::DRbConnError
+	end
+
+	it "creates DRbObjects with a URI pointed to itself" do
+		DRb.start_service("drbssh://localhost")
+		DRb::DRbObject.new({}.extend(DRbUndumped)).__drburi.should eq 'drbssh://localhost'
+		DRb.stop_service
+	end
+
+	it "connects to a remote Ruby" do
+		DRb.start_service("drbssh://localhost")
+		drb = DRbObject.new_with_uri("drbssh://vagrant-zfs/ruby")
+		drb.should be_an_instance_of DRb::DRbObject
+		drb.__drburi.should eq "drbssh://vagrant-zfs/ruby"
+
+		drb.eval("1+1").should eq 2
+		drb.eval("`hostname`").should eq "vagrant-ubuntu-oneiric\n"
+		drb.eval("{ foo: :bar }.extend DRb::DRbUndumped").should be_an_instance_of DRb::DRbObject
+		DRb.stop_service
+	end
+
+	it "allows two-way communication" do
+		DRb.start_service("drbssh://localhost")
+
+		drb = DRbObject.new_with_uri("drbssh://vagrant-zfs/ruby")
+
+		remote_hash = drb.eval("@a = {}.extend(DRb::DRbUndumped)")
+
+		# remote server gets started in main thread, with binding as front object.
+		# server spawns thread to run in, and another thread to run client-connection in.
+		# client connects, sends message,
+
+		# Set local Proc in remote hash, re-fetch it and call it. Works without two-way comms
+		remote_hash["a"] = lambda { return 1 }
+		drb.eval("@a['a']").call.should eq 1
+
+		# Call same Proc in a remote context. This means establishing a connection to the local side, since
+		# the Proc is really a DRbObject on the remote side.
+		drb.eval("@a['a'].call").should eq 1
+
+		DRb.stop_service
+	end
+
+	it "reconnects when connection has been terminated" do
+		DRb.start_service("drbssh://localhost")
+		drb = DRbObject.new_with_uri("drbssh://vagrant-zfs/ruby")
+		drb.eval("`hostname`").should eq "vagrant-ubuntu-oneiric\n"
+		pid = drb.eval('$$')
+
+		expect { drb.eval('Kernel.exit! 0') }.to raise_exception IOError
+
+		drb.eval('$$').should_not eq pid # should create new connection
+	end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+# -*- mode: ruby; tab-width: 4; indent-tabs-mode: t -*-

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: drbssh
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+  prerelease: 
+platform: ruby
+authors:
+- kvs
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70199265074880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: *70199265074880
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &70199265073940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70199265073940
+description: Allows DRb to create and use an SSH-connection.
+email:
+- kvs@binarysolutions.dk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Vagrantfile
+- drbssh.gemspec
+- lib/drbssh.rb
+- spec/drbssh_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/kvs/drbssh
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: An SSH protocol driver for DRb
+test_files:
+- spec/drbssh_spec.rb
+- spec/spec_helper.rb