ably-pubsub-core 0.0.1.pre

data/lib/ably/rest/middleware/encoder.rb

@@ -0,0 +1,49 @@
+require 'faraday'
+require 'json'
+
+module Ably
+  module Rest
+    module Middleware
+      # Encode the body of the message according to the mime type
+      class Encoder < Faraday::Middleware
+        CONTENT_TYPE = 'Content-Type'.freeze unless defined? CONTENT_TYPE
+
+        def call(env)
+          encode env if env.body
+          @app.call env
+        end
+
+        private
+        def encode(env)
+          env.body = case request_type(env)
+          when 'application/x-msgpack'
+            to_msgpack(env.body)
+          when 'application/json', '', nil
+            env.request_headers[CONTENT_TYPE] = 'application/json'
+            to_json(env.body)
+          else
+            env.body
+          end
+        end
+
+        def to_msgpack(body)
+          body.to_msgpack
+        end
+
+        def to_json(body)
+          if body.kind_of?(String)
+            body
+          else
+            body.to_json
+          end
+        end
+
+        def request_type(env)
+          type = env.request_headers[CONTENT_TYPE].to_s
+          type = type.split(';', 2).first if type.index(';')
+          type
+        end
+      end
+    end
+  end
+end

data/lib/ably/rest/middleware/exceptions.rb

@@ -0,0 +1,53 @@
+require 'faraday'
+require 'json'
+
+module Ably
+  module Rest
+    module Middleware
+      # HTTP exceptions raised by Ably due to an error status code
+      # Ably returns JSON/Msgpack error codes and messages so include this if possible in the exception messages
+      class Exceptions < Faraday::Middleware
+        def on_complete(env)
+          if env.status >= 400
+            error_status_code = env.status
+            error_code = nil
+
+            if env.body.kind_of?(Hash)
+              error = env.body.fetch('error', {})
+              error_status_code = error['statusCode'].to_i if error['statusCode']
+              error_code = error['code'].to_i if error['code']
+
+              if error
+                message = "#{error['message']} (status: #{error_status_code}, code: #{error_code})"
+              else
+                message = env.body
+              end
+            else
+              message = env.body
+            end
+
+            message = 'Unknown server error' if message.to_s.strip == ''
+            request_id = env.request.context[:request_id] if env.request.context
+            exception_args = [message, error_status_code, error_code, nil, { request_id: request_id }]
+
+            if env.status >= 500
+              raise Ably::Exceptions::ServerError.new(*exception_args)
+            elsif env.status == 401
+              if Ably::Exceptions::TOKEN_EXPIRED_CODE.include?(error_code)
+                raise Ably::Exceptions::TokenExpired.new(*exception_args)
+              else
+                raise Ably::Exceptions::UnauthorizedRequest.new(*exception_args)
+              end
+            elsif env.status == 403
+              raise Ably::Exceptions::ForbiddenRequest.new(*exception_args)
+            elsif env.status == 404
+              raise Ably::Exceptions::ResourceMissing.new(*exception_args)
+            else
+              raise Ably::Exceptions::InvalidRequest.new(*exception_args)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ably/rest/middleware/external_exceptions.rb

@@ -0,0 +1,24 @@
+require 'faraday'
+
+module Ably
+  module Rest
+    module Middleware
+      # HTTP exceptions raised due to a status code error on a 3rd party site
+      # Used by auth calls
+      class ExternalExceptions < Faraday::Middleware
+        def on_complete(env)
+          if env.status >= 400
+            error_status_code = env.status
+            message = "Error #{error_status_code}: #{(env.body || '')[0...200]}"
+
+            if error_status_code >= 500
+              raise Ably::Exceptions::ServerError, message
+            else
+              raise Ably::Exceptions::InvalidRequest, message
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ably/rest/middleware/fail_if_unsupported_mime_type.rb

@@ -0,0 +1,22 @@
+require 'faraday'
+require 'json'
+
+module Ably
+  module Rest
+    module Middleware
+      class FailIfUnsupportedMimeType < Faraday::Middleware
+        def on_complete(env)
+          unless env.response_headers['Ably-Middleware-Parsed'] == true
+            # Ignore empty body with success status code for no body response
+            return if env.body.to_s.empty? && env.status == 204
+
+            unless (500..599).include?(env.status)
+              raise Ably::Exceptions::InvalidResponseBody,
+                    "Content Type #{env.response_headers['Content-Type']} is not supported by this client library"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ably/rest/middleware/logger.rb

