ruby_rabbitmq_janus 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c75cd0c7c7d224f8c5f3386e7eb847de7ffcecbc
-  data.tar.gz: 17fe7cc7dfb933f50fe6293fbd9015f209bae0d9
+  metadata.gz: bb6b179f8eb2d1d0f17269da3861f0d128100a3e
+  data.tar.gz: e4dae7a3f07f17a4d92cf10b537830bc7e74b9a7
 SHA512:
-  metadata.gz: 07d48d6283589d3adfd76be6820de3bb3508cf565a0e22af174e1704b8eeefdfb8bffca6d7d3afeb904627e92d71ac0af391545a58abe18d3985fae0d8b4ee36
-  data.tar.gz: b6704497ca1ed9f0bace2e8f024e6da2a2e4998948a64371a662572aecab6c00a941699e9bbd0a3bc8a16d6f01de39eaa8889e60345df2af3edb3fd8e700377c
+  metadata.gz: 95f5ed36b90f240b1c42b36785826795a501a4d7f4c7b57a342dcb55007d1a795d5102efdcd35c49df5571d1188ae12d3c0b7409fa8ee51a7e73dc79b0131e20
+  data.tar.gz: 7e352cabebf3d24213768e49466588205c7557d95c6be73e9e31089aa8c73a8331dda52cc2682f2502a7e18bdd01e9be97dff60399e6121e6f3b13f8f2dcabb8

data/lib/rrj/errors/janus_response.rb

@@ -23,7 +23,8 @@ module RubyRabbitmqJanus
     # Define an error for simple message
     class JanusResponseSimple < JanusResponse
       def initialize(message)
-        super "[#{message['code']}] #{message['reason']}"
+        error = message['error']
+        super "[#{error['code']}] #{error['reason']} -- #{message}"
       end
     end
 
@@ -39,7 +40,7 @@ module RubyRabbitmqJanus
     # Define an exception for json
     class JanusResponseJson < JanusResponse
       def initialize(message)
-        super "Error transform to JSON : #{message}"
+        super "Error transform to JSON : #{message[0]} -- message : #{message[1]}"
       end
     end
 
@@ -55,7 +56,7 @@ module RubyRabbitmqJanus
     # Define an exception for hash
     class JanusResponseHash < JanusResponse
       def initialize(message)
-        super "Error transform to Hash : #{message}"
+        super "Error transform to Hash : #{message[0]} -- message : #{message[1]}"
       end
     end
 

data/lib/rrj/info.rb

@@ -3,7 +3,7 @@
 # Define constant to gem.
 module RubyRabbitmqJanus
   # Define version to gem
-  VERSION = '1.0.2'
+  VERSION = '1.0.3'
 
   # Define a summary description to gem
   SUMMARY = 'Ruby RabbitMQ Janus'

data/lib/rrj/init.rb

@@ -15,20 +15,31 @@ module RubyRabbitmqJanus
   # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
   # Initialize gem and create automatically an session with Janus
   # @!attribute [r] session
-  # :reek:BooleanParameter
+  # :reek:BooleanParameter and :reek:ControlParameter
   class RRJ
     attr_reader :session, :event
 
     # Returns a new instance of RubyRabbitmqJanus
-    def initialize(listen_queue_classic = true)
+    def initialize
+      # Instanciate singleton tools
       start_instances_tools
+
+      # Create an session while time opening
       @session = Janus::Keepalive.instance.session
-      Janus::Event.instance if listen_queue_classic
+
       @transaction = nil
     rescue => error
       raise Errors::RRJErrorInit, error
     end
 
+    # Listen a standar queue and working if necesary
+    def listen(&block)
+      # Send a processus to background
+      # fork do
+      Janus::Event.instance.listen(&block)
+      # end
+    end
+
     # Send an simple message to janus. No options in request with this method.
     # @param [String] type
     #   Given a type to request. JSON request writing in 'config/requests/'
@@ -39,7 +50,7 @@ module RubyRabbitmqJanus
     #   #=> {"janus":"server_info","name":"Janus WebRTC Gateway" ... }
     # @return [RubyRabbitmqJanus::Janus::Response] Give an object response to janus server
     def message_simple(type = 'base::info', exclusive = false)
-      Janus::Transaction.new(@session).connect(exclusive) do
+      Janus::Transactions::Transaction.new(@session).connect(exclusive) do
         Janus::Message.new(type)
       end
     end
@@ -55,7 +66,7 @@ module RubyRabbitmqJanus
     #   #=> {"janus":"server_info","name":"Janus WebRTC Gateway" ... }
     # @return [RubyRabbitmqJanus::Janus::Response] Give an object response to janus server
     def message_session(type, options = {}, exclusive = false)
-      Janus::TransactionSession.new(@session).session_connect(exclusive) do
+      Janus::Transactions::Session.new(@session).session_connect(exclusive) do
         Janus::Message.new(type, use_current_session?(options))
       end
     rescue => error
@@ -71,7 +82,7 @@ module RubyRabbitmqJanus
     #   #=> {"janus":"success","sessions": [12345, 8786567465465, ...] }
     # @return [RubyRabbitmqJanus::Janus::Response] Give an object response to janus server
     def message_admin(type, options = {})
-      Janus::TransactionAdmin.new(@session).connect do
+      Janus::Transactions::Admin.new(@session).connect do
         Janus::MessageAdmin.new(type, options.merge!('session_id' => @session))
       end
     end
@@ -92,7 +103,7 @@ module RubyRabbitmqJanus
 
     # Define an handle transaction and establish connection with janus
     def start_handle(exclusive = false)
-      @transaction ||= Janus::TransactionHandle.new(@session)
+      @transaction ||= Janus::Transactions::Handle.new(@session)
       @transaction.handle_connect(exclusive) { yield }
     rescue => error
       raise Errors::RRJErrorHandle, error
@@ -100,7 +111,7 @@ module RubyRabbitmqJanus
 
     # Define an handle admin transaction and establish connection with janus
     def start_handle_admin
-      @transaction ||= Janus::TransactionAdmin.new(@session)
+      @transaction ||= Janus::Transactions::Admin.new(@session)
       @transaction.handle_connect { yield }
     rescue => error
       raise Errors::RRJErrorHandle, error
@@ -113,7 +124,7 @@ module RubyRabbitmqJanus
 
     # Start an short transaction, this queue is not exclusive
     def handle_message_simple(type, replace = {}, add = {})
-      @transaction ||= Janus::TransactionHandle.new(@session)
+      @transaction ||= Janus::Transactions::Handle.new(@session)
       @transaction.handle_connect_and_stop(false) do
         message_handle(type, replace, add).for_plugin
       end
@@ -131,6 +142,7 @@ module RubyRabbitmqJanus
       Tools::Log.instance
       Tools::Config.instance
       Tools::Requests.instance
+      Janus::Event.instance
     end
 
     # Return a current session if not specified

data/lib/rrj/janus/response.rb

@@ -4,6 +4,7 @@ module RubyRabbitmqJanus
   module Janus
     # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
     # Read and decryt a response to janus
+    # :reek:TooManyMethods
     class Response
       # Instanciate a response
       def initialize(response_janus)
@@ -21,7 +22,7 @@ module RubyRabbitmqJanus
         @request.to_json
       rescue => error
         Tools::Log.instance.debug "Request error : #{@request}"
-        raise Errors::JanusResponseJson, error
+        raise Errors::JanusResponseJson, [error, @request]
       end
 
       # Return request to json format with nice format
@@ -38,7 +39,7 @@ module RubyRabbitmqJanus
         @request
       rescue => error
         Tools::Log.instance.debug "Request error : #{@request}"
-        raise Errors::JanusResponseHash, error
+        raise Errors::JanusResponseHash, [error, @request]
       end
 
       # Return a response simple for client
@@ -62,8 +63,33 @@ module RubyRabbitmqJanus
         data_id
       end
 
+      # Return event to message
+      def event
+        @request['janus']
+      end
+
+      # Return body data
+      def data
+        @request['plugindata']['data'] if plugin_response?
+      end
+
+      # Return jsep data
+      def jsep
+        @request['jsep'] if contains_jsep?
+      end
+
       private
 
+      # Test if response is returning by plugin
+      def plugin_response?
+        @request.key?('plugindata') && @request['plugindata'].key?('data')
+      end
+
+      # Test if response contains jsep data
+      def contains_jsep?
+        @request.key?('jsep')
+      end
+
       # Read a hash and return an identifier
       def data_id
         analysis
@@ -75,7 +101,7 @@ module RubyRabbitmqJanus
       # Analysis response and send exception if janus return an error
       # :reek:DuplicateMethodCall
       def analysis
-        raise Errors::JanusResponseSimple, @request['error'] if error_simple?
+        raise Errors::JanusResponseSimple, @request if error_simple?
         raise Errors::JanusResponsePlugin, @request['plugindata']['data'] if error_plugin?
       end
 

data/lib/rrj/janus/threads/event.rb

@@ -4,30 +4,24 @@ module RubyRabbitmqJanus
   # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
   module Janus
     # For listen standard queue ("from-janus" by default)
-    class Event < OneThread
+    class Event < Concurrency
       include Singleton
 
       # Initialize Event object. Is used for listen an standard out queue to Janus
       def initialize
         Tools::Log.instance.debug 'Start listen events in from-janus queue'
-        @response = nil
+        @publish = @response = nil
         super
-        listen_live
+        start_thread
       end
 
-      # Start listen queue and return each message
-      def listen
-        lock.synchronize { condition.wait(lock) }
-        @response
+      # Start listen queue and work with each message reading
+      def listen(&block)
+        loop { @publish.event_received(&block) }
       end
 
       private
 
-      # Listen q queue "from-janus"
-      def listen_live
-        start_thread
-      end
-
       # Intialize an listen to queue
       def initialize_thread
         start_transaction
@@ -39,9 +33,8 @@ module RubyRabbitmqJanus
       # Start a transaction with Rabbit an Janus
       def start_transaction
         rabbit.transaction_long do
-          publisher = Rabbit::Publisher::Listener.new(rabbit)
-          @response = publisher.listen_events
-          lock.synchronize { condition.signal }
+          @publish = Rabbit::Publisher::Listener.new(rabbit)
+          @publish.listen_events
         end
       end
     end

data/lib/rrj/janus/threads/keepalive.rb

@@ -4,44 +4,37 @@ module RubyRabbitmqJanus
   module Janus
     # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
     # Manage sending keepalive message
-    class Keepalive < OneThread
+    class Keepalive < Concurrency
       include Singleton
 
       # Initalize a keepalive message
       def initialize
         Tools::Log.instance.debug 'Create an session for keepalive'
-        super
         @publish = @response = nil
-        session_live
+        super
+        start_thread
       end
 
       # Return an number session created
       def session
-        lock.synchronize { condition.wait(lock) }
-        @response.session
+        wait { @response.session }
       end
 
       private
 
-      # Send to regular interval a message keepalive
-      def session_live
-        start_thread
-      end
-
       # Initialize an session with janus and start a keepalive transaction
       def initialize_thread
-        rabbit.start
-        @response = session_start
-        lock.synchronize { condition.signal }
-        session_keepalive(ttl)
+        rabbit.transaction_long { transaction_keepalive }
+      rescue Interrupt
+        Tools::Log.instance.info 'Stop to sending keepalive'
         rabbit.close
       end
 
-      # Star an session janus
-      def session_start
-        msg_create = Janus::Message.new 'base::create'
-        @publish = Rabbit::Publisher::PublishExclusive.new(rabbit.channel, '')
-        @response = Janus::Response.new(@publish.send_a_message(msg_create))
+      # Star an session with janus and waiting an signal for saving session_id
+      def transaction_keepalive
+        @response = Janus::Response.new(create_session)
+        signal
+        session_keepalive(ttl)
       end
 
       # Create an loop for sending a keepalive message
@@ -49,7 +42,7 @@ module RubyRabbitmqJanus
         loop do
           sleep time_to_live
           @publish.send_a_message(Janus::Message.new('base::keepalive',
-                                                     'session_id' => @response.session))
+                                                     'session_id' => running_session))
         end
       rescue => message
         Tools::Log.instance.debug "Error keepalive : #{message}"
@@ -61,6 +54,17 @@ module RubyRabbitmqJanus
       rescue => error
         Tools::Log.instance.debug "TTL Not loading - #{error}"
       end
