redpack 1.0.1 → 1.0.2

data/rblib/redpack.rb

@@ -0,0 +1,35 @@
+#
+# RedPack-RPC for Ruby modified from MessagePack-RPC
+#
+# Copyright (C) 2010 FURUHASHI Sadayuki
+# Copyright (C) 2010 Lux Delux Inc
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'rblib'))
+
+module RedPack  #:nodoc:
+end
+
+require 'bson'
+require 'redis'
+require 'em-redis'
+require 'redpack/base'
+require 'redpack/dispatcher'
+require 'redpack/future'
+require 'redpack/client'
+require 'redpack/exception'
+require 'redpack/message'
+require 'redpack/server'
+require 'redpack/transport'

data/rblib/redpack/base.rb

@@ -0,0 +1,45 @@
+#
+# RedPack-RPC for Ruby modified from MessagePack-RPC
+#
+# Copyright (C) 2010 FURUHASHI Sadayuki
+# Copyright (C) 2010 Lux Delux Inc
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+module RedPack
+
+module MessageReceiver
+	def on_message(msg, *ctx)
+		case msg[0]
+		when REQUEST
+			on_request(msg[1], msg[2], msg[3], *ctx)
+		when RESPONSE
+			on_response(msg[1], msg[2], msg[3], *ctx)
+		when NOTIFY
+			on_notify(msg[1], msg[2], *ctx)
+		else
+			raise RPCError.new("unknown message type #{msg[0]}")
+		end
+	end
+
+	#def on_request(msgid, method, param)
+	#end
+
+	#def on_notify(method, param)
+	#end
+
+	#def on_response(msgid, error, result)
+	#end
+end
+
+end

data/rblib/redpack/client.rb

@@ -0,0 +1,144 @@
+#
+# RedPack-RPC for Ruby modified from MessagePack-RPC
+#
+# Copyright (C) 2010 FURUHASHI Sadayuki
+# Copyright (C) 2010 Lux Delux Inc
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+module RedPack
+
+class Client
+	def initialize(name, redis_options = {:host => 'localhost'})
+		@timeout = 10
+		@seqid = 0
+		@reqtable = {}
+		@transport = RedisClientTransport.new(self, redis_options, name)
+	end
+	attr_accessor :timeout
+
+	# call-seq:
+	#   notify(symbol, *args) -> nil
+	#
+	# Calls remote method with NOTIFY protocol.
+	# It doesn't require server to return results.
+	# This method is non-blocking and returns nil.
+	def notify(method, *args)
+		send_notify(method, args)
+		nil
+	end
+	
+	# call code like this for sync calls:
+	#   counter = client.increment_remote_counter_sync(1, 2, 3)
+	# 
+	# call code like this for async non-blocking calls:
+	#   client.increment_remote_counter_async(1, 2, 3) do |error, result|
+	#     if error
+	#       raise "we got an error"
+	#     else
+	#       counter = result
+	#     end
+	#   end
+	def method_missing(method, *args, &block)
+	  method_name = method.to_s
+	  sync = method_name.end_with?("_sync")
+	  async = method_name.end_with?("_async")
+    if sync || async
+	    method_name.gsub!(/_sync$/, '') if sync
+	    method_name.gsub!(/_async$/, '') if async
+	    future = send_request(method_name, args)
+  		future.attach_callback(block) if block
+  		if sync
+  		  @transport.listen_for_return_sync
+  		  future.get
+  		  if future.error
+  		    raise error
+		    else
+		      return future.result
+	      end
+	    elsif async
+  		  @transport.listen_for_return_async
+	      return future
+      end
+    else
+      super
+    end
+  end
+  
+
+	# Closes underlaying Transport and destroy resources.
+	def close
+	  @timer.detach if @timer.attached?
+	  @reqtable = {}
+		@transport.close
+		@seqid = 0
+		self
+	end
+	
+	# from ClientTransport
+	def on_response(sock, msgid, error, result)  #:nodoc:
+		if future = @reqtable.delete(msgid)
+			future.set_result(error, result)
+		end
+	end
+
+	# from ClientTransport
+	def on_connect_failed  #:nodoc:
+		@reqtable.reject! {|msgid, future|
+			begin
+				future.set_result ConnectError.new, nil
+			rescue
+			end
+			true
+		}
+		nil
+	end
+
+	# from Client, SessionPool
+	def step_timeout  #:nodoc:
+		timedout = []
+		@reqtable.reject! {|msgid, future|
+			if future.step_timeout
+				timedout.push(future)
+				true
+			end
+		}
+		timedout.each {|future|
+			begin
+				future.set_result TimeoutError.new, nil
+			rescue
+			end
+		}
+		!@reqtable.empty?
+	end
+
+
+	private
+	def send_request(method, param)
+		method = method.to_s
+		msgid = @seqid
+		@seqid += 1; if @seqid >= 1<<31 then @seqid = 0 end
+		data = [REQUEST, msgid, method, param]
+		@transport.send_data(data, msgid)
+		@reqtable[msgid] = Future.new(self)
+	end
+
+	def send_notify(method, param)
+		method = method.to_s
+		data = [NOTIFY, method, param]
+		@transport.send_data(data, nil)
+		nil
+	end
+end
+
+end

data/rblib/redpack/dispatcher.rb

@@ -0,0 +1,106 @@
+#
+# RedPack-RPC for Ruby modified from MessagePack-RPC
+#
+# Copyright (C) 2010 FURUHASHI Sadayuki
+# Copyright (C) 2010 Lux Delux Inc
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+module RedPack
+
+
+class AsyncResult
+	def initialize
+		@responder = nil
+		@sent = false
+	end
+
+	def result(retval, err = nil)
+		unless @sent
+			if @responder
+				@responder.result(retval, err)
+			else
+				@result = [retval, err]
+			end
+			@sent = true
+		end
+		nil
+	end
+
+	def error(err)
+		result(nil, err)
+		nil
+	end
+
+	def set_responder(res)  #:nodoc:
+		@responder = res
+		if @sent && @result
+			@responder.result(*@result)
+			@result = nil
+		end
+	end
+end
+
+
+class ObjectDispatcher
+	def initialize(obj, accept = obj.public_methods)
+		@obj = obj
+		@accept = accept.map {|m| m.is_a?(Integer) ? m : m.to_s }
+	end
+
+	def dispatch_request(session, method, param, responder)
+		begin
+			sent = false
+			early_result = nil
+			result = forward_method(session, method, param) do |result_|
+				unless result_.is_a?(AsyncResult)
+					responder.result(result_)
+					sent = true
+				end
+				early_result = result_
+			end
+
+		# FIXME on NoMethodError
+		# res.error(NO_METHOD_ERROR); return
+
+		# FIXME on ArgumentError
+		# res.error(ArgumentError); return
+
+		rescue
+			responder.error($!.to_s)
+			return
+		end
+
+		if early_result.is_a?(AsyncResult)
+			early_result.set_responder(responder)
+		elsif sent
+			return
+		elsif result.is_a?(AsyncResult)
+			result.set_responder(responder)
+		else
+			responder.result(result)
+		end
+	end
+
+	def dispatch_notify(session, method, param)
+		forward_method(session, method, param)
+	rescue
+	end
+
+	private
+	def forward_method(session, method, param, &block)
+		@obj.send(method, *param, &block)
+	end
+end
+
+end

data/rblib/redpack/exception.rb

@@ -0,0 +1,50 @@
+#
+# RedPack-RPC for Ruby modified from MessagePack-RPC
+#
+# Copyright (C) 2010 FURUHASHI Sadayuki
+# Copyright (C) 2010 Lux Delux Inc
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+module RedPack
+
+class Error < StandardError
+end
+
+class RPCError < Error
+	def initialize(msg)
+		super(msg)
+	end
+end
+
+class RemoteError < RPCError
+	def initialize(msg, result = nil)
+		super(msg)
+		@result = result
+	end
+	attr_reader :result
+end
+
+class TimeoutError < Error
+	def initialize(msg = "request timed out")
+		super
+	end
+end
+
+class ConnectError < TimeoutError
+	def initialize(msg = "connect failed")
+		super
+	end
+end
+
+end

