ruby_rabbitmq_janus 0.3.0 → 1.0.1

data/lib/rrj/errors/janus_response.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+# :reek:FeatureEnvy
+
+module RubyRabbitmqJanus
+  module Errors
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # Define an error primary for response
+    class JanusResponse < JanusError
+      def initialize(message)
+        super "[Response] #{message}"
+      end
+    end
+
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # Define an error for response initalize
+    class JanusResponseInit < JanusResponse
+      def initalize(message)
+        super "Error create object : #{message}"
+      end
+    end
+
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # Define an error for simple message
+    class JanusResponseSimple < JanusResponse
+      def initialize(message)
+        super "[#{message['code']}] #{message['reason']}"
+      end
+    end
+
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # Define an error for plugin
+    class JanusResponsePlugin < JanusResponse
+      def initialize(message)
+        super "[#{message['error_code']}] #{message['error']}"
+      end
+    end
+
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # Define an exception for json
+    class JanusResponseJson < JanusResponse
+      def initialize(message)
+        super "Error transform to JSON : #{message}"
+      end
+    end
+
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # Define an exception for nice_json
+    class JanusResponsePrettyJson < JanusResponse
+      def initialize(message)
+        super "Error transform to Pretty JSON : #{message}"
+      end
+    end
+
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # Define an exception for hash
+    class JanusResponseHash < JanusResponse
+      def initialize(message)
+        super "Error transform to Hash : #{message}"
+      end
+    end
+
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # Define an error for response plugin
+    class JanusResponsePluginData < JanusResponse
+      def initialize(message)
+        super "Error data response : #{message}"
+      end
+    end
+
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # Define an error for response data
+    class JanusResponseDataId < JanusResponse
+      def initalize(message)
+        super "Error Data : #{message}"
+      end
+    end
+  end
+end

data/lib/rrj/errors/janus_transaction.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RubyRabbitmqJanus
+  module Errors
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # Define errors to message sending and response to janus
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # Define an exception for initaliser transaction
+    class JanusTransaction < JanusError
+      def initialize(message)
+        super "[Transaction] Error initialize : #{message}"
+      end
+    end
+
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # Define an exception for running_handle
+    class JanusTransactionHandle
+      def initalize(message)
+        super "[Transaction] Error handle #{message}"
+      end
+    end
+
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # Define an exception for sending_message
+    class JanusTransactionPost < JanusError
+      def initialize(message)
+        super "[Transaction] Error sending message : #{message}"
+      end
+    end
+  end
+end

data/lib/rrj/errors/rabbit.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RubyRabbitmqJanus
+  module Errors
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # Define errors with Rabbitmq when request is not sending
+    class RequestNotExecuted < Errors::RRJError
+      def initialize(request)
+        super "Error in request executed : #{request}", :error
+      end
+    end
+
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # Define errors if connection to rabbitmq is failed
+    class ConnectionRabbitmqFailed < Errors::RRJError
+      def initialize(message)
+        super message, :fatal
+      end
+    end
+  end
+end

data/lib/rrj/errors/request.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RubyRabbitmqJanus
+  module Errors
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # Define errors with Rabbitmq when connection is failed
+    class RequestTemplateNotExist < Errors::RRJError
+      def initialize(request_name)
+        super "The template request (#{request_name}) does not exist", :fatal
+      end
+    end
+
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # Define errors if request folder does not exist
+    class RequestFolerDoesntExist < Errors::RRJError
+      def initialize
+        super 'The requests folder does not exist', :fatal
+      end
+    end
+  end
+end

data/lib/rrj/info.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+# @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+# Define constant to gem.
+module RubyRabbitmqJanus
+  # Define version to gem
+  VERSION = '1.0.1'
+
+  # Define a summary description to gem
+  SUMMARY = 'Ruby RabbitMQ Janus'
+
+  # Define a long description to gem
+  DESCRIPTION = 'This gem is used to communicate to a server Janus through RabbitMQ '\
+    'software (Message-oriented middleware). It waiting a messages to Rails API who ' \
+    'send to RabbitMQ server in a queue for janus server. Janus processes a message ' \
+    'and send to RabbitMQ server in a queue for gem. Once the received message is ' \
+    'decoded and returned through the Rails API.'
+
+  # Define homepage
+  HOMEPAGE = 'https://github.com/dazzl-tv/ruby-rabbitmq-janus'
+
+  # Define a post install message
+  POST_INSTALL = \
+    "# ====================================================== #\n" \
+    "# Thanks for installing!                                 #\n" \
+    "# #{HOMEPAGE}.       #\n" \
+    "# ;;;;;;;;;;;:.                                          #\n" \
+    "# ;;;;;;;;;;;;;;;;;;                                     #\n" \
+    "# ;;;;;;;;;;;:;;;;;;;;                                   #\n" \
+    "# ;;;;;;;;;;` ;;;;;;;;                                   #\n" \
+    "# ;;;;;;;;;  :;;;;;;;;.                                  #\n" \
+    "# ;;;;;;;;   :::::;;;;;                                  #\n" \
+    "# ;;;;;;,       ,;;;;;;                                  #\n" \
+    "# ;;;;;        ;;;;;;;;                                  #\n" \
+    "# ;;;;;;;;;   ;;;;;;;;,                                  #\n" \
+    "# ;;;;;;;;; `;;;;;;;;;     A    ZZZZZZZ ZZZZZZZ LL       #\n" \
+    "# ;;;;;;;;.:;;;;;;;;;;    A A      ZZZ     ZZZ  LL       #\n" \
+    "# ;;;;;;;;;;;;;;;;;      AAAAA   ZZ      ZZ     LL       #\n" \
+    "# ;;;;;;;;;;;;;,        A     A ZZZZZZZ ZZZZZZZ LLLLLLL  #\n" \
+    '# ====================================================== #'
+end

