sneakers_packer 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b6b98083ec7e1c36b50a533f25a6491b18ea1d82
-  data.tar.gz: 96984ee06ee6d2e12700f5a7c74f199b11852766
+  metadata.gz: a4ac9997eb8d9b7257a00b04c991d19220c2f22d
+  data.tar.gz: e3c3c1b1cbd97310b3d1bbd240d9c90168a93e3d
 SHA512:
-  metadata.gz: a599887e7d24b3de1753976db48c13cb622849facf3cd8137b515c3729609652133342fbaa2d55148b25810574972f5ca5a57dd34b5252eebe50b58c003b2778
-  data.tar.gz: 9b6bc6df8d3b9ae5ed76c80b4819b3b213062b39937b619b19ca211ad9b980d092761a245cf406081b53288f544bcc93a5e84ac3c8d193e7c03dad13f5a14f1a
+  metadata.gz: f1c24ad78b837d918ec14ca8fcce97548394848bb3954074d1a79b58195d4d64d61fe8c25667a682a8e59472254e38eedc623b69fa9a41981a5d939974453a61
+  data.tar.gz: b765f498e08c52302dea54e7641dc4925c79f8f844541af1022801dde214c94d6878a3dcd15b7f2688810544360c43fffb736818b075919782fc5dfd18afda89

data/.travis.yml

@@ -1,6 +1,9 @@
 language: ruby
 rvm:
   - 2.1.5
-  - 2.2.3
   - 2.3.0
 before_install: gem install bundler -v 1.11.2
+before_script:
+  - bundle exec ruby test/sneakers_test_workers.rb
+services:
+  - rabbitmq

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.1.5
+* Make it threadsafe.
+* Refactor codes.
+
 ## 0.1.4
 
 * Support automatically_recover of RabbitMQ for rpc.

data/{LICENSE.txt → LICENSE.md}

@@ -1,4 +1,4 @@
-Copyright (c) 2015 Boohee
+Copyright (c) 2016 Boohee
 
 MIT License
 

data/README.md

@@ -1,4 +1,8 @@
-# SneakersPacker
+# SneakersPacker [![Build Status][travis-image]][travis-link]
+
+[travis-image]: https://travis-ci.org/xiewenwei/sneakers_packer.svg?branch=master
+[travis-link]: http://travis-ci.org/xiewenwei/sneakers_packer
+[travis-home]: http://travis-ci.org/
 
 SneakersPacker is a gem for using sneakers to realize 3 message communication patterns job message, broadcast and RPC(remote procedure call).
 
@@ -125,9 +129,16 @@ remote call with custom timeouit.
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+**How to run test?**
+
+1.start RabbitMQ Server. for mac
+`rabbitmq-server`
+
+2.start test workers
+`ruby test/sneakers_test_workers.rb`
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+3.run test
+`bundle exec rake test`
 
 ## Contributing
 

data/lib/sneakers_packer/rpc_client.rb

@@ -1,18 +1,15 @@
 module SneakersPacker
   class RpcClient
-
-    attr_reader :reply_queue
-    attr_accessor :response, :call_id
-    attr_reader :lock, :condition
+    attr_reader :client_lock, :request_hash
 
     def initialize(publisher)
       @publisher = publisher
-      channel, exchange = fetch_channel_and_exchange
-      @queue_name = "rpc.#{SecureRandom.uuid}"
-      @consumer = build_reply_queue(channel, exchange)
-    end
+      @client_lock = Mutex.new
+      @request_lock = Mutex.new
+      @request_hash = {}
 
-    NO_RESPONSE = :__no_resp
+      @subscriber = RpcReplySubscriber.new self, publisher
+    end
 
     # call remote service via rabbitmq rpc
     # @param name route_key for service
@@ -20,86 +17,35 @@ module SneakersPacker
     # @param options{timeout} [int] timeout. seconds.   optional
     # @return result of service
     # @raise RemoteCallTimeoutError if timeout
-    def call(name, message, options = {})
-      self.call_id = SecureRandom.uuid
-      self.response = NO_RESPONSE
+    def call(request, options = {})
+      add_request(request)
 
-      ensure_reply_queue!
-
-      @exchange.publish(message.to_s,
-                        routing_key:    name.to_s,
-                        correlation_id: call_id,
-                        reply_to:       @reply_queue.name)
+      @publisher.publish(request.message,
+                         routing_key: request.name,
+                         correlation_id: request.call_id,
+                         reply_to: @subscriber.reply_queue_name)
 
       timeout = (options[:timeout] || SneakersPacker.conf.rpc_timeout).to_i
 
