ruby_rabbitmq_janus 0.3.0 → 1.0.1

data/lib/rrj/janus/message_async.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module RubyRabbitmqJanus
-  # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
-  # Message Janus sending to rabbitmq server
-  class ASync < MessageJanus
-    def initialize(opts_request, channel)
-      super
-      @response = nil
-      @condition = ConditionVariable.new
-      @lock = Mutex.new
-      @reply = channel.queue('', exclusive: true)
-    end
-
-    # Send a message to RabbitMQ server
-    # @param json [String] Name of request used
-    # @param channel [Bunny::Channel] Channel used in transaction
-    # @param queue_to [String] Name of queue used for sending request in RabbitMQ
-    # @return [Hash] Result to request executed
-    def send(json)
-      Log.instance.debug 'Send a message ASYNCHRONE'
-      subscribe
-      channel_publish_message(json)
-    end
-
-    private
-
-    attr_reader :lock, :response
-
-    def channel_publish_message(json)
-      message = channel.default_exchange
-      message.publish(define_request_sending(json),
-                      reply_to: @reply.name,
-                      routing_key: Config.instance.options['queues']['queue_to'],
-                      correlation_id: correlation,
-                      content_type: 'application/json')
-      @lock.synchronize { @condition.wait(lock) }
-      @response
-    end
-
-    def subscribe
-      @reply.subscribe do |_delivery_info, properties, payload|
-        parse_queue properties, payload
-      end
-    end
-
-    def parse_queue(properties, payload)
-      if properties[:correlation_id] == correlation
-        @response = JSON.parse payload
-        @lock.synchronize { @condition.signal }
-      end
-    end
-  end
-end

data/lib/rrj/janus/message_sync.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module RubyRabbitmqJanus
-  # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
-  # Message Janus sending to rabbitmq server
-  class Sync < MessageJanus
-    def initialize(opts_request, channel)
-      super
-    end
-
-    # Send a message to RabbitMQ server
-    # @param json [String] Name of request used
-    # @param channel [Bunny::Channel] Channel used in transaction
-    # @param queue_to [String] Name of queue used for sending request in RabbitMQ
-    # @return [Hash] Result to request executed
-    def send(json)
-      message = channel.default_exchange
-      Log.instance.debug 'Send a message SYNCHRONE'
-      message.publish(define_request_sending(json),
-                      routing_key: Config.instance.options['queues']['queue_to'],
-                      correlation_id: correlation,
-                      content_type: 'application/json')
-      return_info_message
-    end
-
-    private
-
-    # Prepare an Hash with information necessary to read a response in RabbitMQ queue
-    def return_info_message
-      my_request['properties'] = { 'correlation' => correlation }
-      my_request
-    end
-  end
-end

data/lib/rrj/log.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require 'logging'
-
-module RubyRabbitmqJanus
-  # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
-  # Class for wrtting logs. Define level used (:warn, :info, :debug).
-  class Log
-    include Singleton
-
-    # Define folder to writing logs
-    DEFAULT_LOG_DIR = 'log'
-
-    # Define file name to writing logs
-    DEFAULT_LOG_NAME = 'rails-rabbit-janus.log'
-
-    # Define a default level to gem (:warn, :info, :debug)
-    DEFAULT_LEVEL = :debug
-
-    attr_reader :log_file
-
-    # Returns a new instance to Log
-    def initialize
-      @logs = Logging.logger[Time.now.to_s + ' --']
-      @logs.level = DEFAULT_LEVEL
-      @log_file = DEFAULT_LOG_DIR + '/' + DEFAULT_LOG_NAME
-      @logs.add_appenders Logging.appenders.file(@log_file)
-
-      welcome = '### Start gem Rails Rabbit Janus ###'
-      @logs.info(welcome)
-    end
-
-    # Level to log
-    # @return [Integer] The level to log instance
-    def level
-      @logs.level
-    end
-
-    # Save level to log
-    # @param level [Symbol] Save log level used by this gem
-    def level=(level)
-      @logs.level = level
-    end
-
-    # Write a message in log with a warn level
-    # @param message [String] Message writing in warning level in log
-    def warn(message)
-      @logs.warn(message)
-    end
-
-    # Write a message in log with a info level
-    # @param message [String] Message writing in info level in log
-    def info(message)
-      @logs.info(message)
-    end
-
-    # Write a message in log with a debug level
-    # @param message [String] Message writing in debug level in log
-    def debug(message)
-      @logs.debug(message)
-    end
-  end
-end

data/lib/rrj/rabbitmq/rabbitmq.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require 'bunny'
-
-module RubyRabbitmqJanus
-  # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
-  # Class for connection with RabbitMQ Server
-  class RabbitMQ
-    # Return a new instance to RabbitMQ
-    def initialize
-      @connection = Bunny.new(read_options_server)
-      @janus, @response = nil
-    end
-
-    # Connect to server RabbitMQ and post a message in queue ('to-janus' by default)
-    def ask_request_sync(request_type, opts)
-      execute_request do
-        rqt = Requests.instance.requests[request_type.to_s]
-        @response = @janus.send(rqt, opts)
-        close_server_rabbitmq
-      end
-    end
-
-    def ask_request_async(request_type, opts)
-      execute_request do
-        rqt = Requests.instance.requests[request_type.to_s]
-        @response = @janus.send_async(rqt, opts)
-        close_server_rabbitmq
-      end
-    end
-
-    # Connect to server RabbitMQ and read a message in queue ('from-janus' by default)
-    def ask_response(info_request)
-      execute_request do
-        @response = @janus.read(info_request, @connection)
-      end
-    end
-
-    private
-
-    # Establish connection with RabbitMQ server
-    # @return [RRJ::Janus] Janus object for manipulating data sending and receiving to
-    #   rabbitmq server
-    def open_server_rabbitmq
-      @connection.start
-    end
-
-    # Close connection to rabbitmq server
-    def close_server_rabbitmq
-      @connection.close
-    end
-
-    # Use configuration information to connect RabbitMQ
-    # This method smells of :reek:DuplicateMethodCall
-    # This method smells of :reek:TooManyStatements
-    # This method smells of :reek:FeatureEnvy
-    def read_options_server
-      hash = {}
-      hash.merge!(define_options)
-      hash['log_level'] = Log.instance.level
-      hash['log_file'] = Log.instance.log_file
-      hash
-    end
-
-    # This method smells of :reek:UtilityFunction
-    def define_options
-      hash = {}
-      Config.instance.options.fetch('server').each do |key, server|
-        hash[key.to_sym] = server.to_s
-      end
-      hash
-    end
-
-    # Execute request
-    def execute_request
-      open_server_rabbitmq
-      @janus = Janus.new(@connection)
-      yield
-      @response
-    end
-  end
-end

data/lib/rrj/request/path.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require 'key_path'
-
-module RubyRabbitmqJanus
-  # aze
-  # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
-  class Path
-    attr_reader :path, :parent, :child, :value
-
-    def initialize(key)
-      @path = KeyPath::Path.new key
-      @parent = @path.parent.to_s
-      @child = @path.to_s.gsub(@parent + '.', '')
-    end
-
-    def path
-      @path.to_s
-    end
-  end
-end

data/lib/rrj/request/replaces.rb

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-require 'key_path'
-
-module RubyRabbitmqJanus
-  # Format message request with good data
-  # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
-  class Replace
-    def initialize(json_file, opts)
-      @request = JSON.parse(File.read(json_file))
-      @opts = opts
-      @path = nil
-    end
-
-    def to_hash
-      Hash @request
-    end
-
-    def to_json
-      replaces
-      @request.to_json
-    end
-
-    private
-
-    # Replace element in json request with information used by transaction
-    def replaces
-      create_transaction
-      return unless @opts
-      replace_standard_elements
-      replace_specific_elements if @opts.key?(:other_key) && @request.key?('body')
-    end
-
-    # Create an transaction string and replace in request field with an String format
-    def create_transaction
-      @request['transaction'] = [*('A'..'Z'), *('0'..'9')].sample(10).join
-    end
-
-    def replace_standard_elements
-      replace_element('session_id')
-      replace_plugin
-      replace_element(@opts['handle_id'] ? 'handle_id' : 'sender', 'handle_id')
-    end
-
-    def replace_specific_elements
-      if request_as_replace_specific
-        new_hash = rewrite_key_to_string(@opts[:other_key])
-        running_hash(new_hash)
-      end
-    end
-
-    # Replace a session_id field with an Integer
-    def replace_element(value, value_replace = value)
-      add_return(value_replace, value_data_or_precise(value)) \
-        if @request[value_replace]
-    end
-
-    # Format the response return
-    def value_data_or_precise(key)
-      @opts[key] || @opts['data']['id']
-    end
-
-    # Format the json used for request sending
-    def add_return(key, value)
-      @request[key] = value
-      @request.merge!(key => value)
-    end
-
-    # Replace plugin used for transaction
-    def replace_plugin
-      my_plugin = @request['plugin']
-      if my_plugin
-        number = TypeData.new(my_plugin)
-        add_return('plugin', Config.instance.options['janus']['plugins'][number.format])
-      end
-    end
-
-    # Rewrite key symbol to string
-    def rewrite_key_to_string(node)
-      Hash[
-        node.map do |key, value|
-          [key.to_s, value.is_a?(Hash) ? rewrite_key_to_string(value) : value]
-        end
-      ]
-    end
-
-    def running_hash(hash, parent = '')
-      hash.each do |key, value|
-        if value.is_a?(Hash)
-          running_hash(value, new_parent(key, parent))
-        else
-          @request[parent][key] = value
-        end
-      end
-    end
-
-    def request_as_replace_specific
-      ['<string>', '<number>'].each do |value|
-        return true if @request['body'].value?(value)
-      end
-    end
-
-    # This is method smells of :reek:UtilityFunction
-    def new_parent(key, parent)
-      "#{parent}#{'.' unless parent.empty?}#{key}"
-    end
-  end
-end

data/lib/rrj/request/requests.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module RubyRabbitmqJanus
-  # @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
-  # Load files json in config/request.
-  # This file is used for sending a request to RabbitMQ
-  # @!attribute [r] requests
-  class Requests
-    include Singleton
-
-    attr_reader :requests
-
-    # Define folder to request
-    PATH_REQUEST = 'config/requests/'
-
-    # Load all requests in folder
-    def initialize
-      @requests = {}
-      Log.instance.info "Loading all requests in : #{PATH_REQUEST}"
-      Dir[File.join(PATH_REQUEST, '*')].count do |file|
-        if File.file?(file)
-          read_file(file)
-        elsif File.directory?(file)
-          each_folder(File.basename(file))
-        end
-      end
-    end
-
-    private
-
-    # Run folder contains templates json
-    def each_folder(subfolder)
-      Dir[File.join(PATH_REQUEST + subfolder, '*')].count do |file|
-        if File.file?(file)
-          read_folder(subfolder.gsub('/', '::') + '::', file)
-        elsif File.directory?(file)
-          each_folder(subfolder + '/' + File.basename(file))
-        end
-      end
-    end
-
-    # Add template json to requests array
-    # @param file [File]
-    def read_file(file)
-      @requests[File.basename(file, '.json').to_s] = File.path(file)
-    end
-
-    # Add template json to requests array with a path
-    # @param folder [Dir]
-    # @param file [File]
-    def read_folder(folder, file)
-      @requests[folder + File.basename(file, '.json').to_s] = File.path(file)
-    end
-  end
-end

data/lib/rrj/request/type_data.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module RubyRabbitmqJanus
-  # Format data with type corresponding
-  class TypeData
-    def initialize(type, value = nil)
-      @type = type
-      @value = value
-    end
-
-    # Cast a string
-    def format
-      case @type
-      when '<number>'
-        @value.to_i
-      when '<string>'
-        @value.to_s
-      when /^(?<plugin\[[0-9]\]>)/
-        extract_plugin_number
-      end
-    end
-
-    private
-
-    # Extract the number of plugin to used for this request
-    def extract_plugin_number
-      @type.delete('<plugin[').delete(']').to_i
-    end
-  end
-end

data/lib/rrj/version.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-# @author VAILLANT Jeremy <jeremy.vaillant@dazzl.tv>
-# Define constant to gem.
-module RubyRabbitmqJanus
-  # Define version to gem
-  VERSION = '0.3.0'
-
-  # 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.'
-end