data/lib/rrj/init.rb

@@ -1,73 +1,142 @@
 # frozen_string_literal: true
 
+require 'singleton'
+require 'yaml'
+require 'json'
+require 'securerandom'
+require 'bunny'
+require 'logger'
+require 'key_path'
+require 'active_support'
+require 'concurrent'
+require 'colorize'
+
 module RubyRabbitmqJanus
   # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
-  # Initialize gem
+  # Initialize gem and create automatically an session with Janus
   # @!attribute [r] session
-  #   @return [Hash] Response to request sending in transaction
+  # :reek:BooleanParameter
   class RRJ
     attr_reader :session
 
     # Returns a new instance of RubyRabbitmqJanus
     def initialize
-      Log.instance
-      Config.instance
-      Requests.instance
+      Tools::Env.instance
+      Tools::Log.instance
+      Tools::Config.instance
+      Tools::Requests.instance
 
-      @rabbit = RabbitMQ.new
+      @session = Janus::Keepalive.new.session
 
-      @session = nil
+      @transaction = nil
+    rescue => error
+      raise Errors::RRJErrorInit, error
     end
 
-    # Send a message, to RabbitMQ, with a template JSON
-    # @return [Hash] Contains information to request sending
-    # @param template_used [String] Json used to request sending in RabbitMQ
-    # @param [Hash] opts the options sending with a request
-    # @option opts [String] :janus The message type
-    # @option opts [String] :transaction The transaction identifier
-    # @option opts [Hash] :data The option data to request
-    def message_template_ask_sync(template_used = 'info', opts = {})
-      @rabbit.ask_request_sync(template_used, opts)
+    # 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/'
+    # @param [Bollean] exclusive
+    #   Use an exclusive queue or not
+    # @exemple Sending an message info
+    #   RubyRabbitmqJanus::RRJ.new.message_simple('base::info')
+    #   #=> {"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::Message.new(type)
+      end
     end
 
-    # Send a message to RabbitMQ for reading a response
-    # @return [Hash] Contains a response to request sending
-    # @param info_request [Hash] Contains information to request sending
-    # @option info_request [String] :janus The message type
-    # @option info_request [String] :transaction The transaction identifier
-    # @option info_request [Hash] :data The option data to request
-    def message_template_response(info_request)
-      @rabbit.ask_response(info_request)
+    # Send an message simple in current session.
+    # @param [String] type
+    #   Given a type to request. JSON request writing in 'config/requests/'
+    # @param [Hash] options Options update in request
+    # @param [Bollean] exclusive
+    #   Use an exclusive queue or not
+    # @exemple Sending an message create
+    #   RubyRabbitmqJanus::RRJ.new.message_session('base::create')
+    #   #=> {"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::Message.new(type, use_current_session?(options))
+      end
+    rescue => error
+      raise Errors::RRJErrorPost, error
     end
 
-    # Manage a transaction with an plugin in janus
-    # Is create an session and attach with a plugin configured in file conf to gem, then
-    # when a treatment is complet is destroy a session
-    # @yieldparam session_attach [Hash] Use a session created
-    # @yieldreturn [Hash] Contains a result to transaction with janus server
-    def transaction_plugin
-      @session = yield attach_session
-      destroy_session
+    # Send a message simple for admin Janus
+    # @param [String] type
+    #   Given a type to request. JSON request writing in 'config/requests/'
+    # @param [Hash] options Options update in request
+    # @exemple Sending an message create
+    #   RubyRabbitmqJanus::RRJ.new.message_admin('admin::sessions')
+    #   #=> {"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::MessageAdmin.new(type, options.merge!('session_id' => @session))
+      end
     end
 