-      lock.synchronize { condition.wait(lock, timeout) }
+      client_lock.synchronize { request.condition.wait(client_lock, timeout) }
 
-      if response == NO_RESPONSE
-        raise RemoteCallTimeoutError, "Remote call timeouts.Exceed #{timeout} seconds."
+      remove_request(request)
+
+      if request.processed?
+        request.response_data
       else
-        response
+        raise RemoteCallTimeoutError, "Remote call timeouts.Exceed #{timeout} seconds."
       end
     end
 
     private
 
-    def ensure_reply_queue!
-      reconnected = false
-      channel = nil
-      exchange = nil
-
-      @publisher.instance_eval do
-        if @bunny.nil? || !@bunny.automatically_recover?
-          # ensure_connection connection first
-          @mutex.synchronize do
-            unless connected?
-              ensure_connection!
-              reconnected = true
-              channel = @channel
-              exchange = @exchange
-            end
-          end
-        end
-      end
-
-      # rebuid reply_queue when reconnecting occur
-      if reconnected
-        @consumer = build_reply_queue(channel, exchange)
-      end
-    end
-
-    def build_reply_queue(channel, exchange)
-      @channel, @exchange = channel, exchange
-
-      @reply_queue    = channel.queue(@queue_name, exclusive: true)
-      @reply_queue.bind(exchange, routing_key: @reply_queue.name)
-
-      @lock      = Mutex.new
-      @condition = ConditionVariable.new
-      that       = self
-
-      @reply_queue.subscribe(manual_ack: false) do |delivery_info, properties, payload|
-        if properties[:correlation_id] == that.call_id
-          that.response = payload
-          that.lock.synchronize { that.condition.signal }
-        end
-      end
+    def add_request(request)
+      @request_lock.synchronize { @request_hash[request.call_id] = request }
     end
 
-    # hack seankers publisher to get channel and exchange
-    def fetch_channel_and_exchange
-      ret = nil
-
-      @publisher.instance_eval do
-        # ensure_connection connection first
-        @mutex.synchronize do
-          ensure_connection! unless connected?
-        end
-        ret = [@channel, @exchange]
-      end
-
-      ret
+    def remove_request(request)
+      @request_lock.synchronize { @request_hash.delete request.call_id }
     end
   end
 end

data/lib/sneakers_packer/rpc_reply_subscriber.rb

@@ -0,0 +1,48 @@
+module SneakersPacker
+  class RpcReplySubscriber
+
+    def initialize(client, publisher)
+      @client = client
+      @publisher = publisher
+      @queue_name = "rpc.#{SecureRandom.uuid}"
+
+      initialize_reply_queue
+    end
+
+    def reply_queue_name
+      @queue_name
+    end
+
+    private
+
+    def initialize_reply_queue
+      # ensure_connection
+      @publisher.instance_eval do
+        @mutex.synchronize { ensure_connection! unless connected? }
+      end
+
+      channel = @publisher.instance_variable_get :@channel
+      exchange = @publisher.instance_variable_get :@exchange
+      build_reply_queue(channel, exchange)
+    end
+
+    def build_reply_queue(channel, exchange)
+      @reply_queue = channel.queue(@queue_name, exclusive: true)
+
+      @reply_queue.bind(exchange, routing_key: @reply_queue.name)
+
+      that = @client
+
+      @reply_queue.subscribe(manual_ack: false) do |delivery_info, properties, payload|
+        request = that.request_hash[properties[:correlation_id]]
+        if request
+          request.response = payload
+          request.set_processed!
+          that.client_lock.synchronize { request.condition.signal }
+        else
+          Sneakers.logger.warn "#{properties[:correlation_id]}'s request is not found"
+        end
+      end
+    end
+  end
+end

data/lib/sneakers_packer/rpc_request.rb

@@ -0,0 +1,36 @@
+module SneakersPacker
+  class RpcRequest
+    attr_reader :name, :call_id, :condition
+    attr_reader :response_data, :from, :status
+
+    def initialize(name, data)
+      @name = name.to_s
+      @data = data
+      @call_id = SecureRandom.uuid
+
+      @response = nil
+      @processed = false
+      @condition = ConditionVariable.new
+    end
+
+    def message
+      SneakersPacker.message_packer.pack_request(@data)
+    end
+
+    def processed?
+      @processed
+    end
+
+    def set_processed!
+      @processed = true
+    end
+
+    def response=(value)
+      @response_data, @from, @status = nil, nil, nil
+      @response = value
+      if value
+        @response_data, @from, @status = SneakersPacker.message_packer.unpack_response(value)
+      end
+    end
+  end
+end

