msgpack-rpc 0.4.0 → 0.4.1

data/lib/msgpack/rpc/exception.rb.old

@@ -0,0 +1,303 @@
+#
+# 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
+
+
+
+##
+## MessagePack-RPC Exception
+##
+#
+#  MessagePack-RPC Transport Layer
+#  [int, msgid, object, object] を転送する
+#  これを転送できない場合はTransportError
+#
+#  メッセージ到達   1
+#  ハンドラ到達     2
+#  リトライ推奨     r
+#
+#  RPCError
+#  |
+#  +-- TimeoutError     : [?]
+#  |
+#  +-- TransportError   : []
+#  |   |
+#  |   +-- NetworkUnreachableError
+#  |   |
+#  |   +-- ConnectionRefusedError
+#  |   |
+#  |   +-- ConnectionTimeoutError
+#  |   |
+#  |   +-- MalformedMessageError
+#  |   |
+#  |   +-- ConnectionClosedError
+#  |
+#  +-- CallError        : [1]
+#  |   |
+#  |   +-- NoMethodError
+#  |   |
+#  |   +-- ArgumentError
+#  |
+#  +-- ServerError      : [1, 2?, r]
+#  |   |
+#  |   +-- ServerBusyError
+#  |   |
+#  |   +-- GatewayError
+#  |       |
+#  |       +-- GatewayTimeoutError
+#  |
+#  +-- RemoteError      : [1, 2]
+#      |
+#      +-- RemoteRuntimeError
+#      |
+#      +-- (user-defined errors)
+#
+##
+## MessagePack-RPC Exception
+##
+#
+#  RPCError
+#  |
+#  +-- TimeoutError     : 到達=不明 リトライ=アプリ判断
+#  |
+#  +-- TransportError   : 到達=していない リトライ=非推奨
+#  |   |
+#  |   +-- NetworkUnreachableError
+#  |   |
+#  |   +-- ConnectionRefusedError
+#  |   |
+#  |   +-- ConnectionTimeoutError
+#  |
+#  +-- SessionError     : 到達=した リトライ=非推奨
+#  |   |
+#  |   +-- MessageRefusedError
+#  |   |   |
+#  |   |   +-- MessageTooLargeError
+#  |   |
+#  |   +-- NoMethodError
+#  |   |
+#  |   +-- ArgumentError
+#  |
+#  +-- ServerError      : 到達=した リトライ=推奨
+#  |   |
+#  |   +-- ServerBusyError
+#  |
+#  +-- RemoteError
+#      |
+#      +-- RemoteRuntimeError
+#      |
+#      +-- (user-defined errors)
+#
+#
+##
+## MessagePack-RPC Exception
+##
+#
+#  RPCError
+#  |
+#  +-- TimeoutError
+#  |
+#  +-- ClientError
+#  |   |
+#  |   +-- TransportError
+#  |   |   |
+#  |   |   +-- NetworkUnreachableError
+#  |   |   |
+#  |   |   +-- ConnectionRefusedError
+#  |   |   |
+#  |   |   +-- ConnectionTimeoutError
+#  |   |   |
+#  |   |   +-- MessageTooLargeError
+#  |   |
+#  |   +-- SessionError
+#  |       |
+#  |       +-- NoMethodError
+#  |       |
+#  |       +-- ArgumentError
+#  |
+#  +-- ServerError
+#  |   |
+#  |   +-- ServerBusyError
+#  |
+#  +-- RemoteError
+#      |
+#      +-- (Remote)RuntimeError
+#      |
+#      +-- (user-defined errors)
+#
+
+=begin
+class Error < StandardError
+end
+
+class RPCError < Error
+	def initialize(msg, code)
+		super(msg)
+		@code = code
+	end
+	attr_reader :code
+end
+
+
+class TimeoutError < RPCError
+	CODE = ".TimeoutError"
+	def initialize(msg = "request timed out")
+		super(msg, CODE)
+	end
+end
+
+
+class ClientError < RPCError
+	CODE = ".ClientError"
+	def initialize(msg, code)
+		super(msg, code)
+	end
+end
+
+
+class TransportError < ClientError
+	CODE = ".TransportError"
+	def initialize(msg, code = CODE)
+		super(msg, CODE)
+	end
+end
+
+class NetworkUnreachableError < TransportError
+	CODE = ".NetworkUnreachableError"
+	def initialize(msg = "network unreachable")
+		super(msg, CODE)
+	end
+end
+
+class ConnectionRefusedError < TransportError
+	CODE = -52
+	def initialize(msg = "connection refused")
+		super(msg, CODE)
+	end
+end
+
+class ConnectionTimeoutError < TransportError
+	CODE = -53
+	def initialize(msg = "connection timed out")
+		super(msg, CODE)
+	end
+end
+
+
+class MessageRefusedError < ClientError
+	CODE = -40
+	def initialize(msg = "broken message", code = CODE)
+		super(msg, code)
+	end
+end
+
+class MessageTooLargeError < MessageRefusedError
+	CODE = -41
+	def initialize(msg = "messge too large")
+		super(msg, CODE)
+	end
+end
+
+
+class CallError < ClientError
+	CODE = -20
+	def initialize(msg, code = CODE)
+		super(msg, code)
+	end
+end
+
+class NoMethodError < CallError
+	CODE = -21
+	def initialize(msg = "method not found")
+		super(msg, CODE)
+	end
+end
+
+class ArgumentError < NoMethodError
+	CODE = -22
+	def initialize(msg = "invalid argument")
+		super(msg, CODE)
+	end
+end
+
+
+class ServerError < RPCError
+	CODE = -30
+	def initialize(msg, code = CODE)
+		super(msg, code)
+	end
+end
+
+class ServerBusyError < ServerError
+	CODE = -31
+	def initialize(msg = "server temporally busy")
+		super(msg, CODE)
+	end
+end
+
+
+class RemoteError < RPCError
+	def initialize(msg, code, result = nil)
+		super(msg, code)
+		@result = result
+	end
+	attr_reader :result
+end
+
+class RemoteRuntimeError < RemoteRuntimeError
+	CODE = -10
+	def initialize(msg, result = nil)
+		super(msg, CODE, result)
+	end
+end
+=end
+
+
+end
+end

