ruby_rabbitmq_janus 2.1.1 → 2.2.0.pre.42

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'rrj/janus/processus/keepalive/keepalive_timer'
+require 'rrj/janus/processus/keepalive/keepalive_message'
+require 'rrj/janus/processus/keepalive/keepalive_thread'
+
+module RubyRabbitmqJanus
+  module Janus
+    module Concurrencies
+      # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+      #
+      # # Manage keepalive message
+      #
+      # Create a thread for sending a message with type keepalive to session
+      # created by this instanciate gem
+      class KeepaliveInitializer < Concurrency
+        # Initialize a singleton object for sending keepalive to janus
+        def initialize(instance)
+          super()
+          @thread = KeepaliveThread.new(instance, rabbit) { initialize_thread }
+        rescue
+          raise Errors::Janus::KeepaliveInitializer::Initializer
+        end
+
+        # Get thread with Ruby ID
+        def self.thread(thread)
+          ObjectSpace._id2ref(thread)
+        rescue RangeError
+          puts "No thread with ID : #{thread}"
+        end
+
+        # Give a session Integer  his gem is instantiate.
+        # Is waiting a thread return a response to message created sending.
+        #
+        # @example Ask session
+        #   KeepaliveInitializer.new(123).session
+        #   => 852803383803249
+        #
+        # @return [Fixnum] Identifier to session created by Janus
+        def session
+          @thread.timer.session do
+            lock.synchronize do
+              condition.wait(lock)
+              @thread.session
+            end
+          end
+        rescue
+          raise Errors::Janus::KeepaliveInitializer::Session
+        end
+
+        # Ask Object ID to thread managing keepalive message
+        #
+        # @example Ask ID
+        #   KeepaliveInitializer.new(123).thread
+        #   => 70233080652140
+        #
+        # @return [Integer] Identifier to thread in Ruby
+        def thread_id
+          @thread.__id__
+        rescue
+          raise Errors::Janus::KeepaliveInitializer::Thread
+        end
+
+        private
+
+        def transaction_running
+          @thread.initialize_janus_session
+          lock.synchronize { condition.signal }
+          @thread.start
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# :reek:UtilityFunction
+
+module RubyRabbitmqJanus
+  module Janus
+    module Concurrencies
+      # Manage message used for keepalive thread
+      class KeepaliveMessage
+        def initialize(instance)
+          @instance = instance
+        end
+
+        def session
+          Janus::Messages::Standard.new('base::create', param_instance)
+        end
+
+        def response_session(message)
+          RubyRabbitmqJanus::Janus::Responses::Standard.new(message).session
+        end
+
+        def keepalive(session)
+          parameter = param_session(session)
+          Janus::Messages::Standard.new('base::keepalive', parameter)
+        end
+
+        def response_acknowledgement(message)
+          RubyRabbitmqJanus::Janus::Responses::Standard.new(message).error?
+        end
+
+        def destroy(session)
+          parameter = param_session(session)
+          Janus::Messages::Standard.new('base::destroy', parameter)
+        end
+
+        def response_destroy(message)
+          RubyRabbitmqJanus::Janus::Responses::Standard.new(message)
+        end
+
+        private
+
+        def param_instance
+          { 'instance' => @instance }
+        end
+
+        def param_session(session)
+          { 'session_id' => session }.merge(param_instance)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# :reek:TooManyInstanceVariables
+
+module RubyRabbitmqJanus
+  module Janus
+    module Concurrencies
+      # Object thread
+      class KeepaliveThread < Thread
+        attr_reader :timer, :instance, :session
+
+        def initialize(instance, rabbit, &block)
+          @publisher = @session = nil
+          @rabbit = rabbit
+          @timer = KeepaliveTimer.new
+          @message = KeepaliveMessage.new(instance)
+          super(&block)
+        end
+
+        # Initialize a transaction with Janus Instance.
+        # Create a session and save response
+        def initialize_janus_session
+          @publisher = publisher
+          @session = response_session
+        end
+
+        def start
+          @timer.loop_keepalive { response_keepalive }
+        end
+
+        def kill
+          response_destroy
+          super
+        end
+
+        def instance_is_down
+          janus = Models::JanusInstance.find_by_session(@session)
+          janus.set(enable: false)
+
+          Tools::Log.instance.fatal \
+            "Janus Instance [#{janus.instance}] is down, kill thread."
+          Thread.instance_method(:kill).bind(self).call
+        end
+
+        private
+
+        def publisher
+          Rabbit::Publisher::PublishKeepalive.new(@rabbit.channel)
+        end
+
+        def response_session
+          @message.response_session(publish(@message.session))
+        end
+
+        def response_keepalive
+          keepalive = @message.keepalive(@session)
+          @message.response_acknowledgement(publish(keepalive))
+        end
+
+        def response_destroy
+          destroy = @message.destroy(@session)
+          @message.response_destroy(publish(destroy))
+        end
+
+        def publish(message)
+          @publisher.publish(message)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'timeout'
+require 'timers'
+
+module RubyRabbitmqJanus
+  module Janus
+    module Concurrencies
+      # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+      #
+      # # Manage time for thread
+      #
+      # Configure all timer used in keepalive class
+      class KeepaliveTimer
+        # Initialize timer to keeaplive thread.
+        # Configure timer with :
+        #   - interval for each keepalive message
+        #   - timeout for session response
+        #   - timeout for publish message
+        def initialize
+          @time_to_live = Tools::Config.instance.ttl
+          @time_publish = @time_to_live + 5
+          @timer = Timers::Group.new
+        end
+
+        # Execute a loop with timer for sending keepalive message
+        # to Janus Instance
+        def loop_keepalive(&block)
+          @timer.now_and_every(@time_to_live) { prepare_loop(&block) }
+          loop { @timer.wait }
+        end
+
+        # Test if session is present/exist in Janus Instance
+        def session(&block)
+          Timeout.timeout(@time_publish) { yield }
+        rescue Timeout::Error
+          stop_timer
+          block.binding.receiver.instance_is_down
+        end
+
+        # Stop timer to keepalive thread
+        def stop_timer
+          @timer.pause
+        end
+
+        # Start timer to keepalive thread
+        def start_timer
+          @timer.resume
+        end
+
+        private
+
+        def prepare_loop(&block)
+          Timeout.timeout(@time_publish) do
+            yield
+          end
+        rescue Timeout::Error
+          stop_timer
+          block.binding.receiver.instance_is_down
+        end
+      end
+    end
+  end
+end

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