data/rblib/redpack/future.rb

@@ -0,0 +1,101 @@
+#
+# RedPack-RPC for Ruby modified from MessagePack-RPC
+#
+# Copyright (C) 2010 FURUHASHI Sadayuki
+# Copyright (C) 2010 Lux Delux Inc
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+module RedPack
+
+
+# Future describes result of remote procedure call that is initially not known,
+# because it is not yet received.
+# You can wait and get the result with get method.
+class Future
+	def initialize(session, callback = nil)  #:nodoc:
+		@timeout = session.timeout
+		@callback_handler = callback
+		@error_handler = nil
+		@result_handler = nil
+		@set = false
+		@error = nil
+		@result = nil
+	end
+	attr_accessor :result, :error
+
+	# Wait for receiving result of remote procedure call and returns its result.
+	# If the remote method raises error, then this method raises RemoteError.
+	# If the remote procedure call failed with timeout, this method raises TimeoutError.
+	# Otherwise this method returns the result of remote method.
+	def get
+		join
+		if error.nil?
+			if @result_handler
+				return @result_handler.call(@result)
+			else
+				return @result
+			end
+		end
+		if @error_handler
+			return @error_handler.call(self)
+		else
+			raise @error if @error.is_a?(Error)
+			raise RemoteError.new(@error, @result)
+		end
+	end
+
+	# Wait for receiving result of remote procedure call.
+	# This method returns self.
+	# If a callback method is attached, it will be called.
+	def join
+		until @set
+		  sleep(0.0001)
+		end
+		self
+	end
+
+	# call-seq:
+	#   attach_callback {|future|  }
+	#
+	# Attaches a callback method that is called when the result of remote method is received.
+	def attach_callback(proc = nil, &block)
+		@callback_handler = proc || block
+	end
+
+	# For IDL
+	def attach_error_handler(proc = nil, &block)  #:nodoc:
+		@error_handler = proc || block
+	end
+
+	# For IDL
+	def attach_result_handler(proc = nil, &block)  #:nodoc:
+		@result_handler = proc || block
+	end
+
+	def set_result(err, res)  #:nodoc:
+		@error  = err
+		@result = res
+		if @callback_handler
+			if @callback_handler.arity == 2
+				# FIXME backward compatibility
+				@callback_handler.call(error, result)
+			else
+				@callback_handler.call(self)
+			end
+		end
+		@set = true
+	end
+end
+
+end

data/rblib/redpack/message.rb

@@ -0,0 +1,12 @@
+module RedPack
+
+REQUEST  = 0    # [0, msgid, method, param]
+RESPONSE = 1    # [1, msgid, error, result]
+NOTIFY   = 2    # [2, method, param]
+
+NO_METHOD_ERROR = 0x01;
+ARGUMENT_ERROR  = 0x02;
+
+REDIS_DATA = 535 # == 'redis'.split('').inject(0) {|sum,x| sum+=x.ord} -- I know this is lame, but had to think of something!
+
+end

data/rblib/redpack/server.rb

@@ -0,0 +1,88 @@
+#
+# RedPack-RPC for Ruby modified from MessagePack-RPC
+#
+# Copyright (C) 2010 FURUHASHI Sadayuki
+# Copyright (C) 2010 Lux Delux Inc
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+module RedPack
+
+# Server is usable for RPC server.
+class Server
+  def initialize(name, obj, redis_options = {:host => 'localhost'})
+    @dispatcher = nil
+    @obj = obj
+    @listener = RedisServerTransport.new(name, redis_options)
+  end
+  
+	def serve(obj, accept = obj.public_methods)
+		@dispatcher = ObjectDispatcher.new(obj, accept)
+		self
+	end
+
+	# 1. listen(listener, obj = nil, accept = obj.public_methods)
+	# 2. listen(host, port, obj = nil, accept = obj.public_methods)
+	def start()
+		unless @obj.nil?
+			serve(@obj, @obj.public_methods)
+		end
+
+		@listener.listen(self)
+		nil
+	end
+
+	def close
+	  @listener.close
+	end
+
+	# from ServerTransport
+	def on_request(sendable, msgid, method, param)  #:nodoc:
+		responder = Responder.new(sendable, msgid)
+		@dispatcher.dispatch_request(self, method, param, responder)
+	end
+
+	# from ServerTransport
+	def on_notify(method, param)  #:nodoc:
+		@dispatcher.dispatch_notify(self, method, param)
+	end
+end
+
+
+class Responder
+	def initialize(sendable, msgid)
+		@sendable = sendable  # send_message method is required
+		@msgid = msgid
+		@sent = false
+	end
+
+	def sent?
+		@sent
+	end
+
+	def result(retval, err = nil)
+		unless @sent
+			data = [RESPONSE, @msgid, err, retval]
+			@sendable.send_data(data)
+  		@sendable.finish(@msgid)
+			@sent = true
+		end
+		nil
+	end
+
+	def error(err, retval = nil)
+		result(retval, err)
+	end
+end
+
+end

data/rblib/redpack/transport.rb

@@ -0,0 +1,196 @@
+#
+# RedPack-RPC for Ruby modified from MessagePack-RPC
+#
+# Copyright (C) 2010 FURUHASHI Sadayuki
+# Copyright (C) 2010 Lux Delux Inc
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+module RedPack
+
+module Util
+  # convert a binary sring into an array of bytes
+  def to_bytes(binary_string)
+    binary_string.unpack('c*')
+  end
+
+  # convert an array of bytes into a binary string
+  def to_binary_string(bytes)
+    bytes.pack('c*')
+  end
+end
+
+class RedisClientTransport
+  include Util
+  attr_reader :identifier
+
+  # Pass in {:ignore_return_value => true} as part of the redis_options so that the server doesn't put the return
+  # object in a queue.  This is useful if you're doing call_async and never care about the return value.  It saves
+  # Redis from adding a key/list pair.  A synchronous call will result in an immediate timeout exception.
+	def initialize(client, redis_options, name)
+		@client = client
+		@queue_name = "redpack_request_queue:#{name}"
+    @ignore_return_value = !!redis_options.delete(:ignore_return_value)
+    if @ignore_return_value
+      @client.timeout = 0
+    else
+      @client.timeout = 15
+    end
+
+    @redis_options = redis_options
+    @redis = Redis.new(redis_options)
+
+		# assign a unique client key for this instance which will be used for return values
+		@identifier = @redis.incr("redpack_response_queue_index")
+		@return_queue_name = "redpack_response_queue:#{@identifier}"
+		@unprocessed_requests_name = "#{@return_queue_name}:unprocessed"
+		@pool = 0
+	end
+
+  def process_data(data)
+    # puts "done waiting for #{@return_queue_name}"
+    if data && data[1]
+      begin
+#        redis_packet = MessagePack.unpack(data[1])
+        redis_packet = BSON.deserialize(data[1])
+        msg = redis_packet["data"]
+        if msg
+          if msg[0] == RESPONSE
+            on_response(msg[1], msg[2], msg[3])
+          else
+            puts "unknown message type #{msg[0]}"
+          end
+        end
+      rescue => e
+        puts e
+      end
+    end
+  end
+
+	def listen_for_return_sync
+    process_data(@redis.blpop(@return_queue_name, 0))
+  end
+
+	def listen_for_return_async
+	  Thread.new do
+      unless @ignore_return_value
+		    EM.run do
+  		    redis = EventMachine::Protocols::Redis.connect(@redis_options)
+  		    # puts "waiting for #{@return_queue_name}"
+  		    redis.blpop(@return_queue_name, 0) do |data|
+  		      process_data(data)
+  	      end
+  	    end
+  	  end
+    end
+  end
+
+	def redis_push(msgpack_data, msgid = nil)
+	  if msgid
+      @redis.multi
+      # puts "setting key in #{@unprocessed_requests_name}"
+      @redis.hset(@unprocessed_requests_name, msgid.to_s, msgpack_data)
+      # puts "pushing item into #{@queue_name}"
+      @redis.rpush(@queue_name, msgpack_data)
+      @redis.exec
+    else
+      @redis.rpush(@queue_name, msgpack_data)
+    end
+  end
+
+	def send_data(data, msgid = nil)
+	  if @ignore_return_value
+	    redis_push(BSON.serialize({:data => data}), msgid)
+    else
+	    redis_push(BSON.serialize({:data => data, :return => @return_queue_name}), msgid)
+    end
+	end
+
+	def close
+		self
+	end
+
+	def on_connect(sock)
+	end
+
+	def on_response(msgid, error, result)
+		@client.on_response(self, msgid, error, result)
+	end
+
+	def on_connect_failed(sock)
+	end
+
+	def on_close(sock)
+	end
+end
+
+class RedisServerTransport
+  include Util
+  
+	def initialize(name, redis_options = {})
+	  @ignore_nil_returns = !!redis_options.delete(:ignore_nil_returns)
+    @redis = Redis.new(redis_options)
+		@queue_name = "redpack_request_queue:#{name}"
+		@timeout_mechanism = redis_options[:timeout_mechanism]
+	end
+
+	# ServerTransport interface
+	def listen(server)
+		@server = server
+    loop do
+      begin
+        # puts "listening to #{@queue_name}"
+        data = @redis.blpop(@queue_name, 0)
+        # puts "popped item off of #{@queue_name}"
+    		if data && data[1]
+    		  redis_packet = BSON.deserialize(data[1])
+    		  if redis_packet["data"]
+    		    @return_queue_name = redis_packet["return"]
+    		    @unprocessed_requests_name = "#{@return_queue_name}:unprocessed"
+    		    msg = redis_packet["data"]
+      		  case msg[0]
+        		when REQUEST
+        			@server.on_request(self, msg[1], msg[2], msg[3])
+        		when RESPONSE
+        		  puts "response message on server session"
+        		when NOTIFY
+        			@server.on_notify(msg[1], msg[2])
+        		else
+        			puts "unknown message type #{msg[0]}"
+        		end
+  		    end
+    		end
+    	rescue => e
+    	  # probably timed out
+    	  p e
+    	  @timeout_mechanism.call if @timeout_mechanism
+		  end
+    end
+	end
+	
+	def finish(msgid)
+	  # puts "removing key from #{@unprocessed_requests_name}"
+	  @redis.hdel(@unprocessed_requests_name, msgid.to_s)
+  end
+
+	def send_data(data)
+	  # puts "putting data on #{@return_queue_name}"
+    @redis.rpush(@return_queue_name, BSON.serialize({:data => data})) if @return_queue_name
+  end
+
+	# ServerTransport interface
+	def close
+	end
+end
+
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 1
   - 0
-  - 1
-  version: 1.0.1
+  - 2
+  version: 1.0.2
 platform: ruby
 authors: 
 - Dean Mao
@@ -56,6 +56,15 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- rblib/redpack/base.rb
+- rblib/redpack/client.rb
+- rblib/redpack/dispatcher.rb
+- rblib/redpack/exception.rb
+- rblib/redpack/future.rb
+- rblib/redpack/message.rb
+- rblib/redpack/server.rb
+- rblib/redpack/transport.rb
+- rblib/redpack.rb
 - test/msgpack_rpc_test.rb
 - test/test_helper.rb
 - AUTHORS
@@ -69,7 +78,7 @@ post_install_message:
 rdoc_options: []
 
 require_paths: 
-- rblib/redpack
+- rblib
 required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: