spacebunny 1.0.0

data/lib/spacebunny/live_stream/amqp.rb

@@ -0,0 +1,124 @@
+require 'bunny'
+
+module Spacebunny
+  module LiveStream
+    class Amqp < Base
+      DEFAULT_QUEUE_OPTIONS = { passive: true }
+      DEFAULT_EXCHANGE_OPTIONS = { passive: true }
+      ACK_TYPES = [:manual, :auto]
+
+      attr_reader :built_live_streams, :client
+
+      def initialize(*args)
+        super(:amqp, *args)
+        @built_live_streams = {}
+      end
+
+      def connect
+        # 'Fix' attributes: start from common connection configs and adjust attributes to match what Bunny
+        # wants as connection args
+        connection_params = connection_configs.dup
+        connection_params[:user] = connection_params.delete :client
+        connection_params[:password] = connection_params.delete :secret
+        connection_params[:port] = connection_params.delete(:tls_port) if connection_params[:tls]
+        connection_params[:recover_from_connection_close] = connection_params.delete :auto_recover
+        connection_params[:log_level] = connection_params.delete(:log_level) || ::Logger::ERROR
+
+        # Re-create client every time connect is called
+        @client = Bunny.new(connection_params)
+        @client.start
+      end
+
+      def channel_from_name(name)
+        # In @built_channels in fact we have exchanges
+        with_channel_check name do
+          @built_exchanges[name]
+        end
+      end
+
+      def disconnect
+        super
+        client.stop
+      end
+
+      # Subscribe for messages coming from Live Stream with name 'name'
+      # Each subscriber will receive a copy of messages flowing through the Live Stream
+      def message_from(name, options = {}, &block)
+        receive_message_from name, options, &block
+      end
+
+      # Subscribe for messages coming from cache of Live Stream with name 'name'
+      # The Live Stream will dispatch a message to the first ready subscriber in a round-robin fashion.
+      def message_from_cache(name, options = {}, &block)
+        options[:from_cache] = true
+        receive_message_from name, options, &block
+      end
+
+      private
+
+      def check_client
+        raise ClientNotConnected, 'Client not connected. Did you call client.connect?' unless client_connected?
+      end
+
+      def client_connected?
+        client && client.status.eql?(:open)
+      end
+
+      def live_stream_data_from_name(name)
+        # Find the live_stream from provided name
+        unless live_stream_data = live_streams.find { |ls| ls[:name] == name }
+          raise LiveStreamNotFound.new(name)
+        end
+        live_stream_data
+      end
+
+      def parse_ack(ack)
+        to_ack = false
+        auto_ack = false
+        if ack
+          raise AckTypeError unless ACK_TYPES.include?(ack)
+          to_ack = true
+          case ack
+            when :manual
+              auto_ack = false
+            when :auto
+              auto_ack = true
+          end
+        end
+        return to_ack, auto_ack
+      end
+
+      def receive_message_from(name, options)
+        unless block_given?
+          raise BlockRequired
+        end
+        name = name.to_s
+        blocking = options.fetch :wait, false
+        to_ack, auto_ack = parse_ack options.fetch(:ack, :manual)
+        from_cache = options.fetch :from_cache, false
+
+        check_client
+        ls_channel = client.create_channel
+        live_stream_name = "#{live_stream_data_from_name(name)[:id]}.live_stream"
+        if from_cache
+          live_stream = ls_channel.queue live_stream_name, DEFAULT_QUEUE_OPTIONS
+        else
+          ls_exchange = ls_channel.fanout live_stream_name, DEFAULT_EXCHANGE_OPTIONS
+          live_stream = ls_channel.queue("#{client}_#{Time.now.to_f}.live_stream.temp", auto_delete: true)
+                            .bind ls_exchange, routing_key: '#'
+        end
+
+        live_stream.subscribe(block: blocking, manual_ack: to_ack) do |delivery_info, metadata, payload|
+          message = LiveStream::Message.new ls_channel, options, delivery_info, metadata, payload
+
+          yield message
+
+          # If ack is :auto then ack current message
+          if to_ack && auto_ack
+            message.ack
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spacebunny/live_stream/base.rb