-    def message_template_ask_async(template_used = 'info', opts = {})
-      @rabbit.ask_request_async(template_used, opts)
+    # Send an message in handle session in current session.
+    # @param [String] type
+    #   Given a type to request. JSON request writing in 'config/requests/'
+    # @param [Hash] options Options update in request
+    # @param [Bollean] exclusive
+    #   Use an exclusive queue or not
+    # @exemple Sending an message create
+    #   RubyRabbitmqJanus::RRJ.new.message_session('base::create')
+    #   #=> {"janus":"server_info","name":"Janus WebRTC Gateway" ... }
+    # @return [RubyRabbitmqJanus::Janus::Response] Give an object response to janus server
+    def message_handle(type, replace = {}, add = {})
+      options = { 'replace' => replace, 'add' => add }
+      Tools::Log.instance.debug "Transaction : #{@transaction}"
+      @transaction.publish_message_handle(type, options)
     end
 
-    alias ask_async message_template_ask_async
-    alias ask_sync message_template_ask_sync
-    alias response_sync message_template_response
+    # Manage a transaction simple. Just for create element or destroy
+    # def transaction_simple(type, replace = {}, add = {})
+    #   options = { 'replace' => replace, 'add' => add }
+    #   Janus::Transaction.new(@session).handle_running_simple(type, options)
+    # end
 
-    private
+    # Define an handle and establish connection with janus
+    def start_handle(exclusive = false)
+      @transaction = Janus::TransactionHandle.new(@session)
+      @transaction.handle_connect(exclusive) { yield }
+    rescue => error
+      raise Errors::RRJErrorHandle, error
+    end
+
+    def start_handle_admin
+      @transaction = Janus::TransactionAdmin.new(@session)
+      @transaction.handle_connect { yield }
+    rescue => error
+      raise Errors::RRJErrorHandle, error
+    end
 
-    def attach_session
-      Log.instance.debug 'Create an session'
-      response_sync(ask_sync('attach', ask_sync('create')))
+    # Stop an handle existing in session running
+    def stop_handle
+      @transaction.handle_running_stop
     end
 
-    def destroy_session
-      Log.instance.debug 'Destroy an session'
-      response_sync(ask_sync('destroy', response_sync(ask_sync('detach', @session))))
+    # Start an short transaction, this queue is not exclusive
+    def handle_message_simple(type, replace = {}, add = {})
+      @transaction = Janus::TransactionHandle.new(@session)
+      @transaction.handle_connect_and_stop(false) do
+        message_handle(type, replace, add).for_plugin
+      end
+    rescue => error
+      raise Errors::RRJErrorHandle, error
+    end
+
+    private
+
+    # Return a current session if not specified
+    def use_current_session?(option)
+      { 'session_id' => @session } unless option.key?('session_id')
     end
   end
 end

data/lib/rrj/janus/admin.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+# :reek:InstanceVariableAssumption
+
+module RubyRabbitmqJanus
+  module Janus
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # Create an message for janus
+    class MessageAdmin < Message
+      # Return options to message for rabbitmq
+      def options
+        Tools::Log.instance.debug 'Options used for admin message'
+        @properties.options_admin
+      rescue => error
+        raise Errors::JanusMessagePropertie, error
+      end
+
+      private
+
+      # Transform raw request in request to janus, so replace element <string>, <number>
+      # and other with real value
+      def prepare_request(options)
+        @request = Tools::AdminReplace.new(@request, options).transform_request
+        Tools::Log.instance.debug "Prepare request admin for janus : #{to_json}"
+      end
+    end
+  end
+end

data/lib/rrj/janus/janus.rb

@@ -1,39 +1,16 @@
 # frozen_string_literal: true
 
-require 'json'
+require 'rrj/janus/keepalive'
+require 'rrj/janus/message'
+require 'rrj/janus/admin'
+require 'rrj/janus/response'
+require 'rrj/janus/transaction'
+require 'rrj/janus/transaction_session'
+require 'rrj/janus/transaction_handle'
+require 'rrj/janus/transaction_admin'
 
 module RubyRabbitmqJanus
-  # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
-  # Communication to RabbitMQ with format for Janus message
-  class Janus
-    # Returns a new instance of Janus
-    # @param connection [String] Connection to RabbitMQ server
-    # @param logs [RRJ::Log] Instance to log
-    def initialize(connection)
-      @channel = connection.create_channel
-    end
-
-    # Send a message to RabbitMQ
-    # @param request [String] Type request used by transaction
-    # @param opts [Hash] Contains the parameters used by request if necessary
-    # @return [Hash] Result to request
-    def send(request, opts)
-      message = Sync.new(opts, @channel)
-      message.send(request)
-    end
-
-    def send_async(request, opts)
-      message = ASync.new(opts, @channel)
-      message.send(request)
-    end
-
-    # Read a message to RabbitMQ
-    # @param info_message [Hash] Information request asking to janus
-    # @param connection [Object] Object contains a information to connection
-    # @return [Hash] Result to request
-    def read(info_message, connection)
-      response = ResponseJanus.new(@channel, connection, info_message)
-      response.read
-    end
+  # Module interaction with Janus
+  module Janus
   end
 end

data/lib/rrj/janus/keepalive.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RubyRabbitmqJanus
+  module Janus
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # Manage sending keepalive message
+    # :reek:TooManyInstanceVariables { max_instance_variables: 6 }
+    class Keepalive
+      # Initalize a keepalive message
+      def initialize
+        @response, @publish = nil
+        @rabbit = Rabbit::Connect.new
+        @lock = Mutex.new
+        @condition = ConditionVariable.new
+        session_live
+      end
+
+      # Return an number session created
+      def session
+        @lock.synchronize { @condition.wait(@lock) }
+        @response.session
+      end
+
+      private
+
+      # Send to regular interval a message keepalive
+      def session_live
+        Thread.new do
+          Tools::Log.instance.debug 'Create an session for keepalive'
+          initialize_thread
+        end
+      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.close
+      end
+
+      # Star an session janus
+      def session_start
+        msg_create = Janus::Message.new 'base::create'
+        @publish = Rabbit::PublishExclusive.new(@rabbit.channel, '')
+        Janus::Response.new @publish.send_a_message(msg_create)
+      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(Janus::Message.new('base::keepalive',
+                                                     'session_id' => @response.session))
+        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
+    end
+  end
+end

data/lib/rrj/janus/message.rb

@@ -1,31 +1,86 @@
 # frozen_string_literal: true
 
-require 'securerandom'
-require 'thread'
-
 module RubyRabbitmqJanus
-  # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
-  # Message Janus sending to rabbitmq server
-  class MessageJanus
-    # Initialiaze a message posting to RabbitMQ
-    # @param plugins [String] Name of plugin used by transaction
-    # @param logs [RubyRabbitmqJanus::Log] Instance log
-    # @param opts [Hash] Contains information to request sending
-    def initialize(opts_request, channel)
-      @correlation = SecureRandom.uuid
-      @options_request = opts_request
-      @channel = channel
-    end
+  module Janus
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # Create an message for janus
+    class Message
+      attr_reader :type
+
+      # Instanciate an message
+      # @param template_request [String] Name of request prepare
+      # @param [Hash] options Options to request (replace element or add in body)
+      # @option options [String] :session_id Identifier to session
+      # @option options [String] :handle_id Identifier to session manipulate
+      # @option options [Hash] :other Element contains in request sending to janus
+      # @example Initialize a message
+      #   Message.new('test', {
+      #     "session_id": 42,
+      #     "handle_id": 42,
+      #     "replace": {
+      #       "audio": false,
+      #       "video": true
+      #     },
+      #     "add": {
+      #       "subtitle": true
+      #     })
+      def initialize(template_request, options = {})
+        @request = {}
+        @type = template_request
+        @properties = Rabbit::Propertie.new
+        load_request_file
+        prepare_request(options)
+      rescue => error
+        raise Errors::JanusMessage, error
+      end
+
+      # Return request to json format
+      def to_json
+        @request.to_json
+      rescue => error
+        raise Errors::JanusMessageJson, error
+      end
+
+      # Return request to json format with nice format
+      def to_nice_json
+        JSON.pretty_generate to_hash
+      rescue => error
+        raise Errors::JanusMessagePrettyJson, error
+      end
+
+      # Return request to hash format
+      def to_hash
+        @request
+      rescue => error
+        raise Errors::JanusMessageHash, error
+      end
+
+      # Return options to message for rabbitmq
+      def options
+        @properties.options
+      rescue => error
+        raise Errors::JanusMessagePropertie, error
+      end
+
+      # Return correlation to message
+      def correlation
+        @properties.correlation
+      end
 
-    private
+      private
 
-    attr_reader :channel, :options_request, :opts, :correlation, :my_request, :message
-    attr_reader :log
+      # Load raw request
+      def load_request_file
+        @request = JSON.parse File.read Tools::Requests.instance.requests[@type]
+        Tools::Log.instance.debug "Opening request : #{to_json}"
+      end
 
-    def define_request_sending(json)
-      request = Replace.new(json, @options_request)
-      @my_request = request.to_hash
-      request.to_json
+      # Transform raw request in request to janus, so replace element <string>, <number>
+      # and other with real value
+      def prepare_request(options)
+        @request = Tools::Replace.new(@request, options).transform_request
+        Tools::Log.instance.debug "Prepare request for janus : #{to_json}"
+      end
     end
   end
 end