+
+      # Create an message and publish for create session in Janus
+      def create_session
+        @publish = Rabbit::Publisher::PublishExclusive.new(rabbit.channel, '')
+        @publish.send_a_message(Janus::Message.new('base::create'))
+      end
+
+      # Return session_id
+      def running_session
+        @response.session
+      end
     end
   end
 end

data/lib/rrj/janus/threads/thread.rb

@@ -4,9 +4,10 @@ module RubyRabbitmqJanus
   module Janus
     # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
     # Abstract class for janus Event and Keepalive
-    class OneThread
+    class Concurrency
       # Initialize class with elements for thread communication
       def initialize
+        Tools::Log.instance.info 'Create an subprocess'
         @rabbit = Rabbit::Connect.new
         @lock = Mutex.new
         @condition = ConditionVariable.new
@@ -14,11 +15,28 @@ module RubyRabbitmqJanus
 
       private
 
+      # Start a new thread
       def start_thread
         Thread.new { initialize_thread }
+        # pid = fork { initialize_thread }
+        # Tools::Log.instance.info "Process IDentifier : #{pid}"
+        # initialize_thread
       end
 
-      attr_accessor :rabbit, :lock, :condition
+      # Wait an signal
+      def wait
+        @lock.synchronize do
+          @condition.wait(@lock)
+          yield
+        end
+      end
+
+      # Send and signal
+      def signal
+        @lock.synchronize { @condition.signal }
+      end
+
+      attr_accessor :rabbit, :publish
     end
   end
 end

data/lib/rrj/janus/transactions/admin.rb

@@ -2,42 +2,44 @@
 
 module RubyRabbitmqJanus
   module Janus
-    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
-    # This class work with janus and send a series of message
-    class TransactionAdmin < TransactionHandle
-      # Initialize conncetion to Rabbit and Janus
-      def connect
-        rabbit.transaction_short do
-          choose_queue
-          send_a_message { yield }
+    module Transactions
+      # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+      # This class work with janus and send a series of message
+      class Admin < Handle
+        # Initialize conncetion to Rabbit and Janus
+        def connect
+          rabbit.transaction_short do
+            choose_queue
+            send_a_message { yield }
+          end
         end
-      end
 
-      # Choose queue, create an handle, connect to rabbitmq server and send messages
-      def handle_connect
-        rabbit.transaction_long do
-          choose_queue
-          create_handle
-          yield
+        # Choose queue, create an handle, connect to rabbitmq server and send messages
+        def handle_connect
+          rabbit.transaction_long do
+            choose_queue
+            create_handle
+            yield
+          end
         end
-      end
 
-      # Publish an message in handle
-      def publish_message_handle(type, options = {})
-        opts = { 'session_id' => session, 'handle_id' => handle }
-        msg = Janus::MessageAdmin.new(type, opts.merge!(options))
-        Janus::Response.new(publish.send_a_message(msg))
-      end
+        # Publish an message in handle
+        def publish_message_handle(type, options = {})
+          opts = { 'session_id' => session, 'handle_id' => handle }
+          msg = Janus::MessageAdmin.new(type, opts.merge!(options))
+          Janus::Response.new(publish.send_a_message(msg))
+        end
 
-      # Stop an handle running
-      def handle_running_stop
-        secret = Tools::Config.instance.options['rabbit']['admin_pass']
-        publish_message_handle('base::detach', admin_secret: secret)
-      end
+        # Stop an handle running
+        def handle_running_stop
+          secret = Tools::Config.instance.options['rabbit']['admin_pass']
+          publish_message_handle('base::detach', admin_secret: secret)
+        end
 
-      # Define queue used for admin message
-      def choose_queue
-        @publish = Rabbit::PublisherPublishAdmin.new(rabbit.channel)
+        # Define queue used for admin message
+        def choose_queue
+          @publish = Rabbit::PublisherPublishAdmin.new(rabbit.channel)
+        end
       end
     end
   end

data/lib/rrj/janus/transactions/handle.rb

@@ -2,38 +2,40 @@
 
 module RubyRabbitmqJanus
   module Janus
