ruby_rabbitmq_janus 1.1.12 → 1.2.0

data/lib/rrj/janus/processus/concurrency.rb

@@ -5,7 +5,11 @@ module RubyRabbitmqJanus
     # Modules for create autonomous processus
     module Concurrencies
       # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
-      # Abstract class for janus Event and Keepalive
+
+      # # Class for manage threads
+      #
+      # @abstract Manage thread in this gem for keepalive message and listen
+      # standard queue.
       class Concurrency
         # Initialize class with elements for thread communication
         def initialize
@@ -14,37 +18,19 @@ module RubyRabbitmqJanus
           @lock = Mutex.new
           @condition = ConditionVariable.new
           @thread = Thread.new { initialize_thread }
-          @thread.abort_on_exception = true
         end
 
         private
 
-        # Initialize a thread
         def initialize_thread
-          rabbit.transaction_long { transaction_running }
+          @rabbit.transaction_long { transaction_running }
         rescue Interrupt
           Tools::Log.instance.info "Stop transaction #{self.class.name}"
-          rabbit.close
-        end
-
-        # Wait an signal
-        def wait
-          @lock.synchronize do
-            @condition.wait(@lock)
-            Tools::Log.instance.info 'Waitting signal'
-            yield
-          end
-        end
-
-        # Send and signal
-        def signal
-          @lock.synchronize do
-            Tools::Log.instance.info 'Sending signal'
-            @condition.signal
-          end
+          @rabbit.close
         end
 
         attr_accessor :rabbit, :publish
+        attr_reader :thread, :lock, :condition
       end
     end
   end

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

@@ -1,33 +1,31 @@
 # frozen_string_literal: true
-# :reek:InstanceVariableAssumption and :reek:NilCheck
-# :reek:TooManyInstanceVariables and :reek:TooManyStatements
 
 module RubyRabbitmqJanus
-  # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
   module Janus
     module Concurrencies
-      # For listen standard queue ("from-janus" by default)
+      # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+
+      # # Listen standar queue
+      #
+      # Listen standard queue and sending a block code to thread listen.
+      # The default queue is configured in config file.
+      #
+      # @see file:/config/default.md For more information to config file used.
       class Event < Concurrency
         include Singleton
 
-        # Initialize Event object. Is used for listen an standard out queue to
-        # Janus
-        def initialize
-          super
-          @publish = @response = nil
-        end
-
-        # Execute an block code in a thread
+        # Create a thred for execute a block code in a thread
+        #
+        # @yield Send to publisher the actions when a Janus event is received
         def run(&block)
-          @thread.join
+          thread.join
           Thread.new do
-            loop { @thread.thread_variable_get(:publish).listen_events(&block) }
+            loop { thread.thread_variable_get(:publish).listen_events(&block) }
           end
         end
 
         private
 
-        # Initialize a thread
         def transaction_running
           publisher = Rabbit::Publisher::Listener.new(rabbit)
           Thread.current.thread_variable_set(:publish, publisher)

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

@@ -4,59 +4,64 @@ module RubyRabbitmqJanus
   module Janus
     module Concurrencies
       # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
-      # Manage sending keepalive message
+
+      # # Manage sending keepalive message
+      #
+      # Create a thread for sending keepalive to session created by this
+      # instanciate gem
       class Keepalive < Concurrency
         include Singleton
 
-        # Initalize a keepalive message
+        # Create a thread
         def initialize
-          @publish = @response = nil
+          @response = nil
           super
         end
 
-        # Return an number session created
+        # @return [Fixnum] Identifier to session created by Janus
         def session
-          wait { @response.session }
+          lock.synchronize do
+            condition.wait(lock)
+            Tools::Log.instance.info 'Waitting signal'
+            running_session
+          end
         end
 
         private
 
-        # Star an session with janus and waiting an signal for saving session_id
         def transaction_running
           @response = Janus::Responses::Standard.new(create_session)
-          signal
+          lock.synchronize do
+            Tools::Log.instance.info 'Sending signal'
+            condition.signal
+          end
           session_keepalive(ttl)
         end
 
-        # Create an loop for sending a keepalive message
         def session_keepalive(time_to_live)
           loop do
             sleep time_to_live
-            @publish.send_a_message(message_keepalive)
+            publish.send_a_message(message_keepalive)
           end
         rescue => message
           Tools::Log.instance.debug "Error keepalive : #{message}"
         end
 
-        # Define a Time To Live between each request sending to janus
         def ttl
           Tools::Config.instance.options['gem']['session']['keepalive'].to_i
         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::Messages::Standard.new('base::create'))
+          publish = Rabbit::Publisher::PublishExclusive.new(rabbit.channel, '')
+          publish.send_a_message(Janus::Messages::Standard.new('base::create'))
         end
 
-        # Return session_id
         def running_session
           @response.session
         end
 
-        # Create an message with type keepalive
         def message_keepalive
           Janus::Messages::Standard.new('base::keepalive',
                                         'session_id' => running_session)

data/lib/rrj/janus/responses/response.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# :reek:TooManyMethods and :reek:DuplicateMethodCall
 
 module RubyRabbitmqJanus
   module Janus

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

@@ -4,43 +4,37 @@ module RubyRabbitmqJanus
   module Janus
     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
+        # Opening a long transaction with rabbitmq. If handle is equal to 0
+        # create an handle, send request 'type::atach' before message.
+        #
+        # @yield Send a message to Janus
+        #
+        # @return [Fixnum] Sender using in current transaction
         def connect
           rabbit.transaction_short do
             choose_queue
-            send_a_message { yield }
-          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
+            create_handle if handle.eql?(0)
             yield
           end
+          handle
         end
 
         # Publish an message in handle
-        def publish_message_handle(type, options = {})
+        def publish_message_handle(type, options)
           opts = {
             'session_id' => session,
             'handle_id' => handle,
-            'add' => {
-              'admin_secret' => admin_secret
-            }
+            'admin_secret' => admin_secret
           }
           msg = Janus::Messages::Admin.new(type, opts.merge!(options))
-          send_a_message { msg }
+          publisher = publish.send_a_message(msg)
+          Janus::Responses::Standard.new(read_response(publisher))
         end
 
-        # Stop an handle running
-        def handle_running_stop
-          publish_message_handle('base::detach')
-        end
+        private
 
         # Define queue used for admin message
         def choose_queue
@@ -48,8 +42,6 @@ module RubyRabbitmqJanus
           @publish = Rabbit::Publisher::PublisherAdmin.new(chan)
         end
 
-        private
-
         # Override method for publishing an message and reading a response
         def send_a_message
           Tools::Log.instance.info 'Publish a message ...'

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

@@ -4,48 +4,40 @@ module RubyRabbitmqJanus
   module Janus
     module Transactions
       # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+
       # This class work with janus and send a series of message
-      # :reek:TooManyStatements
       class Handle < Session
-        # Inistialize transaction handle
-        def initialize(session)
+        # Initialize a transaction with handle
+        #
+        # @param [Fixnum] session
+        #   Use a session identifier for created message
+        def initialize(session, exclusive, handle = 0)
           super(session)
-          @exclusive = nil
-        end
-
-        # Initialize connection to Rabbit and Janus
-        def handle_connect(exclusive)
           @exclusive = exclusive
-          rabbit.transaction_long do
-            choose_queue(exclusive)
-            create_handle
-            yield
-          end
-          handle
+          @handle = handle
         end
 
-        # Initialize connection to Rabbit and Janus and close after sending an
-        # received a response
-        def handle_connect_and_stop(exclusive, sender)
-          @exclusive = exclusive
+        # Opening a long transaction with rabbitmq and is ending closing
+        # transaction, so delete exclusive queue
+        #
+        # @yield Send a message to Janus
+        #
+        # @return [Fixnum] Sender using in current transaction
+        def connect
           rabbit.transaction_short do
-            choose_queue(exclusive)
-            sender.eql?(0) ? create_handle : connect_handle(sender)
+            choose_queue
+            create_handle
             yield
           end
-        end
-
-        # Stop an handle running
-        def handle_running_stop
-          publish_message_handle('base::detach')
+          handle
         end
 
         # Publish an message in handle
-        def publish_message_handle(type, options = {})
+        def publish_message_handle(type, options)
           opts = { 'session_id' => session, 'handle_id' => handle }
           msg = Janus::Messages::Standard.new(type, opts.merge!(options))
           publisher = publish.send_a_message(msg)
-          Janus::Responses::Standard.new(read_response(publisher, @exclusive))
+          Janus::Responses::Standard.new(read_response(publisher))
         end
 
         private
@@ -58,12 +50,6 @@ module RubyRabbitmqJanus
           @handle = send_a_message_exclusive { msg }
         end
 
-        # Connect to handle
-        def connect_handle(sender)
-          Tools::Log.instance.info 'Connect an handle'
-          @handle = sender
-        end
-
         # Send a messaeg in exclusive queue
         def send_a_message_exclusive
           Janus::Responses::Standard.new(read_response_exclusive do

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

@@ -4,14 +4,21 @@ module RubyRabbitmqJanus
   module Janus
     module Transactions
       # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
-      # This class work with janus and send a series of message for session
-      # level
+
+      # # Manage a transaction
+      # Manage a transaction with message if contains a session identifier
       class Session < Transaction
-        # Connect to session and post an message
-        def session_connect(exclusive)
+        # Opening a short transaction with rabbitmq and close when is ending
+        #
+        # @param [Boolean] exclusive
+        #   Determine if the message is sending to a exclusive queue or not
+        #
+        # @yield Send a message to Janus
+        def connect(exclusive)
+          @exclusive = exclusive
           rabbit.transaction_short do
-            choose_queue(exclusive)
-            send_a_message(exclusive) { yield }
+            choose_queue
+            send_a_message { yield }
           end
         end
       end

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

@@ -1,39 +1,33 @@
 # frozen_string_literal: true
-# :reek:TooManyInstanceVariables and :reek:ControlParameter
-# :reek:ControlParameter and :reek:BooleanParameter
 
 module RubyRabbitmqJanus
   module Janus
-    # Define an module for manipulate a message between apps and janus
+    # Define an module for manipulate messages between apps and Janus
     module Transactions
       # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
-      # This class work with janus and send a series of message
+
+      # # Manage a transactions
+      # This class work with Janus and send a series of message
       class Transaction
-        # Initialize an transaction
+        # Initialize a transaction
+        #
+        # @param [Fixnum] session
+        #   Use a session identifier for created message
         def initialize(session)
           @rabbit = Rabbit::Connect.new
           @session = session
-          @response = @handle = @publish = nil
+          @publish = @exclusive = 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(exclusive) { yield }
-          end
-        end
-
         private
 
-        attr_reader :rabbit, :session, :response, :handle, :publish
+        attr_reader :rabbit, :session, :response, :handle, :publish, :exclusive
 
-        # determine queue used
-        def choose_queue(exclusive)
+        def choose_queue
           chan = @rabbit.channel
-          @publish = if exclusive
+          @publish = if @exclusive
                        Tools::Log.instance.debug \
                          'Choose an queue Exclusive : ampq.gen-xxx'
                        Rabbit::Publisher::PublishExclusive.new(chan, '')
@@ -44,16 +38,14 @@ module RubyRabbitmqJanus
                      end
         end
 
-        # Send a message to queue
-        def send_a_message(exclusive)
+        def send_a_message
           Tools::Log.instance.info 'Publish a message ...'
           publish = @publish.send_a_message(yield)
-          Janus::Responses::Standard.new(read_response(publish, exclusive))
+          Janus::Responses::Standard.new(read_response(publish))
         end
 
-        # Read a response if is a exclusive message
-        def read_response(publish, exclusive)
-          if exclusive
+        def read_response(publish)
+          if @exclusive
             Tools::Log.instance.info '... and read a janus response'
             publish
           else

data/lib/rrj/rabbit/connect.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# :reek:FeatureEnvy
 
 module RubyRabbitmqJanus
   module Rabbit
@@ -9,7 +8,7 @@ module RubyRabbitmqJanus
       # Initialize connection to server RabbitMQ
       def initialize
         Tools::Log.instance.debug 'Initialize connection with RabbitMQ'
-        @rabbit = Bunny.new(read_options_server)
+        @rabbit = Bunny.new(read_options_server.merge!(option_log_rabbit))
       end
 
       # Create an transaction with rabbitmq and close after response is received
@@ -54,9 +53,9 @@ module RubyRabbitmqJanus
         cfg = Tools::Config.instance.options['rabbit']
         opts = {}
         %w(host port pass user vhost).each do |val|
-          opts.merge!(val.to_sym => Tools::Env.instance.test_env_var(cfg, val))
+          opts.merge!(val.to_sym => cfg[val])
         end
-        opts.merge!(option_log_rabbit)
+        opts
       end
 
       # Define option logs for bunny