msgpack-rpc 0.3.0 → 0.4.0

data/lib/msgpack/rpc/address.rb

@@ -0,0 +1,144 @@
+#
+# 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
+
+
+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
+		def initialize(host, port)
+			raw = Socket.pack_sockaddr_in(port, host)
+			family = raw.unpack('S')[0]
+			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
+	else
+		# BSD
+		def initialize(host, port)
+			raw = Socket.pack_sockaddr_in(port, host)
+			family = raw.unpack('CC')[1]
+			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
+	end
+
+	def host
+		unpack[0]
+	end
+
+	def port
+		unpack[1]
+	end
+
+	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
+			addr = Socket.pack_sockaddr_in(0, '::')
+			addr[2,2]  = raw[0,2]
+			addr[8,16] = raw[2,16]
+		end
+		addr
+	end
+
+	def self.parse(raw)
+		Socket.unpack_sockaddr_in(parse_sockaddr(raw)).reverse
+	end
+
+	def self.load(raw)
+		Address.new *parse(raw)
+	end
+
+	def dump
+		@serial
+	end
+
+	def to_msgpack(out = '')
+		@serial.to_msgpack(out)
+	end
+
+	def to_s
+		unpack.join(':')
+	end
+
+	def to_a
+		unpack
+	end
+
+	def <=>(o)
+		dump <=> o.dump
+	end
+
+	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
+
+
+end
+end

data/lib/msgpack/rpc/client.rb

@@ -0,0 +1,80 @@
+#
+# 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
+
+
+# Client is usable for RPC client.
+# Note that SessionPool includes LoopUtil.
+class Client < Session
+	# 1. initialize(builder, address, loop = Loop.new)
+	# 2. initialize(host, port, loop = Loop.new)
+	#
+	# Creates a client.
+	def initialize(arg1, arg2, arg3=nil)
+			# 1.
+		if arg1.respond_to?(:build_transport)
+			builder = arg1
+			address = arg2
+			loop    = arg3 || Loop.new
+		else
+			# 2.
+			builder = TCPTransport.new
+			address = Address.new(arg1, arg2)
+			loop    = arg3 || Loop.new
+		end
+
+		super(builder, address, loop)
+
+		@timer = Timer.new(1, true, &method(:step_timeout))
+		loop.attach(@timer)
+	end
+
+	# call-seq:
+	#   Client.open(arg1, arg2, arg3=nil) {|client|  }
+	#
+	# Creates a client, call the block and close the client.
+	def self.open(*args, &block)
+		c = new(*args)
+		begin
+			block.call(c)
+		ensure
+			c.close
+		end
+	end
+
+	def close
+		@timer.detach if @timer.attached?
+		super
+	end
+
+	include LoopUtil
+end
+
+
+#:nodoc:
+class Client::Base
+	def initialize(*args)
+		@base = Client.new(*args)
+	end
+	attr_reader :base
+end
+
+
+end
+end

data/lib/msgpack/rpc/dispatcher.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
+
+
+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)
+		unless @accept.include?(method)
+			raise NoMethodError, "method `#{method}' is not accepted"
+		end
+		@obj.send(method, *param, &block)
+	end
+end
+
+
+end
+end

data/lib/msgpack/rpc/exception.rb

@@ -0,0 +1,53 @@
+#
+# 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
+
+
+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
+end

data/lib/msgpack/rpc/future.rb

@@ -0,0 +1,116 @@
+#
+# 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
+
+
+# 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, loop, callback = nil)  #:nodoc:
+		@timeout = session.timeout
+		@loop = loop
+		@callback_handler = callback
+		@error_handler = nil
+		@result_handler = nil
+		@set = false
+		@error = nil
+		@result = nil
+	end
+	attr_reader :loop
+	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
+			@loop.run_once
+		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
+		if @callback_handler.arity == 2
+			# FIXME backward compatibility
+			handler = @callback_handler
+			@callback_handler = Proc.new {|future|
+				handler.call(future.error, future.result)
+			}
+		end
+	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
+			@callback_handler.call(self)
+		end
+		@set = true
+	end
+
+	def step_timeout  #:nodoc:
+		if @timeout < 1
+			true
+		else
+			@timeout -= 1
+			false
+		end
+	end
+end
+
+
+end
+end