data/lib/msgpack/rpc/future.rb

@@ -49,12 +49,14 @@ class Future
 				return @result
 			end
 		end
+		if @result.nil?
+			# compatible error
+			raise RuntimeError.new(@error)
+		end
 		if @error_handler
-			return @error_handler.call(self)
-		else
-			raise @error if @error.is_a?(Error)
-			raise RemoteError.new(@error, @result)
+			@error_handler.call(@error, @result)
 		end
+		raise RPCError.create(@error, @result)
 	end
 
 	# Wait for receiving result of remote procedure call.
@@ -73,13 +75,6 @@ class 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
@@ -95,10 +90,18 @@ class Future
 	def set_result(err, res)  #:nodoc:
 		@error  = err
 		@result = res
+		@set = true
 		if @callback_handler
-			@callback_handler.call(self)
+			if @callback_handler.arity == 2
+				# FIXME backward compatibility
+				@callback_handler.call(error, result)
+			else
+				@callback_handler.call(self)
+			end
 		end
-		@set = true
+		self
+	rescue
+		self
 	end
 
 	def step_timeout  #:nodoc:

data/lib/msgpack/rpc/multi_future.rb

@@ -0,0 +1,190 @@
+#
+# 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
+
+
+# MultiFuture bunldes up multiple Future objects.
+class MultiFuture
+	def initialize
+		@all = []
+
+		@not_joined = []
+		@joined = []
+		@error = []
+		@success = []
+
+		@on_all = nil
+		@on_error = nil
+		@on_success = nil
+		@on_num = {}  # {num => callback}
+	end
+
+	# Gets all registered Future objects.
+	attr_reader :all
+
+	# Gets Future objects which are not joined yet.
+	attr_reader :not_joined
+
+	# Gets Future objects which are already joined.
+	attr_reader :joined
+
+	# Gets Future objects which are joined as error.
+	attr_reader :error
+
+	# Gets Future objects which are joined as success.
+	attr_reader :success
+
+	# Clears all Future objects and all callback methods.
+	def clear
+		@all = []
+
+		@not_joined = []
+		@joined = []
+		@error = []
+		@success = []
+
+		clear_callback
+	end
+
+	# Clears all callback methods registered by on_xxx methods.
+	def clear_callback
+		@on_all = nil
+		@on_error = nil
+		@on_success = nil
+		@on_num = {}
+		self
+	end
+
+	# Registeres new Future object.
+	# Returns self.
+	def add(future)
+		future.attach_callback(&method(:callback))
+		@all << future
+		@not_joined << future
+		self
+	end
+
+	# Attaches a callback method that is called when
+	# all Future objects are joined.
+	# Returns self.
+	def on_all(&block)
+		@on_all = block
+		self
+	end
+
+	# Attaches a callback method that is called when
+	# Future objects are joined as success.
+	# Returns self.
+	def on_success(&block)
+		@on_success = block
+		self
+	end
+
+	# Attaches a callback method that is called when
+	# Future objects are joined as error.
+	# Returns self.
+	def on_error(&block)
+		@on_error = block
+		self
+	end
+
+	# Attaches a callback method that is called when
+	# specified number of Future objects are joined.
+	# Returns self.
+	def on_num(n, &block)
+		@on_num[n.to_i] = block
+		self
+	end
+
+	# Waits until all Future objects join.
+	def join_all
+		@not_joined.each {|future|
+			future.join
+		}
+		@all
+	end
+
+	# Waits until at least one Future object joins as success.
+	# Returns the joined Future object or nil.
+	def join_success
+		until @not_joined.empty?
+			unless @success.empty?
+				break
+			end
+			@not_joined.first.loop.run_once
+		end
+		@success.last
+	end
+
+	# Waits until at least one Future object joins as error.
+	# Returns the joined Future object or nil.
+	def join_error
+		until @not_joined.empty?
+			unless @error.empty?
+				break
+			end
+			@not_joined.first.loop.run_once
+		end
+		@error.last
+	end
+
+	# Waits until specified number of Future objects join.
+	# Returns the joined Future objects or nil.
+	def join_num(n)
+		until @not_joined.empty?
+			unless @joined.size >= n
+				return @joined
+			end
+			@not_joined.first.loop.run_once
+		end
+		nil
+	end
+
+	private
+
+	def callback(future)
+		if @not_joined.delete(future)
+			@joined << future
+
+			if future.error == nil
+				@success << future
+				if @on_success
+					@on_success.call(future) rescue nil
+				end
+			else
+				@error << future
+				if @on_error
+					@on_error.call(future) rescue nil
+				end
+			end
+
+			if callback = @on_num[@joined.size]
+				callback.call(@joined) rescue nil
+			end
+
+			if @on_all && @not_joined.empty?
+				@on_all.call(@all) rescue nil
+			end
+		end
+	end
+end
+
+
+end
+end