data/lib/sneakers_packer/version.rb

@@ -1,3 +1,3 @@
 module SneakersPacker
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

data/lib/sneakers_packer.rb

@@ -3,42 +3,71 @@ require "sneakers_packer/version"
 require "sneakers_packer/configuration"
 require "sneakers_packer/message_packer"
 require "sneakers_packer/common_worker"
+
 require "sneakers_packer/rpc_worker"
+require "sneakers_packer/rpc_request"
+require "sneakers_packer/rpc_reply_subscriber"
 require "sneakers_packer/rpc_client"
 
 module SneakersPacker
   class RemoteCallTimeoutError < StandardError; end
 
-  # sender message to sneaker exchange
-  # @param name route_key for message
-  # @param data
-  def self.publish(name, data)
-    message = message_packer.pack_request(data)
+  # sneakers_packer_mutex is mutex for class instance variables initialization
+  @sneakers_packer_mutex = Mutex.new
+  @publish_mutex = Mutex.new
 
-    publisher.publish message, to_queue: name
-  end
+  class << self
+    # sender message to sneaker exchange
+    # @param name route_key for message
+    # @param data
+    def publish(name, data)
+      message = message_packer.pack_request(data)
+      @publish_mutex.synchronize do
+        publisher.publish message, to_queue: name
+      end
+    end
 
-  # call remote service via rabbitmq rpc
-  # @param name route_key for service
-  # @param data
-  # @param options{timeout} [int] timeout. seconds.   optional
-  # @return result of service
-  # @raise RemoteCallTimeoutError if timeout
-  #
-  def self.remote_call(name, data, options = {})
-    @client ||= RpcClient.new(publisher)
-    message = message_packer.pack_request(data)
-    response = @client.call name, message, options
-    response_data, from, status = message_packer.unpack_response(response)
-    response_data
-  end
+    # call remote service via rabbitmq rpc
+    # @param name route_key for service
+    # @param data
+    # @param options{timeout} [int] timeout. seconds.   optional
+    # @return result of service
+    # @raise RemoteCallTimeoutError if timeout
+    #
+    def remote_call(name, data, options = {})
+      request = RpcRequest.new name, data
 
-  def self.publisher
-    @publisher ||= ::Sneakers::Publisher.new
-  end
+      rpc_client.call request, options
+    end
+
+    # publisher is a singleton object
+    def publisher
+      if !@publisher
+        @sneakers_packer_mutex.synchronize {
+          @publisher ||= ::Sneakers::Publisher.new
+        }
+      end
+      @publisher
+    end
+
+    # message_packer is a singleton object
+    def message_packer
+      if !@message_packer
+        @sneakers_packer_mutex.synchronize {
+          @message_packer ||= MessagePacker.new(self.conf.app_name)
+        }
+      end
+      @message_packer
+    end
 
-  # message_packer is a singleton object
-  def self.message_packer
-    @message_packer ||= MessagePacker.new(self.conf.app_name)
+    def rpc_client
+      if !@rpc_client
+        _publisher = publisher
+        @sneakers_packer_mutex.synchronize {
+          @rpc_client ||= RpcClient.new(_publisher)
+        }
+      end
+      @rpc_client
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sneakers_packer
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - vincent
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-02-16 00:00:00.000000000 Z
+date: 2016-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sneakers
@@ -106,16 +106,16 @@ files:
 - ".travis.yml"
 - CHANGELOG.md
 - Gemfile
-- LICENSE.txt
+- LICENSE.md
 - README.md
 - Rakefile
-- bin/console
-- bin/setup
 - lib/sneakers_packer.rb
 - lib/sneakers_packer/common_worker.rb
 - lib/sneakers_packer/configuration.rb
 - lib/sneakers_packer/message_packer.rb
 - lib/sneakers_packer/rpc_client.rb
+- lib/sneakers_packer/rpc_reply_subscriber.rb
+- lib/sneakers_packer/rpc_request.rb
 - lib/sneakers_packer/rpc_worker.rb
 - lib/sneakers_packer/version.rb
 - sneakers_packer.gemspec

data/bin/console

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-
-require "bundler/setup"
-require "sneakers_packer"
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require "irb"
-IRB.start

data/bin/setup

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-
-bundle install
-
-# Do any other automated setup that you need to do here