@@ -0,0 +1,58 @@
+require 'faraday'
+
+module Ably
+  module Rest
+    module Middleware
+      class Logger < Faraday::Middleware
+        extend Forwardable
+
+        def initialize(app, logger = nil)
+          super(app)
+          @logger = logger || begin
+            require 'logger'
+            ::Logger.new(STDOUT)
+          end
+        end
+
+        def_delegators :@logger, :debug, :info, :warn, :error, :fatal
+
+        def call(env)
+          debug { "=> URL: #{env.method} #{env.url}, Headers: #{dump_headers env.request_headers}" }
+          debug { "=> Body: #{body_for(env)}" }
+          super
+        end
+
+        def on_complete(env)
+          debug "<= Status: #{env.status}, Headers: #{dump_headers env.response_headers}"
+          debug "<= Body: #{body_for(env)}"
+        end
+
+        private
+        def dump_headers(headers)
+          headers.map { |k, v| "#{k}: #{v.inspect}" }.join(", ")
+        end
+
+        def body_for(env)
+          return '' if !env.body || env.body.empty?
+
+          if env.request_headers['Content-Type'] == 'application/x-msgpack'
+            MessagePack.unpack(env.body)
+          else
+            env.body
+          end
+
+        rescue StandardError
+          readable_body(env.body)
+        end
+
+        def readable_body(body)
+          if body.respond_to?(:encoding) && body.encoding == Encoding::ASCII_8BIT
+            body.unpack('H*')
+          else
+            body
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ably/rest/middleware/parse_json.rb

@@ -0,0 +1,27 @@
+require 'faraday'
+require 'json'
+
+module Ably
+  module Rest
+    module Middleware
+      class ParseJson < Faraday::Middleware
+        def on_complete(env)
+          if env.response_headers['Content-Type'] == 'application/json'
+            env.body = parse(env.body) unless env.response_headers['Ably-Middleware-Parsed'] == true
+            env.response_headers['Ably-Middleware-Parsed'] = true
+          end
+        end
+
+        def parse(body)
+          if body.length > 0
+            JSON.parse(body)
+          else
+            body
+          end
+        rescue JSON::ParserError => e
+          raise Ably::Exceptions::InvalidResponseBody, "Expected JSON response: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/ably/rest/middleware/parse_message_pack.rb

@@ -0,0 +1,43 @@
+require 'faraday'
+require 'msgpack'
+
+module Ably
+  module Rest
+    module Middleware
+      class ParseMessagePack < Faraday::Middleware
+        def on_complete(env)
+          if env.response_headers['Content-Type'] == 'application/x-msgpack'
+            env.body = parse(env.body) unless env.response_headers['Ably-Middleware-Parsed'] == true
+            env.response_headers['Ably-Middleware-Parsed'] = true
+          end
+        rescue Ably::Exceptions::InvalidResponseBody => e
+          debug_info = {
+            method: env.method,
+            url: env.url,
+            base64_body: base64_body(env.body),
+            response_headers: env.response_headers
+          }
+          raise Ably::Exceptions::InvalidResponseBody, "#{e.message}\nRequest env: #{debug_info}"
+        end
+
+        def parse(body)
+          if body.length > 0
+            MessagePack.unpack(body)
+          else
+            body
+          end
+        rescue MessagePack::UnknownExtTypeError => e
+          raise Ably::Exceptions::InvalidResponseBody, "MessagePack::UnknownExtTypeError body could not be decoded: #{e.message}. Got Base64:\n#{base64_body(body)}"
+        rescue MessagePack::MalformedFormatError => e
+          raise Ably::Exceptions::InvalidResponseBody, "MessagePack::MalformedFormatError body could not be decoded: #{e.message}. Got Base64:\n#{base64_body(body)}"
+        end
+
+        def base64_body(body)
+          Base64.encode64(body)
+        rescue => err
+          "[#{err.message}! Could not base64 encode body: '#{body}']"
+        end
+      end
+    end
+  end
+end

data/lib/ably/rest/presence.rb

@@ -0,0 +1,113 @@
+module Ably
+  module Rest
+    # Enables the retrieval of the current and historic presence set for a channel.
+    #
+    class Presence
+      include Ably::Modules::Conversions
+
+      # {Ably::Rest::Client} for this Presence object
+      #
+      # @return {Ably::Rest::Client}
+      #
+      # @private
+      attr_reader :client
+
+      # {Ably::Rest::Channel} this Presence object is associated with
+      #
+      # @return [Ably::Rest::Channel]
+      #
+      attr_reader :channel
+
+      # Initialize a new Presence object
+      #
+      # @param client [Ably::Rest::Client]
+      # @param channel [Channel] The channel object
+      #
+      def initialize(client, channel)
+        @client  = client
+        @channel = channel
+      end
+
+      # Retrieves the current members present on the channel and the metadata for each member, such as their
+      # {Ably::Models::PresenceMessage::ACTION} and ID. Returns a {Ably::Models::PaginatedResult} object,
+      # containing an array of {Ably::Models::PresenceMessage} objects.
+      #
+      # @spec RSPa, RSP3a, RSP3a2, RSP3a3
+      #
+      # @param [Hash] options the options for the set of members present
+      # @option options [Integer]   :limit           An upper limit on the number of messages returned. The default is 100, and the maximum is 1000. (RSP3a)
+      # @option options [String]    :client_id       Filters the list of returned presence members by a specific client using its ID. (RSP3a2)
+      # @option options [String]    :connection_id   Filters the list of returned presence members by a specific connection using its ID. (RSP3a3)
+      #
+      # @return [Ably::Models::PaginatedResult<Ably::Models::PresenceMessage>] A {Ably::Models::PaginatedResult} object containing an array of {Ably::Models::PresenceMessage} objects.
+      #
+      def get(options = {})
+        options = options = {
+          :limit     => 100
+        }.merge(options)
+
+        paginated_options = {
+          coerce_into: 'Ably::Models::PresenceMessage',
+          async_blocking_operations: options.delete(:async_blocking_operations),
+        }
+
+        response = client.get(base_path, options)
+
+        Ably::Models::PaginatedResult.new(response, base_path, client, paginated_options) do |presence_message|
+          presence_message.tap do |message|
+            decode_message message
+          end
+        end
+      end
+
+      # Retrieves a {Ably::Models::PaginatedResult} object, containing an array of historical {Ably::Models::PresenceMessage}
+      # objects for the channel. If the channel is configured to persist messages, then presence messages can be retrieved
+      # from history for up to 72 hours in the past. If not, presence messages can only be retrieved from history for up to two minutes in the past.
+      #
+      # @spec RSP4a
+      #
+      # @param [Hash] options the options for the message history request
+      # @option options [Integer,Time] :start      The time from which messages are retrieved, specified as milliseconds since the Unix epoch. (RSP4b1)
+      # @option options [Integer,Time] :end        The time until messages are retrieved, specified as milliseconds since the Unix epoch. (RSP4b1)
+      # @option options [Symbol]       :direction  The order for which messages are returned in. Valid values are backwards which orders messages from most recent to oldest, or forwards which orders messages from oldest to most recent. The default is backwards. (RSP4b2)
+      # @option options [Integer]      :limit      An upper limit on the number of messages returned. The default is 100, and the maximum is 1000. (RSP4b3)
+      #
+      # @return [Ably::Models::PaginatedResult<Ably::Models::PresenceMessage>] A {Ably::Models::PaginatedResult} object containing an array of {Ably::Models::PresenceMessage} objects.
+      #
+      def history(options = {})
+        url = "#{base_path}/history"
+        options = options = {
+          :direction => :backwards,
+          :limit     => 100
+        }.merge(options)
+
+        [:start, :end].each { |option| options[option] = as_since_epoch(options[option]) if options.has_key?(option) }
+        raise ArgumentError, ":end must be equal to or after :start" if options[:start] && options[:end] && (options[:start] > options[:end])
+
+        paginated_options = {
+          coerce_into: 'Ably::Models::PresenceMessage',
+          async_blocking_operations: options.delete(:async_blocking_operations),
+        }
+
+        response = client.get(url, options)
+
+        Ably::Models::PaginatedResult.new(response, url, client, paginated_options) do |presence_message|
+          presence_message.tap do |message|
+            decode_message message
+          end
+        end
+      end
+
+      private
+      def base_path
+        "/channels/#{URI.encode_www_form_component(channel.name)}/presence"
+      end
+
+      def decode_message(presence_message)
+        presence_message.decode client.encoders, channel.options
+      rescue Ably::Exceptions::CipherError, Ably::Exceptions::EncoderError => e
+        client.logger.error { "Decoding Error on presence channel '#{channel.name}', presence message client_id '#{presence_message.client_id}'. #{e.class.name}: #{e.message}" }
+      end
+    end
+  end
+end

data/lib/ably/rest/push/admin.rb

@@ -0,0 +1,58 @@
+require 'ably/rest/push/device_registrations'
+require 'ably/rest/push/channel_subscriptions'
+
+module Ably::Rest
+  class Push
+    # Class providing push notification administrative functionality
+    # for registering devices and attaching to channels etc.
+    class Admin
+      include Ably::Modules::Conversions
+
+      # @api private
+      attr_reader :client
+
+      # @api private
+      attr_reader :push
+
+      def initialize(push)
+        @push = push
+        @client = push.client
+      end
+
+      # Publish a push message directly to a single recipient
+      #
+      # @param recipient [Hash] A recipient device, client_id or raw APNS/FCM/web target. Refer to push documentation
+      # @param data      [Hash] The notification payload data and fields. Refer to push documentation
+      #
+      # @return [void]
+      #
+      def publish(recipient, data)
+        raise ArgumentError, "Expecting a Hash object for recipient, got #{recipient.class}" unless recipient.kind_of?(Hash)
+        raise ArgumentError, "Recipient data is empty. You must provide recipient details" if recipient.empty?
+        raise ArgumentError, "Expecting a Hash object for data, got #{data.class}" unless data.kind_of?(Hash)
+        raise ArgumentError, "Push data field is empty. You must provide attributes for the push notification" if data.empty?
+
+        publish_data = data.merge(recipient: IdiomaticRubyWrapper(recipient))
+        # Co-erce to camelCase for notitication fields which are always camelCase
+        publish_data[:notification] = IdiomaticRubyWrapper(data[:notification]) if publish_data[:notification].kind_of?(Hash)
+        client.post('/push/publish', publish_data)
+      end
+
+      # Manage device registrations
+      #
+      # @return [Ably::Rest::Push::DeviceRegistrations]
+      #
+      def device_registrations
+        @device_registrations ||= DeviceRegistrations.new(self)
+      end
+
+      # Manage channel subscriptions for devices or clients
+      #
+      # @return [Ably::Rest::Push::ChannelSubscriptions]
+      #
+      def channel_subscriptions
+        @channel_subscriptions ||= ChannelSubscriptions.new(self)
+      end
+    end
+  end
+end

data/lib/ably/rest/push/channel_subscriptions.rb

@@ -0,0 +1,121 @@
+module Ably::Rest
+  class Push
+    # Manage push notification channel subscriptions for devices or client identifiers
+    class ChannelSubscriptions
+      include Ably::Modules::Conversions
+
+      # @api private
+      attr_reader :client
+
+      # @api private
+      attr_reader :admin
+
+      def initialize(admin)
+        @admin = admin
+        @client = admin.client
+      end
+
+      # List channel subscriptions filtered by optional params
+      #
+      # @param [Hash] params   the filter options for the list channel subscription request. At least one of channel, client_id or device_id is required
+      # @option params [String]   :channel    filter by realtime pub/sub channel name
+      # @option params [String]   :client_id  filter by devices registered to a client identifier. If provided with device_id param, a concat operation is used so that any device with this client_id or provided device_id is returned.
+      # @option params [String]   :device_id  filter by unique device ID. If provided with client_id param, a concat operation is used so that any device with this device_id or provided client_id is returned.
+      # @option params [Integer]  :limit      maximum number of subscriptions to retrieve up to 1,000, defaults to 100
+      #
+      # @return [Ably::Models::PaginatedResult<Ably::Models::PushChannelSubscription>]  Paginated list of matching {Ably::Models::PushChannelSubscription}
+      #
+      def list(params)
+        raise ArgumentError, "params must be a Hash" unless params.kind_of?(Hash)
+
+        if (IdiomaticRubyWrapper(params).keys & [:channel, :client_id, :device_id]).length == 0
+          raise ArgumentError, "at least one channel, client_id or device_id filter param must be provided"
+        end
+
+        params = params.clone
+
+        paginated_options = {
+          coerce_into: 'Ably::Models::PushChannelSubscription',
+          async_blocking_operations: params.delete(:async_blocking_operations),
+        }
+
+        response = client.get('/push/channelSubscriptions', IdiomaticRubyWrapper(params).as_json)
+
+        Ably::Models::PaginatedResult.new(response, '', client, paginated_options)
+      end
+
+      # List channels with at least one subscribed device
+      #
+      # @param [Hash] params   the options for the list channels request
+      # @option params [Integer]  :limit      maximum number of channels to retrieve up to 1,000, defaults to 100
+      #
+      # @return [Ably::Models::PaginatedResult<String>]  Paginated list of matching {Ably::Models::PushChannelSubscription}
+      #
+      def list_channels(params = {})
+        params = {} if params.nil?
+        raise ArgumentError, "params must be a Hash" unless params.kind_of?(Hash)
+
+        params = params.clone
+
+        paginated_options = {
+          coerce_into: 'String',
+          async_blocking_operations: params.delete(:async_blocking_operations),
+        }
+
+        response = client.get('/push/channels', IdiomaticRubyWrapper(params).as_json)
+
+        Ably::Models::PaginatedResult.new(response, '', client, paginated_options)
+      end
+
+      # Save push channel subscription for a device or client ID
+      #
+      # @param [Ably::Models::PushChannelSubscription,Hash]   push_channel_subscription   the push channel subscription details to save
+      #
+      # @return [void]
+      #
+      def save(push_channel_subscription)
+        push_channel_subscription_object = PushChannelSubscription(push_channel_subscription)
+        raise ArgumentError, "Channel is required yet is empty" if push_channel_subscription_object.channel.to_s.empty?
+
+        client.post("/push/channelSubscriptions", push_channel_subscription_object.as_json)
+      end
+
+      # Remove a push channel subscription
+      #
+      # @param [Ably::Models::PushChannelSubscription,Hash]   push_channel_subscription   the push channel subscription details to remove
+      #
+      # @return [void]
+      #
+      def remove(push_channel_subscription)
+        push_channel_subscription_object = PushChannelSubscription(push_channel_subscription)
+        raise ArgumentError, "Channel is required yet is empty" if push_channel_subscription_object.channel.to_s.empty?
+        if push_channel_subscription_object.client_id.to_s.empty? && push_channel_subscription_object.device_id.to_s.empty?
+          raise ArgumentError, "Either client_id or device_id must be present"
+        end
+
+        client.delete("/push/channelSubscriptions", push_channel_subscription_object.as_json)
+      end
+
+      # Remove all matching push channel subscriptions
+      #
+      # @param [Hash] params   the filter options for the list channel subscription request. At least one of channel, client_id or device_id is required
+      # @option params [String]   :channel    filter by realtime pub/sub channel name
+      # @option params [String]   :client_id  filter by devices registered to a client identifier. If provided with device_id param, a concat operation is used so that any device with this client_id or provided device_id is returned.
+      # @option params [String]   :device_id  filter by unique device ID. If provided with client_id param, a concat operation is used so that any device with this device_id or provided client_id is returned.
+      #
+      # @return [void]
+      #
+      def remove_where(params)
+        raise ArgumentError, "params must be a Hash" unless params.kind_of?(Hash)
+
+        if (IdiomaticRubyWrapper(params).keys & [:channel, :client_id, :device_id]).length == 0
+          raise ArgumentError, "at least one channel, client_id or device_id filter param must be provided"
+        end
+
+        params = params.clone
+
+        client.delete("/push/channelSubscriptions", IdiomaticRubyWrapper(params).as_json)
+      end
+    end
+  end
+end