msgpack-rpc 0.3.0 → 0.4.0

data/lib/msgpack/rpc/loop.rb

@@ -0,0 +1,87 @@
+#
+# MessagePack-RPC for Ruby
+#
+# Copyright (C) 2010 FURUHASHI Sadayuki
+#
+#    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 MessagePack
+module RPC
+
+
+Loop = Rev::Loop
+
+
+module LoopUtil
+	attr_reader :loop
+
+	class Timer < Rev::TimerWatcher
+		def initialize(interval, repeating, &block)
+			@block = block
+			super(interval, repeating)
+		end
+		def on_timer
+			@block.call
+		end
+	end
+
+	def start_timer(interval, repeating, &block)
+		@loop.attach Timer.new(interval, repeating, &block)
+	end
+
+	class TaskQueue < Rev::AsyncWatcher
+		def initialize
+			@queue = []
+			super
+		end
+
+		def push(task)
+			@queue.push(task)
+			signal
+		end
+
+		def on_signal
+			while task = @queue.shift
+				begin
+					task.call
+				rescue
+				end
+			end
+		end
+	end
+
+	def submit(task = nil, &block)
+		task ||= block
+		unless @queue
+			@queue = TaskQueue.new
+			@loop.attach(@queue)
+		end
+		@queue.push(task)
+	end
+
+	def run
+		@loop.run
+	end
+
+	def stop
+		@queue.detach if @queue && @queue.attached?
+		@loop.stop
+		# attach dummy timer
+		@loop.attach Rev::TimerWatcher.new(0, false)
+		nil
+	end
+end
+
+
+end
+end

data/lib/msgpack/rpc/message.rb

@@ -0,0 +1,31 @@
+#
+# MessagePack-RPC for Ruby
+#
+# Copyright (C) 2010 FURUHASHI Sadayuki
+#
+#    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 MessagePack
+module RPC
+
+
+REQUEST  = 0    # [0, msgid, method, param]
+RESPONSE = 1    # [1, msgid, error, result]
+NOTIFY   = 2    # [2, method, param]
+
+NO_METHOD_ERROR = 0x01;
+ARGUMENT_ERROR  = 0x02;
+
+
+end
+end

data/lib/msgpack/rpc/server.rb

@@ -0,0 +1,111 @@
+#
+# MessagePack-RPC for Ruby
+#
+# Copyright (C) 2010 FURUHASHI Sadayuki
+#
+#    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 MessagePack
+module RPC
+
+
+# Server is usable for RPC server.
+# Note that Server is a SessionPool.
+class Server < SessionPool
+	# 1. initialize(builder, loop = Loop.new)
+	# 2. initialize(loop = Loop.new)
+	def initialize(arg1=nil, arg2=nil)
+		super(arg1, arg2)
+		@dispatcher = nil
+		@listeners = []
+	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 listen(arg1, arg2 = nil, arg3 = nil, arg4 = nil)
+		if arg1.respond_to?(:listen)
+			# 1.
+			listener = arg1
+			obj      = arg2
+			accept   = arg3 || obj.public_methods
+		else
+			# 2.
+			listener = TCPServerTransport.new(Address.new(arg1,arg2))
+			obj      = arg3
+			accept   = arg4 || obj.public_methods
+		end
+
+		unless obj.nil?
+			serve(obj, accept)
+		end
+
+		listener.listen(self)
+		@listeners.push(listener)
+		nil
+	end
+
+	def close
+		@listeners.reject! {|listener|
+			listener.close
+			true
+		}
+		super
+	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
+	end
+
+	def result(retval, err = nil)
+		data = [RESPONSE, @msgid, err, retval].to_msgpack
+		@sendable.send_data(data)
+	end
+
+	def error(err, retval = nil)
+		result(retval, err)
+	end
+end
+
+
+#:nodoc:
+class Server::Base
+	def initialize(*args)
+		@base = Server.new(*args)
+		@base.serve(self)
+	end
+	attr_reader :base
+end
+
+
+end
+end

data/lib/msgpack/rpc/session.rb

@@ -0,0 +1,157 @@
+#
+# MessagePack-RPC for Ruby
+#
+# Copyright (C) 2010 FURUHASHI Sadayuki
+#
+#    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 MessagePack
+module RPC
+
+
+# Session is a abstract class corresponds with a remote host.
+# You can call remote method using call, call_async, callback or notify method.
+class Session
+	def initialize(builder, address, loop)
+		@address = address
+		@loop = loop
+		@reqtable = {}
+		@timeout = 10    # FIXME default timeout time
+		@seqid = 0
+		@transport = builder.build_transport(self, address)
+	end
+	attr_reader :loop, :address
+
+	# Sets and gets timeout in seconds.
+	attr_accessor :timeout
+
+	# backward compatibility
+	def port  #:nodoc:
+		@address.port;
+	end
+
+	# backward compatibility
+	def host  #:nodoc:
+		@address.host;
+	end
+
+	# call-seq:
+	#   call(symbol, *args) -> result of remote method
+	#
+	# Calls remote method.
+	# This method is same as call_async(method, *args).get
+	def call(method, *args)
+		call_async(method, *args).get
+	end
+
+	# call-seq:
+	#   call_async(symbol, *args) -> Future
+	#
+	# Calls remote method asynchronously.
+	# This method is non-blocking and returns Future.
+	def call_async(method, *args)
+		future = send_request(method, args)
+	end
+
+	# backward compatibility
+	alias send call_async  #:nodoc:
+
+	# call-seq:
+	#   callback(symbol, *args) {|future| }
+	#
+	# Calls remote method asynchronously.
+	# The callback method is called with Future when the result is reached.
+	# This method is same as call_async(method, *args).attach_callback {|future|  }
+	def callback(method, *args, &block)
+		future = send_request(method, args)
+		future.attach_callback(block)
+		future
+	end
+
+	# 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
+
+	# Closes underlaying Transport and destroy resources.
+	def close
+		@transport.close
+		@reqtable = {}
+		@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].to_msgpack
+		@transport.send_data(data)
+		@reqtable[msgid] = Future.new(self, @loop)
+	end
+
+	def send_notify(method, param)
+		method = method.to_s
+		data = [NOTIFY, method, param].to_msgpack
+		@transport.send_data(data)
+		nil
+	end
+end
+
+
+end
+end

data/lib/msgpack/rpc/session_pool.rb

@@ -0,0 +1,91 @@
+#
+# MessagePack-RPC for Ruby
+#
+# Copyright (C) 2010 FURUHASHI Sadayuki
+#
+#    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 MessagePack
+module RPC
+
+
+# SessionPool is usable for connection pooling.
+# You can get pooled Session using get_session method.
+# Note that SessionPool includes LoopUtil.
+class SessionPool
+	# 1. initialize(builder, loop = Loop.new)
+	# 2. initialize(loop = Loop.new)
+	#
+	# Creates an SessionPool.
+	def initialize(arg1=nil, arg2=nil)
+		if arg1.respond_to?(:build_transport)
+			# 1.
+			builder = arg1
+			loop    = arg2 || Loop.new
+		else
+			# 2.
+			builder = TCPTransport.new
+			loop    = arg1 || Loop.new
+		end
+
+		@builder = builder
+		@loop = loop
+		@pool = {}
+
+		@timer = Timer.new(1, true, &method(:step_timeout))
+		loop.attach(@timer)
+	end
+
+	# 1. get_session(address)
+	# 2. get_session(host, port)
+	#
+	# Returns pooled Session.
+	# If there are no pooled Session for the specified address,
+	# this method creates the Session and pools it.
+	def get_session(arg1, arg2=nil)
+		if arg2.nil?
+			# 1.
+			addr = arg1
+		else
+			# 2.
+			host = arg1
+			port = arg2
+			addr = Address.new(host, port)
+		end
+
+		@pool[addr] ||= Session.new(@builder, addr, @loop)
+	end
+
+	# backward compatibility
+	alias get_session_addr get_session   #:nodoc:
+
+	def close
+		@pool.reject! {|addr, s|
+			s.close
+			true
+		}
+		@timer.detach if @timer.attached?
+		nil
+	end
+
+	include LoopUtil
+
+	private
+	def step_timeout
+		@pool.each_pair {|addr,s| s.step_timeout }
+	end
+end
+
+
+end
+end