ruby_rabbitmq_janus 0.3.0 → 1.0.1

data/lib/rrj/janus/response.rb

@@ -1,55 +1,93 @@
 # frozen_string_literal: true
 
-require 'json'
-
 module RubyRabbitmqJanus
-  # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
-  # Response Janus received to RabbitMQ server
-  class ResponseJanus
-    # Initialiaze a response reading in RabbitMQ queue
-    def initialize(channel, connection, opts = {})
-      @channel = channel
-      @connection = connection
-      @opts = opts
-      @response = nil
-    end
+  module Janus
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # Read and decryt a response to janus
+    class Response
+      # Instanciate a response
+      def initialize(response_janus)
+        @request = response_janus
+      rescue => error
+        Tools::Log.instance.debug "Request error : #{@request}"
+        raise Errors::JanusResponseInit, error
+      else
+        Tools::Log.instance.debug "Response return : #{to_json}"
+      end
 
-    # Read a response to janus (in RabbitMQ queue)
-    # @return [Hash] resultat to request
-    def read
-      Log.instance.debug 'Read a response'
-      the_queue = @channel.queue(Config.instance.options['queues']['queue_from'])
-      the_queue.subscribe(block: true) do |info, prop, pay|
-        listen(info, prop, pay)
+      # Return request to json format
+      def to_json
+        analysis
+        @request.to_json
+      rescue => error
+        Tools::Log.instance.debug "Request error : #{@request}"
+        raise Errors::JanusResponseJson, error
+      end
+
+      # Return request to json format with nice format
+      def to_nice_json
+        JSON.pretty_generate to_hash
+      rescue => error
+        Tools::Log.instance.debug "Request error : #{@request}"
+        raise Errors::JanusResponsePrettyJson, error
       end
-      return_response_json
-    end
 
-    private
+      # Return request to hash format
+      def to_hash
+        analysis
+        @request
+      rescue => error
+        Tools::Log.instance.debug "Request error : #{@request}"
+        raise Errors::JanusResponseHash, error
+      end
 
-    # Listen a response to queue
-    def listen(_delivery_info, properties, payload)
-      if @opts['properties']['correlation'] == properties[:correlation_id]
-        @response = payload
-        @connection.close
+      # Return a response simple for client
+      def for_plugin
+        case @request['janus']
+        when 'success' then @request['plugindata']['data']
+        when 'ack' then {}
+        end
+      rescue => error
+        Tools::Log.instance.debug "Request error : #{@request}"
+        raise Errors::JanusResponsePluginData, error
       end
-    end
 
-    # Format the response returning
-    def return_response_json
-      @response = JSON.parse(@response)
-      case @opts['janus']
-      when 'create'
-        merge('session_id')
-      when 'attach'
-        merge('handle_id')
+      # Return a integer to session
+      def session
+        data_id
       end
-      @response
-    end
 
-    # Update value to element in Hash
-    def merge(key)
-      @response[key] = @response['data']['id']
+      # Return a integer to handle
+      def sender
+        data_id
+      end
+
+      private
+
+      # Read a hash and return an identifier
+      def data_id
+        analysis
+        @request['data']['id'].to_i
+      rescue => error
+        raise Errors::JanusResponseDataId, error
+      end
+
+      # Analysis response and send exception if janus return an error
+      # :reek:DuplicateMethodCall
+      def analysis
+        raise Errors::JanusResponseSimple, @request['error'] if error_simple?
+        raise Errors::JanusResponsePlugin, @request['plugindata']['data'] if error_plugin?
+      end
+
+      # Test if message response contains an simple error
+      def error_simple?
+        @request['janus'].equal? 'error'
+      end
+
+      # Test if message response contains an error in plugin
+      def error_plugin?
+        @request.key?('plugindata') && @request['plugindata']['data'].key?('error_code')
+      end
     end
   end
 end

data/lib/rrj/janus/transaction.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+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
+
+      # 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
+
+      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
+                     Rabbit::PublishNonExclusive.new(chan)
+                   else
+                     Rabbit::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/janus/transaction_admin.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+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 }
+        end
+      end
+
+      def handle_connect
+        rabbit.transaction_long do
+          choose_queue
+          create_handle
+          yield
+        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
+
+      # 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::PublishAdmin.new(rabbit.channel)
+      end
+    end
+  end
+end

data/lib/rrj/janus/transaction_handle.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+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
+        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
+        end
+      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))
+      end
+    end
+  end
+end

data/lib/rrj/janus/transaction_session.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+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 }
+        end
+      end
+    end
+  end
+end

data/lib/rrj/rabbit/connect.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RubyRabbitmqJanus
+  module Rabbit
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # Class for manage connection with rabbitmq
+    class Connect
+      # Initialize connection to server RabbitMQ
+      def initialize
+        Tools::Log.instance.debug 'Initialize connection with RabbitMQ'
+        @rabbit = Bunny.new(read_options_server)
+      end
+
+      # Create an transaction with rabbitmq and close after response is received
+      def transaction_short
+        response = transaction_long { yield }
+        close
+        response
+      end
+
+      # Create an transaction with rabbitmq and not close
+      def transaction_long
+        start
+        yield
+      end
+
+      # Openning a connection with Rabbitmq
+      def start
+        Tools::Log.instance.debug 'Connection to rabbitmq START'
+        @rabbit.start
+      rescue => message
+        raise Errors::ConnectionRabbitmqFailed, message
+      end
+
+      # Close connection to server RabbitMQ
+      def close
+        Tools::Log.instance.debug 'Connection to rabbitmq STOP'
+        @rabbit.close
+      rescue
+        raise Bunny::ConnectionClosedError
+      end
+
+      # Create an channel
+      def channel
+        Tools::Log.instance.debug 'Create an channel'
+        @rabbit.create_channel
+      end
+
+      private
+
+      # Read option for bunny instance (connection with rabbitmq)
+      # :reek:FeatureEnvy
+      def read_options_server
+        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))
+        end
+        opts.merge!(option_log_rabbit)
+      end
+
+      # Define option logs for bunny
+      def option_log_rabbit
+        if Tools::Log.instance.level.zero?
+          {
+            log_level: Tools::Log.instance.level,
+            log_file: Tools::Log.instance.logdev
+          }
+        else
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/rrj/rabbit/propertie.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubyRabbitmqJanus
+  module Rabbit
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # Manage properties to message sending in rabbitmq queue
+    class Propertie
+      attr_reader :correlation
+
+      # Initialize a message sending to rabbitmq
+      def initialize
+        Tools::Log.instance.debug 'initalize a propertie to message'
+        @correlation = SecureRandom.uuid
+      end
+
+      # Define options sending to rabbitmq
+      def options
+        Tools::Log.instance.debug 'Add options to propertie to message'
+        {
+          routing_key: Tools::Config.instance.options['queues']['queue_to'],
+          correlation_id: @correlation,
+          content_type: 'application/json'
+        }
+      end
+
+      # Define option sending to rabbitmq for janus admin message
+      def options_admin
+        Tools::Log.instance.debug 'Add options to propertie to message'
+        {
+          routing_key: Tools::Config.instance.options['queues']['admin']['queue_to'],
+          correlation_id: @correlation,
+          content_type: 'application/json'
+        }
+      end
+    end
+  end
+end

data/lib/rrj/rabbit/publish.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+# :reek:FeatureEnvy and :reek:InstanceVariableAssumption
+module RubyRabbitmqJanus
+  module Rabbit
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # @abstract Publish message in RabbitMQ
+    class Publish
+      # Define Exchange operation
+      def initialize(exchange)
+        Tools::Log.instance.debug 'Create/Connect to queue'
+        @exchange = exchange.default_exchange
+        @message = nil
+      end
+
+      # Send a message in queue
+      def send_a_message(request)
+        Tools::Log.instance.info "Send request type : #{request.type}"
+        @message = request
+        @exchange.publish(@message.to_json, request.options)
+      end
+    end
+
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # @abstract Publish an message in RabbitMQ and waiting a response
+    class PublishReply < Publish
+      # Initialize a queue
+      def initialize(exchange)
+        @condition = ConditionVariable.new
+        @lock = Mutex.new
+        @response = nil
+        subscribe_to_queue
+        super
+      end
+
+      # Publish an message in rabbitmq
+      def send_a_message(request)
+        Tools::Log.instance.info "Send request type : #{request.type}"
+        @exchange.publish(read_message(request),
+                          request.options.merge!(reply_to: @reply.name))
+        @lock.synchronize { @condition.wait(@lock) }
+        @response
+      end
+
+      private
+
+      # Read message and return to JSON format
+      def read_message(request)
+        @message = request
+        @message.to_json
+      end
+
+      # Subscribe to queue in Rabbitmq
+      def subscribe_to_queue
+        @reply.subscribe do |_delivery_info, properties, payload|
+          if @message.correlation.eql?(properties.correlation_id)
+            @response = JSON.parse payload
+            @lock.synchronize { @condition.signal }
+          end
+        end
+      end
+    end
+
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # Publish message in non exclusive queue
+    class PublishNonExclusive < PublishReply
+      # Initialize an queue non exclusive
+      def initialize(exchange)
+        @reply = exchange.queue(Tools::Config.instance.options['queues']['queue_from'])
+        super(exchange)
+      end
+    end
+
+    # Publish for admin Janus
+    class PublishAdmin < PublishReply
+      # Initialize an queue non exclusive
+      def initialize(exchange)
+        name = Tools::Config.instance.options['queues']['admin']['queue_from']
+        @reply = exchange.queue(name)
+        super(exchange)
+      end
+    end
+
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # Publish message in exclusive queue
+    class PublishExclusive < PublishReply
+      # Initialize an queue exclusive
+      def initialize(exchange, name_queue = '')
+        @reply = exchange.queue(name_queue, exclusive: true)
+        super(exchange)
+      end
+
+      # Name to queue
+      # @return [String] Name to queue used
+      def queue_name
+        @reply.name
+      end
+    end
+  end
+end

data/lib/rrj/rabbit/rabbit.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'rrj/rabbit/connect'
+require 'rrj/rabbit/publish'
+require 'rrj/rabbit/propertie'
+
+module RubyRabbitmqJanus
+  # Module rabbit interaction
+  module Rabbit
+  end
+end

data/lib/rrj/tools/config.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RubyRabbitmqJanus
+  module Tools
+    # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
+    # Loading a yaml file for apply a configuration to gem.
+    class Config
+      include Singleton
+
+      attr_reader :options
+
+      # Define a default path to file configuration
+      DEFAULT_PATH = File.realpath(File.join(File.dirname(__FILE__), '..', '..'))
+
+      # Define a default name to file configuration
+      DEFAULT_CONF = 'config/default.yml'
+
+      # Define a default override file configuration
+      CUSTOMIZE_CONF = 'config/ruby-rabbitmq-janus.yml'
+
+      # Initialize configuration file default or customize if exist
+      def initialize
+        @options = nil
+        conf_customize
+        conf_default
+        define_log_level_used
+      end
+
+      private
+
+      # Load configuration file yaml
+      # @return [Yaml] Configuration file
+      # @param file [String] Path to configuration file (with name)
+      # :reek:UtilityFunction { public_methods_only: true }
+      def load_configuration(file)
+        Tools::Log.instance.info("Loading configuration file : #{file}")
+        YAML.load(File.read(file))
+      rescue
+        raise Errors::ConfigFileNotFound, file
+      end
+
+      # Load customize configuration file if exist
+      def conf_customize
+        file = File.join(Dir.pwd, CUSTOMIZE_CONF)
+        @options = load_configuration(file) if File.exist?(file)
+      end
+
+      # Load default configuration if customize configuration doesn't exist
+      def conf_default
+        file = File.join(DEFAULT_PATH, DEFAULT_CONF)
+        @options ||= load_configuration(file)
+      end
+
+      # Define log lvel used in this gem
+      def define_log_level_used
+        Tools::Log.instance.level = \
+          Tools::Log::LEVELS[@options['gem']['log']['level'].to_sym]
+      rescue
+        raise Errors::LevelNotDefine
+      end
+    end
+  end
+end

data/lib/rrj/tools/env.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RubyRabbitmqJanus
+  # Contains all tools necessary in this gem
+  module Tools
+    # Class for tools used in gem
+    # :reek:UtilityFunction
+    class Env
+      include Singleton
+
+      def test_env_var(configuration, key)
+        test = configuration[key.to_s]
+        if test.is_a?(String)
+          test.include?('ENV') ? ENV[test.gsub("ENV['", '').gsub("']", '')] : test
+        else
+          test
+        end
+      end
+    end
+  end
+end