@@ -0,0 +1,198 @@
+require 'json'
+require 'http'
+
+module Spacebunny
+  module LiveStream
+
+    # Proxy to Base.new
+    def self.new(*args)
+      Amqp.new *args
+    end
+
+    class Base
+      attr_accessor :api_endpoint, :auto_recover, :raise_on_error, :client, :secret, :host, :vhost, :live_streams
+      attr_reader :log_to, :log_level, :logger, :custom_connection_configs, :auto_connection_configs,
+                  :connection_configs, :auto_configs, :tls, :tls_cert, :tls_key, :tls_ca_certificates, :verify_peer
+
+      def initialize(protocol, *args)
+        @protocol = protocol
+        @custom_connection_configs = {}
+        @auto_connection_configs = {}
+        options = args.extract_options.deep_symbolize_keys
+
+        @client = options[:client] || raise(ClientRequired)
+        @secret = options[:secret] || raise(SecretRequired)
+        @api_endpoint = options[:api_endpoint] || {}
+
+        extract_custom_connection_configs_from options
+        set_live_streams options[:live_streams]
+
+        @raise_on_error = options[:raise_on_error]
+        @log_to = options[:log_to] || STDOUT
+        @log_level = options[:log_level] || ::Logger::WARN
+        @logger = options[:logger] || build_logger
+      end
+
+      def api_endpoint=(options)
+        unless options.is_a? Hash
+          raise ArgumentError, 'api_endpoint must be an Hash. See doc for further info'
+        end
+        @api_endpoint = options.deep_symbolize_keys
+      end
+
+      def connection_configs
+        return @connection_configs if @connection_configs
+        if auto_configure?
+         # If key is specified, retrieve configs from APIs endpoint
+          @auto_configs = EndpointConnection.new(@api_endpoint.merge(client: @client, secret: @secret)).configs
+          check_and_add_live_streams @auto_configs[:live_streams]
+          @auto_connection_configs = normalize_auto_connection_configs
+        end
+        # Build final connection_configs
+        @connection_configs = merge_connection_configs
+        # Check for required params presence
+        check_connection_configs
+        @connection_configs
+      end
+
+      def connect
+        logger.warn "connect method must be implemented on class responsibile to handle protocol '#{@protocol}'"
+      end
+
+      def connection_options=(options)
+        unless options.is_a? Hash
+          raise ArgumentError, 'connection_options must be an Hash. See doc for further info'
+        end
+        extract_custom_connection_configs_from options.with_indifferent_access
+      end
+
+      def disconnect
+        @connection_configs = nil
+      end
+
+      # Stub method: must be implemented on the class responsible to handle the protocol
+      def on_receive(options = {})
+        logger.warn "on_receive method must be implemented on class responsibile to handle protocol '#{@protocol}'"
+      end
+
+      def auto_configure?
+        @client && @secret
+      end
+
+      def auto_recover
+        connection_configs[:auto_recover]
+      end
+
+      def host
+        connection_configs[:host]
+      end
+
+      def secret
+        connection_configs[:secret]
+      end
+
+      def vhost
+        connection_configs[:vhost]
+      end
+
+      private
+
+      # @private
+      # Check if live_streams are an array
+      def set_live_streams(live_streams)
+        if live_streams && !live_streams.is_a?(Array)
+          raise StreamsMustBeAnArray
+        end
+        check_and_add_live_streams(live_streams)
+      end
+
+      # @private
+      # Check for required params presence
+      def check_connection_configs
+        # Do nothing ATM
+      end
+
+      # @private
+      # Merge auto_connection_configs and custom_connection_configs
+      def merge_connection_configs
+        auto_connection_configs.merge(custom_connection_configs) do |key, old_val, new_val|
+          if new_val.nil?
+            old_val
+          else
+            new_val
+          end
+        end
+      end
+
+      # @private
+      def build_logger
+        logger          = ::Logger.new(@log_to)
+        logger.level    = normalize_log_level
+        logger.progname = 'Spacebunny'
+        Spacebunny.logger = logger
+      end
+
+      # @private
+      def extract_custom_connection_configs_from(options)
+        @custom_connection_configs = options
+        # Auto_recover from connection.close by default
+        @custom_connection_configs[:auto_recover] = @custom_connection_configs.delete(:auto_recover) || true
+        @custom_connection_configs[:host] = @custom_connection_configs.delete :host
+        if @custom_connection_configs[:protocols] && custom_connection_configs[:protocols][@protocol]
+          @custom_connection_configs[:port] = @custom_connection_configs[:protocols][@protocol].delete :port
+          @custom_connection_configs[:tls_port] = @custom_connection_configs[:protocols][@protocol].delete :tls_port
+        end
+        @custom_connection_configs[:vhost] = @custom_connection_configs.delete :vhost
+        @custom_connection_configs[:client] = @custom_connection_configs.delete :client
+        @custom_connection_configs[:secret] = @custom_connection_configs.delete :secret
+      end
+
+      # @private
+      def check_and_add_live_streams(chs)
+        @live_streams = [] unless @live_streams
+        return unless chs
+        chs.each do |ch|
+          case ch
+            when Hash
+              ch.symbolize_keys!
+              # Check for required attributes
+              [:id, :name].each do |attr|
+                unless ch[attr]
+                  raise LiveStreamParamError(ch[:name], attr)
+                end
+              end
+              @live_streams << ch
+            else
+              raise LiveStreamFormatError
+          end
+        end
+      end
+
+      # @private
+      # Translate from auto configs given by APIs endpoint to a common format
+      def normalize_auto_connection_configs
+        {
+            host: @auto_configs[:connection][:host],
+            port: @auto_configs[:connection][:protocols][@protocol][:port],
+            tls_port: @auto_configs[:connection][:protocols][@protocol][:tls_port],
+            vhost: @auto_configs[:connection][:vhost],
+            client: @auto_configs[:connection][:client],
+            secret: @auto_configs[:connection][:secret]
+        }
+      end
+
+      # @private
+      def normalize_log_level
+        case @log_level
+          when :debug, ::Logger::DEBUG, 'debug' then ::Logger::DEBUG
+          when :info,  ::Logger::INFO,  'info'  then ::Logger::INFO
+          when :warn,  ::Logger::WARN,  'warn'  then ::Logger::WARN
+          when :error, ::Logger::ERROR, 'error' then ::Logger::ERROR
+          when :fatal, ::Logger::FATAL, 'fatal' then ::Logger::FATAL
+          else
+            Logger::WARN
+        end
+      end
+    end
+  end
+end

data/lib/spacebunny/live_stream/message.rb

@@ -0,0 +1,38 @@
+module Spacebunny
+  module LiveStream
+    class Message
+      attr_reader  :live_stream, :sender_id, :channel_name, :delivery_info, :metadata, :payload
+
+      def initialize(live_stream, options, delivery_info, metadata, payload)
+        @live_stream = live_stream
+        @options = options
+        @delivery_info = delivery_info
+        @metadata = metadata
+        @payload = payload
+
+        set_sender_id_and_channel
+      end
+
+      def ack(options = {})
+        multiple = options.fetch :multiple, false
+        @live_stream.acknowledge @delivery_info.delivery_tag, multiple
+      end
+
+      def nack(options = {})
+        multiple = options.fetch :multiple, false
+        requeue = options.fetch :requeue, false
+        @live_stream.nack @delivery_info.delivery_tag, multiple, requeue
+      end
+
+      def from_api?
+        !@metadata[:headers].nil? && @metadata[:headers]['x-from-sb-api']
+      end
+
+      private
+
+      def set_sender_id_and_channel
+        @sender_id, @channel_name = @delivery_info[:routing_key].split('.')
+      end
+    end
+  end
+end

data/lib/spacebunny/logger.rb

@@ -0,0 +1,35 @@
+module Spacebunny
+  # Log on multiple outputs at the same time
+  #
+  # Usage example:
+  #
+  # log_file = File.open("log/debug.log", "a")
+  # Logger.new Spacebunny::Logger.new(STDOUT, log_file)
+
+  class Logger
+    def initialize(*args)
+      @streams = []
+      args.each do |a|
+        case a
+          when String
+            # This is a file path
+            puts File.open(a, 'a+').inspect
+            @streams << File.open(a, 'a+')
+          else
+            @streams << a
+        end
+      end
+    end
+
+    def write(*args)
+      @streams.each do |lo|
+        lo.write(*args)
+        lo.flush
+      end
+    end
+
+    def close
+      @streams.each(&:close)
+    end
+  end
+end

data/lib/spacebunny/utils.rb

@@ -0,0 +1,185 @@
+class Hash
+  # Returns a new hash with all keys converted using the block operation.
+  #
+  #  hash = { name: 'Rob', age: '28' }
+  #
+  #  hash.transform_keys{ |key| key.to_s.upcase }
+  #  # => {"NAME"=>"Rob", "AGE"=>"28"}
+  def transform_keys
+    return enum_for(:transform_keys) unless block_given?
+    result = self.class.new
+    each_key do |key|
+      result[yield(key)] = self[key]
+    end
+    result
+  end
+
+  # Destructively convert all keys using the block operations.
+  # Same as transform_keys but modifies +self+.
+  def transform_keys!
+    return enum_for(:transform_keys!) unless block_given?
+    keys.each do |key|
+      self[yield(key)] = delete(key)
+    end
+    self
+  end
+
+  # Returns a new hash with all keys converted to strings.
+  #
+  #   hash = { name: 'Rob', age: '28' }
+  #
+  #   hash.stringify_keys
+  #   # => {"name"=>"Rob", "age"=>"28"}
+  def stringify_keys
+    transform_keys{ |key| key.to_s }
+  end
+
+  # Destructively convert all keys to strings. Same as
+  # +stringify_keys+, but modifies +self+.
+  def stringify_keys!
+    transform_keys!{ |key| key.to_s }
+  end
+
+  # Returns a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+.
+  #
+  #   hash = { 'name' => 'Rob', 'age' => '28' }
+  #
+  #   hash.symbolize_keys
+  #   # => {:name=>"Rob", :age=>"28"}
+  def symbolize_keys
+    transform_keys{ |key| key.to_sym rescue key }
+  end
+  alias_method :to_options,  :symbolize_keys
+
+  # Destructively convert all keys to symbols, as long as they respond
+  # to +to_sym+. Same as +symbolize_keys+, but modifies +self+.
+  def symbolize_keys!
+    transform_keys!{ |key| key.to_sym rescue key }
+  end
+  alias_method :to_options!, :symbolize_keys!
+
+  # Validate all keys in a hash match <tt>*valid_keys</tt>, raising
+  # ArgumentError on a mismatch.
+  #
+  # Note that keys are treated differently than HashWithIndifferentAccess,
+  # meaning that string and symbol keys will not match.
+  #
+  #   { name: 'Rob', years: '28' }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key: :years. Valid keys are: :name, :age"
+  #   { name: 'Rob', age: '28' }.assert_valid_keys('name', 'age') # => raises "ArgumentError: Unknown key: :name. Valid keys are: 'name', 'age'"
+  #   { name: 'Rob', age: '28' }.assert_valid_keys(:name, :age)   # => passes, raises nothing
+  def assert_valid_keys(*valid_keys)
+    valid_keys.flatten!
+    each_key do |k|
+      unless valid_keys.include?(k)
+        raise ArgumentError.new("Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}")
+      end
+    end
+  end
+
+  # Returns a new hash with all keys converted by the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  #
+  #  hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #  hash.deep_transform_keys{ |key| key.to_s.upcase }
+  #  # => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}
+  def deep_transform_keys(&block)
+    _deep_transform_keys_in_object(self, &block)
+  end
+
+  # Destructively convert all keys by using the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_transform_keys!(&block)
+    _deep_transform_keys_in_object!(self, &block)
+  end
+
+  # Returns a new hash with all keys converted to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  #
+  #   hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #   hash.deep_stringify_keys
+  #   # => {"person"=>{"name"=>"Rob", "age"=>"28"}}
+  def deep_stringify_keys
+    deep_transform_keys{ |key| key.to_s }
+  end
+
+  # Destructively convert all keys to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_stringify_keys!
+    deep_transform_keys!{ |key| key.to_s }
+  end
+
+  # Returns a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+. This includes the keys from the root hash
+  # and from all nested hashes and arrays.
+  #
+  #   hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }
+  #
+  #   hash.deep_symbolize_keys
+  #   # => {:person=>{:name=>"Rob", :age=>"28"}}
+  def deep_symbolize_keys
+    deep_transform_keys{ |key| key.to_sym rescue key }
+  end
+
+  # Destructively convert all keys to symbols, as long as they respond
+  # to +to_sym+. This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_symbolize_keys!
+    deep_transform_keys!{ |key| key.to_sym rescue key }
+  end
+
+  private
+  # support methods for deep transforming nested hashes and arrays
+  def _deep_transform_keys_in_object(object, &block)
+    case object
+      when Hash
+        object.each_with_object({}) do |(key, value), result|
+          result[yield(key)] = _deep_transform_keys_in_object(value, &block)
+        end
+      when Array
+        object.map {|e| _deep_transform_keys_in_object(e, &block) }
+      else
+        object
+    end
+  end
+
+  def _deep_transform_keys_in_object!(object, &block)
+    case object
+      when Hash
+        object.keys.each do |key|
+          value = object.delete(key)
+          object[yield(key)] = _deep_transform_keys_in_object!(value, &block)
+        end
+        object
+      when Array
+        object.map! {|e| _deep_transform_keys_in_object!(e, &block)}
+      else
+        object
+    end
+  end
+end
+
+class Array
+  # Extracts options from a set of arguments. Removes and returns the last
+  # element in the array if it's a hash, otherwise returns a blank hash.
+  #
+  #   def options(*args)
+  #     args.extract_options!
+  #   end
+  #
+  #   options(1, 2)        # => {}
+  #   options(1, 2, a: :b) # => {:a=>:b}
+  def extract_options
+    if last.is_a?(Hash)
+      pop
+    else
+      {}
+    end
+  end
+end