msgpack-rpc 0.1.4 → 0.2.0

data/Rakefile

@@ -17,7 +17,7 @@ DESCRIPTION       = "RPC library using MessagePack, a ainary-based efficient dat
 RUBYFORGE_PROJECT = "msgpack"
 HOMEPATH          = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
 BIN_FILES         = %w(  )
-VERS              = "0.1.4"
+VERS              = "0.2.0"
 
 #REV = File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
 REV = nil

data/lib/msgpack/rpc.rb

@@ -40,11 +40,16 @@ class RemoteError < RPCError
 end
 
 class TimeoutError < Error
-	def initialize
-		super("request timed out")
+	def initialize(msg = "request timed out")
+		super
 	end
 end
 
+class ConnectError < TimeoutError
+	def initialize(msg = "connect failed")
+		super
+	end
+end
 
 class Responder
 	def initialize(socket, msgid)
@@ -53,7 +58,7 @@ class Responder
 	end
 
 	def result(retval, err = nil)
-		@socket.send_response(@msgid, retval, err)
+		@socket.write RPCSocket.pack_response(@msgid, retval, err)
 	end
 
 	def error(err)
@@ -62,75 +67,141 @@ class Responder
 end
 
 
-REQUEST  = 0
-RESPONSE = 1
-NOTIFY   = 2
+class Address
+	# +--+----+
+	# | 2|  4 |
+	# +--+----+
+	# port network byte order
+	#    IPv4 address
+	#
+	# +--+----------------+
+	# | 2|       16       |
+	# +--+----------------+
+	# port network byte order
+	#    IPv6 address
+	#
+
+	test = Socket.pack_sockaddr_in(0,'0.0.0.0')
+	if test[0] == "\0"[0] || test[1] == "\0"[0]
+		# Linux
+		IMPL_LINUX = true
+	else
+		# BSD
+		IMPL_LINUX = false
+	end
+
+	def initialize(host, port)
+		raw = Socket.pack_sockaddr_in(port, host)
+		if IMPL_LINUX
+			family = raw.unpack('S')[0]
+		else
+			family = raw.unpack('CC')[1]
+		end
+		if family == Socket::AF_INET
+			@serial = raw[2,6]
+		elsif family == Socket::AF_INET6
+			@serial = raw[2,2] + raw[8,16]
+		else
+			raise "Unknown address family: #{family}"
+		end
+	end
 
+	def host
+		unpack[0]
+	end
 
-module RPCSocket
-	def session=(s)
-		@session = s
-		s.add_socket(self)
+	def port
+		unpack[1]
 	end
 
-	def on_message(msg)
-		case msg[0]
-		when REQUEST
-			on_request(msg[1], msg[2], msg[3])
-		when RESPONSE
-			on_response(msg[1], msg[2], msg[3])
-		when NOTIFY
-			on_notify(msg[1], msg[2])
+	def connectable?
+		port != 0
+	end
+
+	def sockaddr
+		Address.parse_sockaddr(@serial)
+	end
+
+	def unpack
+		Address.parse(@serial)
+	end
+
+	def self.parse_sockaddr(raw)
+		if raw.length == 6
+			addr = Socket.pack_sockaddr_in(0, '0.0.0.0')
+			addr[2,6] = raw[0,6]
 		else
-			raise RPCError.new("unknown message type #{msg[0]}")
+			addr = Socket.pack_sockaddr_in(0, '::')
+			addr[2,2]  = raw[0,2]
+			addr[8,16] = raw[2,16]
 		end
+		addr
 	end
 
-	def on_close
-		return unless @session
-		@session.on_close(self)
-		@session = nil
-	rescue
-		nil
+	def self.parse(raw)
+		Socket.unpack_sockaddr_in(parse_sockaddr(raw)).reverse
 	end
 
-	def on_request(msgid, method, param)
-		return unless @session
-		@session.on_request(method, param, Responder.new(self,msgid))
+	def self.load(raw)
+		Address.new *parse(raw)
 	end
 
-	def on_notify(method, param)
-		return unless @session
-		@session.on_notify(method, param)
+	def dump
+		@serial
 	end
 
-	def on_response(msgid, error, result)
-		return unless @session
-		@session.on_response(msgid, error, result)
+	def to_msgpack(out = '')
+		@serial.to_msgpack(out)
 	end
 
-	def send_request(msgid, method, param)
-		send_message [REQUEST, msgid, method, param]
+	def to_s
+		unpack.join(':')
 	end
 
-	def send_response(msgid, result, error)
-		send_message [RESPONSE, msgid, error, result]
+	def to_a
+		unpack
 	end
 
-	def send_notify(method, param)
-		send_message [NOTIFY, method, param]
+	def inspect
+		"#<#{self.class} #{to_s} @serial=#{@serial.inspect}>"
+	end
+
+
+	def eql?(o)
+		o.class == Address && dump.eql?(o.dump)
+	end
+
+	def hash
+		dump.hash
+	end
+
+	def ==(o)
+		eql?(o)
 	end
 end
 
 
-class RevSocket < ::Rev::TCPSocket
-	include RPCSocket
+REQUEST  = 0
+RESPONSE = 1
+NOTIFY   = 2
+INIT     = 3
+
 
-	def initialize(*args)
+class RPCSocket < Rev::TCPSocket
+	def initialize(sock, session)
 		@buffer = ''
 		@nread = 0
 		@mpac = MessagePack::Unpacker.new
-		super
+		@s = session
+		super(sock)
+	end
+
+	def bind_session(s)
+		@s = s
+	end
+
+	def bound?
+		!@s.nil?
 	end
 
 	def on_read(data)
@@ -155,28 +226,96 @@ class RevSocket < ::Rev::TCPSocket
 		end
 	end
 
+	def on_message(msg)
+		case msg[0]
+		when REQUEST
+			on_request(msg[1], msg[2], msg[3])
+		when RESPONSE
+			on_response(msg[1], msg[2], msg[3])
+		when NOTIFY
+			on_notify(msg[1], msg[2])
+		when INIT
+			on_init(msg[1])
+		else
+			raise RPCError.new("unknown message type #{msg[0]}")
+		end
+	end
+
+	def on_connect
+		return unless @s
+		@s.on_connect(self)
+	end
+
+	def on_connect_failed
+		return unless @s
+		@s.on_connect_failed(self)
+	end
+
+	def on_close
+		return unless @s
+		@s.on_close(self)
+		@s = nil
+	rescue
+		nil
+	end
+
+	def on_request(msgid, method, param)
+		return unless @s
+		@s.on_request(method, param, Responder.new(self,msgid))
+	end
+
+	def on_notify(method, param)
+		return unless @s
+		@s.on_notify(method, param)
+	end
+
+	def on_response(msgid, error, result)
+		return unless @s
+		@s.on_response(msgid, error, result)
+	end
+
+	def on_init(msg)
+		# ignore
+	end
+
 	def send_message(msg)
 		write msg.to_msgpack
 	end
+
+	def self.pack_request(msgid, method, param)
+		[REQUEST, msgid, method, param].to_msgpack
+	end
+
+	def self.pack_response(msgid, result, error)
+		[RESPONSE, msgid, error, result].to_msgpack
+	end
+
+	def self.pack_notify(method, param)
+		[NOTIFY, method, param].to_msgpack
+	end
+
+	def self.pack_init(msg)
+		[INIT, msg].to_msgpack
+	end
 end
 
 
-class ClientSession
+class Session
 
 	class BasicRequest
-		def initialize(session, loop)
-			@session = session
-			@timeout = session.timeout
+		def initialize(s, loop)
+			@s = s
+			@timeout = s.timeout
 			@loop = loop
 		end
 		attr_reader :loop
 
 		def call(err, res)
-			@session = nil
+			@s = nil
 		end
 
 		def join
-			while @session
+			while @s
 				@loop.run_once
 			end
 			self
@@ -193,8 +332,8 @@ class ClientSession
 	end
 
 	class AsyncRequest < BasicRequest
-		def initialize(session, loop)
-			super(session, loop)
+		def initialize(s, loop)
+			super(s, loop)
 			@error  = nil
 			@result = nil
 		end
@@ -203,13 +342,13 @@ class ClientSession
 		def call(err, res)
 			@error  = err
 			@result = res
-			@session = nil
+			@s = nil
 		end
 	end
 
 	class CallbackRequest < BasicRequest
-		def initialize(session, loop, block)
-			super(session, loop)
+		def initialize(s, loop, block)
+			super(s, loop)
 			@block = block
 		end
 
@@ -219,89 +358,164 @@ class ClientSession
 	end
 
 
-	def initialize(loop)
-		@sock = nil
-		@reqtable = {}
-		@seqid = 0
+	def initialize(initmsg, target_addr, dispatcher, loop)
+		@initmsg = initmsg
+		@target_addr = target_addr
+		@dispatcher = dispatcher || NullDispatcher.new
 		@loop = loop
-		@timeout = 60    # FIXME default timeout time
+		@timeout = 10    # FIXME default timeout time
+		@reconnect = 5   # FIXME default reconnect limit
+		reset
+	end
+	attr_accessor :timeout, :reconnect
+
+	def address
+		@target_addr
 	end
-	attr_accessor :timeout
 
-	def add_socket(sock)
-		@sock = sock
+	def on_connect(sock)
+		@sockpool.push(sock)
+		sock.write @pending
+		@pending = ""
+		@connecting = 0
 	end
 
+	def on_connect_failed(sock)
+		if @connecting < @reconnect
+			try_connect
+			@connecting += 1
+		else
+			@connecting = 0
+			@reqtable.reject! {|msgid, req|
+				begin
+					req.call ConnectError.new, nil
+				rescue
+				end
+				true
+			}
+		end
+	end
+
+
 	def send(method, *args)
-		send_real(method, args, AsyncRequest.new(self,@loop))
+		msgid = send_request(method, args)
+		@reqtable[msgid] = AsyncRequest.new(self, @loop)
 	end
 
 	def callback(method, *args, &block)
-		send_real(method, args, CallbackRequest.new(self,@loop,block))
+		msgid = send_request(method, args)
+		@reqtable[msgid] = CallbackRequest.new(self, @loop, block)
 	end
 
 	def call(method, *args)
+		# FIXME if @reqtable.empty? optimize
 		req = send(method, *args)
 		req.join
 		if req.error
-			raise TimeoutError.new if req.error == :TimeoutError
+			raise req.error if req.error.is_a?(Error)
 			raise RemoteError.new(req.error, req.result)
 		end
 		req.result
 	end
 
 	def notify(method, *args)
-		notify_real(method, args)
+		send_notify(method, args)
+	end
+
+	def close
+		@sockpool.reject! {|sock|
+			sock.detach if sock.attached?
+			sock.close
+			true
+		}
+		reset
+		self
+	end
+
+	def step_timeout
+		reqs = []
+		@reqtable.reject! {|msgid, req|
+			if req.step_timeout
+				reqs.push(req)
+			end
+		}
+		reqs.each {|req|
+			begin
+				req.call TimeoutError.new, nil
+			rescue
+			end
+		}
+		!@reqtable.empty?
 	end
 
 
 	def on_response(msgid, error, result)
 		if req = @reqtable.delete(msgid)
-			req.call error, result
+			req.call(error, result)
 		end
 	end
 
-	def on_notify(method, param)
-		raise RPCError.new("unexpected notify message")
-	end
-
 	def on_request(method, param, res)
-		raise RPCError.new("unexpected request message")
+		@dispatcher.dispatch_request(self, method, param, res)
 	end
 
-	def on_close(sock)
-		@sock = nil
+	def on_notify(method, param)
+		@dispatcher.dispatch_notify(self, method, param)
 	end
 
-	def close
-		@sock.close if @sock
+	def on_close(sock)
+		@sockpool.delete(sock)
 	end
 
 
-	def step_timeout
-		reqs = []
-		@reqtable.reject! {|msgid, req|
-			if req.step_timeout
-				reqs.push req
-			end
-		}
-		reqs.each {|req| req.call :TimeoutError, nil }
+	private
+	def reset
+		@sockpool = []
+		@reqtable = {}
+		@seqid = 0
+		@pending = ""
+		@connecting = 0
 	end
 
-	private
-	def send_real(method, param, req)
+	def send_request(method, param)
 		method = method.to_s unless method.is_a?(Integer)
 		msgid = @seqid
 		@seqid += 1; if @seqid >= 1<<31 then @seqid = 0 end
-		@sock.send_request msgid, method, param
-		@reqtable[msgid] = req
+		send_data RPCSocket.pack_request(msgid, method, param)
+		msgid
 	end
 
-	def notify_real(method, param)
+	def send_notify(method, param)
 		method = method.to_s unless method.is_a?(Integer)
-		@sock.send_notify method, param
+		send_data RPCSocket.pack_notify(method, param)
 		nil
 	end
+
+	def send_data(msg)
+		unless @target_addr
+			raise RPCError.new("unexpected send request on server session")
+		end
+		if @sockpool.empty?
+			if @connecting == 0
+				try_connect
+				@connecting = 1
+			end
+			@pending << msg
+		else
+			# FIXME pesudo connection load balance
+			sock = @sockpool.first
+			sock.write msg
+		end
+	end
+
+	def try_connect
+		port, host = ::Socket.unpack_sockaddr_in(@target_addr.sockaddr)
+		sock = RPCSocket.connect(host, port, self)  # async connect
+		if @initmsg
+			sock.write @initmsg
+		end
+		@loop.attach(sock)
+	end
 end
 
 
@@ -338,19 +552,25 @@ class AsyncResult
 end
 
 
-class ServerSession
+class NullDispatcher
+	def dispatch_request(session, method, param, res)
+		raise RPCError.new("unexpected request message")
+	end
+
+	def dispatch_notify(session, method, param)
+		raise RPCError.new("unexpected notify message")
+	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 add_socket(sock)
-		# do nothing
-	end
-
-	def on_request(method, param, res)
+	def dispatch_request(session, method, param, res)
 		begin
-			result = forward_method(method, param)
+			result = forward_method(session, method, param)
 		rescue
 			res.error($!.to_s)
 			return
@@ -362,30 +582,23 @@ class ServerSession
 		end
 	end
 
-	def on_notify(method, param)
-		forward_method(method, param)
+	def dispatch_notify(session, method, param)
+		forward_method(session, method, param)
 	rescue
 	end
 
-	def on_response(msgid, error, result)
-		raise RPCError.new("unexpected response message")
-	end
-
-	def on_close(sock)
-		# do nothing
-		@sock = nil
-	end
-
 	private
-	def forward_method(method, param)
+	def forward_method(session, method, param)
 		unless @accept.include?(method)
 			raise NoMethodError, "method `#{method}' is not accepted"
 		end
-		@obj.send(method, *param)
+		@obj.send(method, *param) { session }
 	end
 end
 
-Loop = ::Rev::Loop
+
+Loop = Rev::Loop
+
 
 module LoopUtil
 	attr_reader :loop
@@ -404,11 +617,42 @@ module LoopUtil
 		@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)
@@ -417,86 +661,172 @@ module LoopUtil
 end
 
 
-class Client
+class Client < Session
 	def initialize(host, port, loop = Loop.new)
 		@loop = loop
 		@host = host
 		@port = port
-		@rsock = RevSocket.connect(host, port)
-		@s = ClientSession.new(loop)
-		@rsock.session = @s
-		loop.attach(@rsock)
-		@timer = Timer.new(1, true) { @s.step_timeout }
+
+		target_addr = Address.new(host, port)
+		super(nil, target_addr, NullDispatcher.new, loop)
+
+		@timer = Timer.new(1, true) {
+			step_timeout
+		}
 		loop.attach(@timer)
 	end
 	attr_reader :host, :port
 
+	def self.open(host, port, loop = Loop.new, &block)
+		cli = new(host, port, loop)
+		begin
+			block.call(cli)
+		ensure
+			cli.close
+		end
+	end
+
 	def close
 		@timer.detach if @timer.attached?
-		@rsock.detach if @rsock.attached?
-		@s.close
-		nil
+		super
 	end
 
-	def send(method, *args)
-		@s.send(method, *args)
-	end
+	include LoopUtil
+end
 
-	def callback(method, *args, &block)
-		@s.callback(method, *args, &block)
-	end
 
-	def call(method, *args)
-		@s.call(method, *args)
+class SessionPool
+	def initialize(loop = Loop.new)
+		@loop = loop
+		@spool = {}
+		@stimer = Timer.new(1, true, &method(:step_timeout))
+		loop.attach(@stimer)
 	end
 
-	def notify(method, *args)
-		@s.notify(method, *args)
+	def get_session(host, port)
+		target_addr = Address.new(host, port)
+		@spool[target_addr] ||= create_session(target_addr)
 	end
 
-	def timeout
-		@s.timeout
+	def close
+		@spool.reject! {|target_addr, s|
+			s.close
+			true
+		}
+		@stimer.detach if @stimer.attached?
+		nil
 	end
 
-	def timeout=(time)
-		@s.timeout = time
+	include LoopUtil
+
+	protected
+	def create_session(target_addr)
+		Session.new(nil, target_addr, nil, @loop)
 	end
 
