redpack 1.0.3 → 1.0.4

data/rblib/redpack/client.rb

@@ -19,126 +19,126 @@
 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
+  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-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")
+  # 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, !!sync)
-  		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
+      method_name.gsub!(/_sync$/, '') if sync
+      method_name.gsub!(/_async$/, '') if async
+      future = send_request(method_name, args, !!sync)
+      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
+  # Closes underlaying Transport and destroy resources.
+  def close
+    @timer.detach if @timer.attached?
+    @reqtable = {}
+    @transport.close
+    @seqid = 0
+    self
+  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
+  # 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, sync = false)
-		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, sync)
-		@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
+  private
+  def send_request(method, param, sync = false)
+    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, sync)
+    @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/future.rb

@@ -23,79 +23,79 @@ module RedPack
 # 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
+  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 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
+  # 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
+  # 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_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
+  # 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
+  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/transport.rb

@@ -37,9 +37,9 @@ class RedisClientTransport
   # 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}"
+  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
@@ -50,12 +50,12 @@ class RedisClientTransport
     @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
+    # 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}"
@@ -77,26 +77,25 @@ class RedisClientTransport
     end
   end
 
-	def listen_for_return_sync
+  def listen_for_return_sync
     process_data(@redis.blpop(@return_queue_name, 0))
   end
 
-	def listen_for_return_async
-	  Thread.new do
+  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
+        EM.run do
+          redis = EventMachine::Protocols::Redis.connect(@redis_options)
+          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
+  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)
@@ -108,89 +107,89 @@ class RedisClientTransport
     end
   end
 
-	def send_data(data, msgid = nil, sync = false)
-    if sync
+  def send_data(data, msgid = nil, sync = false)
+    if @ignore_return_value
+      redis_push(BSON.serialize({:data => data}), msgid)
+    else
       redis_push(BSON.serialize({:data => data, :return => @return_queue_name}), msgid)
-	  elsif @ignore_return_value || !sync
-	    redis_push(BSON.serialize({:data => data}), msgid)
     end
-	end
+  end
 
-	def close
-		self
-	end
+  def close
+    self
+  end
 
-	def on_connect(sock)
-	end
+  def on_connect(sock)
+  end
 
-	def on_response(msgid, error, result)
-		@client.on_response(self, msgid, error, result)
-	end
+  def on_response(msgid, error, result)
+    @client.on_response(self, msgid, error, result)
+  end
 
-	def on_connect_failed(sock)
-	end
+  def on_connect_failed(sock)
+  end
 
-	def on_close(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)
+
+  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
+    @queue_name = "redpack_request_queue:#{name}"
+    @timeout_mechanism = redis_options[:timeout_mechanism]
+  end
 
-	# ServerTransport interface
-	def listen(server)
-		@server = server
+  # 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
+        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}"
+  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
+  # ServerTransport interface
+  def close
+  end
 end
 
-end
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 1
   - 0
-  - 3
-  version: 1.0.3
+  - 4
+  version: 1.0.4
 platform: ruby
 authors: 
 - Dean Mao
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-19 00:00:00 -08:00
+date: 2011-02-01 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency