spacebunny 1.0.0

data/lib/spacebunny/device/base.rb

@@ -0,0 +1,229 @@
+require 'json'
+require 'http'
+
+module Spacebunny
+  module Device
+
+    # Proxy to Base.new
+    def self.new(*args)
+      Amqp.new *args
+    end
+
+    class Base
+      attr_accessor :key, :api_endpoint, :auto_recover, :raise_on_error, :id, :name, :host, :secret, :vhost, :channels
+      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
+        key = args.first
+
+        @key = key || options[:key]
+        @api_endpoint = options[:api_endpoint] || {}
+
+        extract_custom_connection_configs_from options
+        set_channels options[:channels]
+
+        @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(key: @key)).configs
+          normalize_and_add_channels @auto_configs[:channels]
+          @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 publish(channel, message, options = {})
+        logger.warn "publish method must be implemented on class responsibile to handle protocol '#{@protocol}'"
+      end
+
+      # Stub method: must be implemented on the class responsible to handle the protocol
+      def on_receive(options = {}, &block)
+        logger.warn "on_receive method must be implemented on class responsibile to handle protocol '#{@protocol}'"
+      end
+
+      def auto_recover
+        connection_configs[:auto_recover]
+      end
+
+      def id
+        connection_configs[:device_id]
+      end
+
+      def name
+        connection_configs[:device_name]
+      end
+
+      def host
+        connection_configs[:host]
+      end
+
+      def secret
+        connection_configs[:secret]
+      end
+
+      def vhost
+        connection_configs[:vhost]
+      end
+
+      protected
+
+      # @protected
+      def auto_configure?
+        !@key.nil?
+      end
+
+      def with_channel_check(name)
+        unless res = channels.include?(name)
+          logger.warn <<-MSG
+
+            You're going to publish on channel '#{name}', but it does not appear a configured channel.
+            If using auto-configuration (device-key) associate the channel to device '#{@auto_configs[:connection][:name]}'
+            from web interface.
+            If providing manual configuration, please specify channels list through the :channels option
+            or through given setter, e.g. client.channels = [:first_channel, :second_channel, ... ])
+
+          MSG
+        end
+        if block_given?
+          yield
+        else
+          res
+        end
+      end
+
+      private
+
+      # @private
+      # Check if channels are an array
+      def set_channels(channels)
+        if channels && !channels.is_a?(Array)
+          raise ChannelsMustBeAnArray
+        end
+        normalize_and_add_channels(channels)
+      end
+
+      # @private
+      # Check for required params presence
+      def check_connection_configs
+        raise DeviceIdMissing unless @connection_configs[:device_id]
+      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
+      # Copy options to custom_connection_configs and normalize some of the attributes overwriting it
+      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[:device_id] = @custom_connection_configs.delete :device_id
+        @custom_connection_configs[:device_name] = @custom_connection_configs.delete :device_name
+        @custom_connection_configs[:secret] = @custom_connection_configs.delete :secret
+      end
+
+      # @private
+      def normalize_and_add_channels(chs)
+        @channels = [] unless @channels
+        return unless chs
+        chs.each do |ch|
+          case ch
+            when Hash
+              @channels << ch[:name].to_sym
+            else
+              ch.to_sym
+          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],
+            device_id: @auto_configs[:connection][:device_id],
+            device_name: @auto_configs[:connection][:device_name],
+            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/device/message.rb

@@ -0,0 +1,56 @@
+module Spacebunny
+  module Device
+    class Message
+      attr_reader  :device, :sender_id, :channel_name, :delivery_info, :metadata, :payload
+
+      def initialize(device, options, delivery_info, metadata, payload)
+        @device = device
+        @options = options
+        @delivery_info = delivery_info
+        @metadata = metadata
+        @payload = payload
+
+        extract_options
+        set_sender_id_and_channel
+      end
+
+      def ack(options = {})
+        multiple = options.fetch :multiple, false
+        @device.input_channel.acknowledge @delivery_info.delivery_tag, multiple
+      end
+
+      def nack(options = {})
+        multiple = options.fetch :multiple, false
+        requeue = options.fetch :requeue, false
+        @device.input_channel.nack @delivery_info.delivery_tag, multiple, requeue
+      end
+
+      def blacklisted?
+        # Discard packet if it has been sent from me
+        if @discard_mine && @device.id.eql?(@sender_id) && !from_api?
+          return true
+        end
+        # Discard packet if has been published from APIs
+        if @discard_from_api && from_api?
+          return true
+        end
+        false
+      end
+
+      def from_api?
+        !@metadata[:headers].nil? && @metadata[:headers]['x-from-sb-api']
+      end
+
+      private
+
+      def extract_options
+        @discard_mine = @options.fetch :discard_mine, false
+        @discard_from_api = @options.fetch :discard_from_api, false
+      end
+
+      def set_sender_id_and_channel
+        @sender_id, @channel_name = @delivery_info[:routing_key].split('.')
+      end
+    end
+  end
+end

data/lib/spacebunny/endpoint_connection.rb

@@ -0,0 +1,128 @@
+require 'uri/http'
+require 'uri/https'
+
+# Handle retrieve of Device and LiveStream configs from APIs endpoint
+
+module Spacebunny
+  class EndpointConnection
+    DEFAULT_OPTIONS = {
+        scheme: 'https',
+        host: 'api.spacebunny.io',
+        port: 443,
+        api_version: '/v1',
+        configs_path: {
+            device: '/device_configurations',
+            live_stream: '/live_stream_key_configurations'
+        }
+    }.freeze
+
+    attr_accessor :scheme, :host, :port, :api_version, :configs_path
+
+    def initialize(options = {})
+      unless options.is_a? Hash
+        fail ArgumentError, 'connection options must be an Hash'
+      end
+      options = merge_with_default options
+      @key = options[:key]
+      @client = options[:client]
+      @secret = options[:secret]
+
+      ensure_credentials_have_been_provided
+      # API endpoint params
+      @scheme = options[:scheme]
+      @host = options[:host]
+      @port = options[:port]
+      @api_version = options[:api_version]
+      @configs_path = options[:configs_path]
+    end
+
+    def configs
+      unless @configs
+        @configs = fetch
+      end
+      @configs
+    end
+
+    def configs_path
+      if @configs_path.is_a? Hash
+        if device?
+          @configs_path[:device]
+        else
+          @configs_path[:live_stream]
+        end
+      else
+        @configs_path
+      end
+    end
+
+    # Contact APIs endpoint to retrieve configs
+    def fetch
+      uri_builder = case scheme
+                      when 'http'
+                        URI::HTTP
+                      when 'https'
+                        URI::HTTPS
+                    end
+
+      unless uri = uri_builder.build(host: host, port: port, path: "#{api_version}#{configs_path}")
+        raise SchemeNotValid.new(scheme)
+      end
+
+      response = contact_endpoint_with uri
+      content = JSON.parse(response, symbolize_names: true) rescue nil
+      status = response.status
+      if status != 200
+        if content
+          phrase = "Auto-configuration failed:  #{response.status} => #{content[:error]}"
+          if status == 401
+            if device?
+              phrase = "#{phrase}. Is Device Key correct?"
+            else
+              phrase = "#{phrase} Are Client and Secret correct?"
+            end
+          end
+        else
+          phrase = "#{response.status}"
+        end
+        raise EndpointError, phrase
+      end
+      content
+    end
+
+    private
+
+    def ensure_credentials_have_been_provided
+      if !@key && !(@client && @secret)
+        raise DeviceKeyOrClientAndSecretRequired
+      end
+    end
+
+    def device?
+      !@key.nil?
+    end
+
+    def contact_endpoint_with(uri)
+      if device?
+        request = HTTP.headers('Device-Key' => @key)
+      else
+        request = HTTP.headers('Live-Stream-Key-Client' => @client, 'Live-Stream-Key-Secret' => @secret)
+      end
+      request = request.headers(content_type: 'application/json', accept: 'application/json')
+      begin
+        request.get(uri.to_s)
+      rescue => e
+        logger.error e.message
+        logger.error e.backtrace.join "\n"
+        raise EndPointNotReachable
+      end
+    end
+
+    def logger
+      Spacebunny.logger
+    end
+
+    def merge_with_default(options)
+      DEFAULT_OPTIONS.merge(options) { |key, old_val, new_val| new_val.nil? ? old_val : new_val }
+    end
+  end
+end

data/lib/spacebunny/exceptions.rb

@@ -0,0 +1,143 @@
+module Spacebunny
+  class DeviceKeyOrClientAndSecretRequired < Exception
+    def initialize(message = nil)
+      message = message || "A valid 'Api Key' or valid 'Client' and 'Secret' are required for auto-configuration"
+      super(message)
+    end
+  end
+
+  class DeviceKeyOrConfigurationsRequired < Exception
+    def initialize(message = nil)
+      message = message || 'Neither key or connection options provided!'
+      super(message)
+    end
+  end
+
+  class AckTypeError < Exception
+    def initialize(message = nil)
+      message = message || "Ack type not valid. Use one of #{Spacebunny::AmqpClient::ACK_TYPES.map{ |t| ":#{t}" }.join(', ')}"
+      super(message)
+    end
+  end
+
+  class BlockRequired < Exception
+    def initialize(message = nil)
+      message = message || 'block missing. Please provide a block'
+      super(message)
+    end
+  end
+
+  class ChannelsMustBeAnArray < Exception
+    def initialize
+      message = "channels option must be an Array. E.g. [:data, :alarms]"
+      super(message)
+    end
+  end
+
+  class ChannelNotExists < Exception
+    def initialize(channel = nil)
+      message = if channel
+                  "Channel '#{channel}' does not exists. Is this channel enabled for the device or did you specified it on client initialization?"
+                else
+                  'Channel does not exists'
+                end
+      super(message)
+    end
+  end
+
+  class ClientRequired < Exception
+    def initialize(message = nil)
+      message = message || "Missing mandatory 'client'. Spacebunny::LiveStream.new(:client => 'a_valid_client', :secret: 'a_valid_secret')"
+      super(message)
+    end
+  end
+
+  class LiveStreamFormatError < Exception
+    def initialize
+      message = "Live Stream not correctly formatted. It must be an Hash with at least 'name' and 'id' attributes"
+      super(message)
+    end
+  end
+
+  class LiveStreamNotFound < Exception
+    def initialize(name = nil)
+      message = if name
+                  "Live Stream '#{name}' not found. Did you created and configured it?"
+                else
+                  'Live Stream not found'
+                end
+      super(message)
+    end
+  end
+
+  class LiveStreamParamError < Exception
+    def initialize(live_stream_name, param_name)
+      live_stream_name = live_stream_name || 'no-name-provided'
+      "Live Stream '#{live_stream_name}' misses mandatory '#{param_name}' param"
+      super(message)
+    end
+  end
+
+  class SecretRequired < Exception
+    def initialize(message = nil)
+      message = message || "Missing mandatory 'secret' Spacebunny::LiveStream.new(:client => 'a_valid_client', :secret: 'a_valid_secret')"
+      super(message)
+    end
+  end
+
+  class ClientNotConnected < Exception
+    def initialize(message = nil)
+      message = message || 'Client not connected! Check internet connection'
+      super(message)
+    end
+  end
+
+  class ClientNotSetup < Exception
+    def initialize(message = nil)
+      message = message || "'Client not setup. Did you call 'connect'?'"
+      super(message)
+    end
+  end
+
+  class DeviceIdMissing < Exception
+    def initialize(message = nil)
+      message = message || "missing mandatory 'device_id' parameter. Please provide it on client initialization (see doc) or use auto-configuration"
+      super(message)
+    end
+  end
+
+  class EndpointError < Exception
+    def initialize(message = nil)
+      message = message || 'Error while contacting endpoint for auto-configuration'
+      super(message)
+    end
+  end
+
+  class EndPointNotReachable < Exception
+    def initialize(message = nil)
+      message = message || 'Endpoint not reachable'
+      super(message)
+    end
+  end
+
+  class ProtocolNotRegistered < Exception
+    def initialize(protocol)
+      message = "protocol #{protocol} is not registered"
+      super(message)
+    end
+  end
+
+  class SchemeNotValid < Exception
+    def initialize(scheme)
+      message = "Provided scheme #{scheme} is not valid"
+      super(message)
+    end
+  end
+
+  class StreamsMustBeAnArray < Exception
+    def initialize
+      message = "streams option must be an Array"
+      super(message)
+    end
+  end
+end