@@ -11,7 +11,7 @@ module RubyRabbitmqJanus
       # Read a message in rabbitmq queue. This message is formatted to JSON
       # or Hash format. For developpment it's possible to used a `nice` JSON.
       class Response
-        # Instanciate a response
+        # Instantiate a response
         #
         # @param [Hash] response_janus
         #   Request parsing after Janus/RabbitMQ receive a response to request
@@ -49,6 +49,13 @@ module RubyRabbitmqJanus
           raise Errors::Janus::Response::ToHash
         end
 
+        # Test if response it's an error
+        #
+        # @return [Boolean]
+        def error?
+          @request['janus'].match?('error')
+        end
+
         private
 
         attr_accessor :request

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

@@ -15,7 +15,7 @@ module RubyRabbitmqJanus
         # @param [Fixnum] session
         #   Use a session identifier for created message
         def initialize(session)
-          @rabbit = Rabbit::Connect.new
+          @rabbit = RubyRabbitmqJanus::Rabbit::Connect.new
           @session = session
           @publisher = @exclusive = nil
         rescue

data/lib/rrj/models/active_record.rb

@@ -6,9 +6,13 @@ module RubyRabbitmqJanus
     #
     # Store instance information for MongoID database
     class JanusInstance < ::ActiveRecord::Base
-      include RubyRabbitmqJanus::Models::JanusInstanceConcern
+      include RubyRabbitmqJanus::Models::JanusInstanceCallbacks
+      include RubyRabbitmqJanus::Models::JanusInstanceMethods
+      include RubyRabbitmqJanus::Models::JanusInstanceValidations
 
-      before_destroy { destroy_before_action }
+      after_create      { callback_after_after }
+      after_update      { callback_update_after }
+      after_destroy     { callback_destroy_after }
     end
   end
 end

data/lib/rrj/models/concerns/janus_instance_callbacks.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RubyRabbitmqJanus
+  # Contains all model for this gem
+  module Models
+    # Configure callback for Janus Instance models
+    module JanusInstanceCallbacks
+      extend ActiveSupport::Concern
+
+      # Create a session in Janus Instance
+      def callback_create_after
+        Tools::Log.instance.debug 'Callback AFTER_VALIDATION'
+        create_a_session_in_janus_instance if enable
+      end
+
+      # Update a keepalive transaction in Janus Instance
+      # Enable or Disable transaction
+      def callback_update_after
+        Tools::Log.instance.debug 'Callback AFTER_UPDATE'
+        if enable && enable_changed?
+          create_a_session_in_janus_instance
+        elsif !enable && enable_changed?
+          disable_a_session_in_janus_instance
+        end
+      end
+
+      # Destroy a session in Janus Instance
+      def callback_destroy_after
+        Tools::Log.instance.debug 'Callback AFTER_DESTROY'
+        destroy_a_session_in_janus_instance if enable && session? && thread?
+      end
+
+      private
+
+      def create_a_session_in_janus_instance
+        info_instance('Create session')
+        janus_instance = keepalive_object_new
+        set(session: janus_instance.session, thread: janus_instance.thread_id)
+      end
+
+      def disable_a_session_in_janus_instance
+        info_instance('Destroy session')
+        keepalive_object_thread.kill
+        unset(%I[thread session])
+      end
+
+      def destroy_a_session_in_janus_instance
+        info_instance('Destroy session')
+        keepalive_object_thread.kill
+      end
+
+      def keepalive_object
+        RubyRabbitmqJanus::Janus::Concurrencies::KeepaliveInitializer
+      end
+
+      def keepalive_object_new
+        keepalive_object.new(instance)
+      end
+
+      def keepalive_object_thread
+        keepalive_object.thread(thread)
+      end
+
+      def info_instance(text)
+        Tools::Log.instance.debug "#{text} in Janus Instance [##{instance}]"
+      end
+    end
+  end
+end

data/lib/rrj/models/concerns/{janus_instance_concern.rb → janus_instance_methods.rb}

@@ -5,17 +5,9 @@
 module RubyRabbitmqJanus
   module Models
     # Add method for JanusInstance model
-    module JanusInstanceConcern
+    module JanusInstanceMethods
       extend ActiveSupport::Concern
 
-      # Send an action for destroying a session in Janus Gateway instance
-      def destroy_before_action
-        options = { 'session_id' => session, 'instance' => instance }
-        search_initializer(options) do |transaction|
-          transaction.publish_message('base::destroy', options)
-        end
-      end
-
       # Class methods for JanusInstance model
       module ClassMethods
         # Disable an instance
@@ -23,7 +15,7 @@ module RubyRabbitmqJanus
           JanusInstance.find_by(session: session_id).set(enable: false)
         end
 
-        # Delete all instance disabled
+        # Clean all instance disabled
         def destroys
           JanusInstance.where(enable: false).delete_all
         end
@@ -41,6 +33,11 @@ module RubyRabbitmqJanus
         rescue
           nil
         end
+
+        # Get all instance active
+        def enabled
+          JanusInstance.where(enable: true)
+        end
       end
 
       private

data/lib/rrj/models/concerns/janus_instance_validations.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RubyRabbitmqJanus
+  module Models
+    # Configure validation for JanusInstance model
+    module JanusInstanceValidations
+      extend ActiveSupport::Concern
+
+      included do
+        # Instance number it's mandatory, unique and with type Integer
+        validates :instance, presence: true,
+                             numericality: { only_integer: true },
+                             uniqueness: true
+        # This instance it's a state (enable or disable)
+        validates :enable, presence: true,
+                           inclusion: { in: [true, false] }
+      end
+    end
+  end
+end