-	include LoopUtil
+	private
+	def step_timeout
+		@spool.each_pair {|target_addr, s|
+			s.step_timeout
+		}
+	end
 end
 
 
-class Server
-	class Socket < RevSocket
-		def initialize(*args)
-			accept = args.pop
-			obj = args.pop
-			self.session = ServerSession.new(obj, accept)
-			super(*args)
+class Server < SessionPool
+	class Socket < RPCSocket
+		def initialize(sock, dispatcher, loop)
+			s = Session.new(nil, nil, dispatcher, loop)
+			super(sock, s)
 		end
 	end
 
 	def initialize(loop = Loop.new)
-		@loop = loop
-		@socks = []
+		super(loop)
+		@lsocks = []
 	end
 
 	def listen(host, port, obj, accept = obj.public_methods)
-		lsock = ::Rev::TCPServer.new(host, port, Server::Socket, obj, accept)
-		@socks.push lsock
+		dispatcher = ObjectDispatcher.new(obj, accept)
+		lsock = Rev::TCPServer.new(host, port, Server::Socket, dispatcher, @loop)
+		@lsocks.push(lsock)
 		@loop.attach(lsock)
 	end
 
 	def close
-		@socks.reject! {|lsock|
+		@lsocks.reject! {|lsock|
 			lsock.detach if lsock.attached?
 			lsock.close
 			true
 		}
-		nil
+		super
+	end
+end
+
+
+class Cluster < SessionPool
+	class Socket < RPCSocket
+		def initialize(sock, binder)
+			@binder = binder
+			super(sock, nil)
+		end
+
+		def on_message(msg)
+			if bound?
+				super
+			else
+				@binder.call(self, msg)
+			end
+		end
+	end
+
+	def initialize(host, port, loop = Loop.new)
+		super(loop)
+		@host = host
+		@port = port
+		@dispatcher = nil
+		self_addr = Address.new(host, port)
+		@initmsg = RPCSocket.pack_init(self_addr)
+	end
+	attr_reader :host, :port
+
+	def serve(obj, accept = obj.public_methods)
+		@dispatcher = ObjectDispatcher.new(obj, accept)
+		@lsock = Rev::TCPServer.new(host, port, Cluster::Socket, method(:lazy_bind))
+		@loop.attach(@lsock)
+		self
+	end
+
+	def close
+		if @lsock
+			@lsock.detach if @lsock.attached?
+			@lsock.close
+		end
+		super
 	end
 
 	include LoopUtil
+
+	protected
+	def create_session(target_addr)
+		Session.new(@initmsg, target_addr, @dispatcher, @loop)
+	end
+
+	private
+	def lazy_bind(sock, msg)
+		if msg[0] == INIT
+			# cluster
+			target_addr = Address.load(msg[1])
+			s = Session.new(@initmsg, target_addr, @dispatcher, @loop)
+			sock.bind_session(s)
+			@spool[target_addr] = s
+		else
+			# subsys
+			s = Session.new(nil, nil, @dispatcher, @loop)
+			sock.bind_session(s)
+			sock.on_message(msg)
+		end
+	end
 end
 
 

data/test/msgpack_rpc_test.rb

@@ -211,6 +211,24 @@ class MessagePackRPCTest < Test::Unit::TestCase
 	end
 
 
+	def test_pool
+		svr, cli = start_server
+
+		sp = MessagePack::RPC::SessionPool.new
+		s = sp.get_session('127.0.0.1', cli.port)
+
+		result = s.call(:hello)
+		assert_equal(result, "ok")
+
+		result = s.call(:sum, 1, 2)
+		assert_equal(result, 3)
+
+		sp.close
+		cli.close
+		svr.stop
+	end
+
+
 	def test_loop
 		port = next_port
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: msgpack-rpc
 version: !ruby/object:Gem::Version 
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors: 
 - FURUHASHI Sadayuki
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-01 00:00:00 +09:00
+date: 2009-12-05 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -48,11 +48,12 @@ files:
 - Rakefile
 - test/msgpack_rpc_test.rb
 - test/test_helper.rb
-- lib/msgpack
 - lib/msgpack/rpc.rb
 - AUTHORS
-has_rdoc: false
+has_rdoc: true
 homepage: http://msgpack.rubyforge.org
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --title
@@ -84,9 +85,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: msgpack
-rubygems_version: 1.3.1
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: RPC library using MessagePack, a ainary-based efficient data interchange format.
 test_files: 
 - test/test_helper.rb