-    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
-    # This class work with janus and send a series of message
-    class TransactionHandle < TransactionSession
-      # Initialize connection to Rabbit and Janus
-      def handle_connect(exclusive)
-        rabbit.transaction_long do
-          choose_queue(exclusive)
-          create_handle
-          yield
+    module Transactions
+      # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+      # This class work with janus and send a series of message
+      class Handle < Session
+        # Initialize connection to Rabbit and Janus
+        def handle_connect(exclusive)
+          rabbit.transaction_long do
+            choose_queue(exclusive)
+            create_handle
+            yield
+          end
         end
-      end
 
-      # Initialize connection to Rabbit and Janus and close after sending an received
-      # a response
-      def handle_connect_and_stop(exclusive)
-        rabbit.transaction_short do
-          choose_queue(exclusive)
-          create_handle
-          yield
+        # Initialize connection to Rabbit and Janus and close after sending an received
+        # a response
+        def handle_connect_and_stop(exclusive)
+          rabbit.transaction_short do
+            choose_queue(exclusive)
+            create_handle
+            yield
+          end
         end
-      end
 
-      # Stop an handle running
-      def handle_running_stop
-        publish_message_handle('base::detach')
-      end
+        # Stop an handle running
+        def handle_running_stop
+          publish_message_handle('base::detach')
+        end
 
-      # Publish an message in handle
-      def publish_message_handle(type, options = {})
-        opts = { 'session_id' => session, 'handle_id' => handle }
-        msg = Janus::Message.new(type, opts.merge!(options))
-        Janus::Response.new(publish.send_a_message(msg))
+        # Publish an message in handle
+        def publish_message_handle(type, options = {})
+          opts = { 'session_id' => session, 'handle_id' => handle }
+          msg = Janus::Message.new(type, opts.merge!(options))
+          Janus::Response.new(publish.send_a_message(msg))
+        end
       end
     end
   end

data/lib/rrj/janus/transactions/session.rb

@@ -2,14 +2,16 @@
 
 module RubyRabbitmqJanus
   module Janus
-    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
-    # This class work with janus and send a series of message for session level
-    class TransactionSession < Transaction
-      # Connect to session and post an message
-      def session_connect(exclusive)
-        rabbit.transaction_short do
-          choose_queue(exclusive)
-          send_a_message { yield }
+    module Transactions
+      # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+      # This class work with janus and send a series of message for session level
+      class Session < Transaction
+        # Connect to session and post an message
+        def session_connect(exclusive)
+          rabbit.transaction_short do
+            choose_queue(exclusive)
+            send_a_message { yield }
+          end
         end
       end
     end

data/lib/rrj/janus/transactions/transaction.rb

@@ -2,53 +2,58 @@
 
 module RubyRabbitmqJanus
   module Janus
-    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
-    # This class work with janus and send a series of message
-    # :reek:TooManyInstanceVariables
-    class Transaction
-      # Initialize an transaction
-      def initialize(session)
-        @rabbit = Rabbit::Connect.new
-        @session = session
-        @response = @handle = @publish = nil
-      rescue => error
-        raise Errors::JanusTransaction, error
-      end
+    # Define an module for manipulate a message between apps and janus
+    module Transactions
+      # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+      # This class work with janus and send a series of message
+      # :reek:TooManyInstanceVariables
+      class Transaction
+        # Initialize an transaction
+        def initialize(session)
+          @rabbit = Rabbit::Connect.new
+          @session = session
+          @response = @handle = @publish = nil
+        rescue => error
+          raise Errors::JanusTransaction, error
+        end
 
-      # Opening a short transaction with rabbitmq and close when is ending
-      def connect(exclusive)
-        @rabbit.transaction_short do
-          choose_queue(exclusive)
-          send_a_message { yield }
+        # Opening a short transaction with rabbitmq and close when is ending
+        def connect(exclusive)
+          @rabbit.transaction_short do
+            choose_queue(exclusive)
+            send_a_message { yield }
+          end
         end
-      end
 
-      private
-
-      attr_reader :rabbit, :session, :response, :handle, :publish
-
-      # determine queue used
-      # :reek:ControlParameter and :reek:BooleanParameter
-      def choose_queue(exclusive = false)
-        chan = @rabbit.channel
-        @publish = if exclusive
-                     Tools::Log.instance.debug 'Choose an queue non Exclusive : to-janus'
-                     Rabbit::Publisher::PublishNonExclusive.new(chan)
-                   else
-                     Tools::Log.instance.debug 'Choose an queue Exclusive : ampq.gen-xxx'
-                     Rabbit::Publisher::PublishExclusive.new(chan, '')
-                   end
-      end
+        private
 
-      # Send a message to queue
-      def send_a_message
-        Janus::Response.new(@publish.send_a_message(yield))
-      end
+        attr_reader :rabbit, :session, :response, :handle, :publish
 
-      # Associate handle to transaction
-      def create_handle
-        msg = Janus::Message.new('base::attach', 'session_id' => @session)
-        @handle = send_a_message { msg }.sender
+        # determine queue used
+        # :reek:ControlParameter and :reek:BooleanParameter
+        def choose_queue(exclusive = false)
+          chan = @rabbit.channel
+          @publish = if exclusive
+                       Tools::Log.instance.debug \
+                         'Choose an queue non Exclusive : to-janus'
+                       Rabbit::Publisher::PublishNonExclusive.new(chan)
+                     else
+                       Tools::Log.instance.debug \
+                         'Choose an queue Exclusive : ampq.gen-xxx'
+                       Rabbit::Publisher::PublishExclusive.new(chan, '')
+                     end
+        end
+
+        # Send a message to queue
+        def send_a_message
+          Janus::Response.new(@publish.send_a_message(yield))
+        end
+
+        # Associate handle to transaction
+        def create_handle
+          msg = Janus::Message.new('base::attach', 'session_id' => @session)
+          @handle = send_a_message { msg }.sender
+        end
       end
     end
   end

data/lib/rrj/rabbit/publish/base_publisher.rb

@@ -2,6 +2,7 @@
 
 module RubyRabbitmqJanus
   module Rabbit
+    # Define an module for create an publisher
     module Publisher
       # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
       # @abstract Publish message in RabbitMQ
@@ -22,10 +23,10 @@ module RubyRabbitmqJanus
 
         # return an response when signal is trigger
         def return_response
-          Tools::Log.instance.debug 'Waiting an response ...'
+          Tools::Log.instance.debug 'Response received'
           @lock.synchronize do
             @condition.wait(@lock)
-            response
+            @response
           end
         end
       end

data/lib/rrj/rabbit/publish/listener.rb

@@ -10,6 +10,7 @@ module RubyRabbitmqJanus
         # Define an publisher
         def initialize(rabbit)
           super()
+          @response = nil
           @count = 1
           @rabbit = rabbit.channel
           @reply = @rabbit.queue(Tools::Config.instance.options['queues']['queue_from'])
@@ -21,16 +22,25 @@ module RubyRabbitmqJanus
           @reply.subscribe do |_info_delivery, _propertie, payload|
             synchronize_response(payload)
           end
-          return_response
+        end
+
+        # Execute an action for each response received in queue
+        def event_received
+          Tools::Log.instance.debug 'Response received'
+          lock.synchronize do
+            condition.wait(lock)
+            yield @response.event, @response.data, @response.jsep
+          end
         end
 
         private
 
         # Sending an signal when an response is reading in queue
         def synchronize_response(payload)
-          @response = JSON.parse payload
-          Tools::Log.instance.debug \
-            "[X] Message number reading : #{@count} -- type : #{response['janus']}"
+          @response = Janus::Response.new(JSON.parse(payload))
+          Tools::Log.instance.info \
+            "[X] Message number reading : #{@count} --\n\r" \
+            "type : #{@response}"
           @count += 1
           lock.synchronize { condition.signal }
         end

data/lib/rrj/rabbit/publish/non_exclusive.rb

@@ -7,6 +7,7 @@ module RubyRabbitmqJanus
       # Publish message in queue non exclusive. By default "to-janus".
       # This an option in config to this gem.
       class PublishNonExclusive < Publisher
+        # Define an publisher for create non exclusive queue
         def initialize(exchange)
           @reply = exchange.queue(queue_from)
           super(exchange)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_rabbitmq_janus
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - VAILLANT Jeremy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-09 00:00:00.000000000 Z
+date: 2016-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler