ably-pubsub-core 0.0.1.pre

data/lib/ably/realtime/push/device_registrations.rb

@@ -0,0 +1,105 @@
+module Ably::Realtime
+  class Push
+    # Manage device registrations for push notifications
+    class DeviceRegistrations
+      include Ably::Modules::Conversions
+      include Ably::Modules::AsyncWrapper
+
+      # @api private
+      attr_reader :client
+
+      # @api private
+      attr_reader :admin
+
+      def initialize(admin)
+        @admin = admin
+        @client = admin.client
+      end
+
+      # (see Ably::Rest::Push::DeviceRegistrations#get)
+      #
+      # @yield  Block is invoked when request succeeds
+      # @return [Ably::Util::SafeDeferrable]
+      #
+      def get(device_id, &callback)
+        device_id = device_id.id if device_id.kind_of?(Ably::Models::DeviceDetails)
+        raise ArgumentError, "device_id must be a string or DeviceDetails object" unless device_id.kind_of?(String)
+
+        async_wrap(callback) do
+          rest_device_registrations.get(device_id)
+        end
+      end
+
+      # (see Ably::Rest::Push::DeviceRegistrations#list)
+      #
+      # @yield  Block is invoked when request succeeds
+      # @return [Ably::Util::SafeDeferrable]
+      #
+      def list(params = {}, &callback)
+        params = {} if params.nil?
+        raise ArgumentError, "params must be a Hash" unless params.kind_of?(Hash)
+        raise ArgumentError, "device_id filter cannot be specified alongside a client_id filter. Use one or the other" if params[:client_id] && params[:device_id]
+
+        async_wrap(callback) do
+          rest_device_registrations.list(params.merge(async_blocking_operations: true))
+        end
+      end
+
+      # (see Ably::Rest::Push::DeviceRegistrations#save)
+      #
+      # @yield  Block is invoked when request succeeds
+      # @return [Ably::Util::SafeDeferrable]
+      #
+      def save(device, &callback)
+        device_details = DeviceDetails(device)
+        raise ArgumentError, "Device ID is required yet is empty" if device_details.id.nil? || device_details == ''
+
+        async_wrap(callback) do
+          rest_device_registrations.save(device_details)
+        end
+      end
+
+      # (see Ably::Rest::Push::DeviceRegistrations#remove)
+      #
+      # @yield  Block is invoked when request succeeds
+      # @return [Ably::Util::SafeDeferrable]
+      #
+      def remove(device_id, &callback)
+        device_id = device_id.id if device_id.kind_of?(Ably::Models::DeviceDetails)
+        raise ArgumentError, "device_id must be a string or DeviceDetails object" unless device_id.kind_of?(String)
+
+        async_wrap(callback) do
+          rest_device_registrations.remove(device_id)
+        end
+      end
+
+      # (see Ably::Rest::Push::DeviceRegistrations#remove_where)
+      #
+      # @yield  Block is invoked when request succeeds
+      # @return [Ably::Util::SafeDeferrable]
+      #
+      def remove_where(params = {}, &callback)
+        filter = if params.kind_of?(Ably::Models::DeviceDetails)
+          { 'deviceId' => params.id }
+        else
+          raise ArgumentError, "params must be a Hash" unless params.kind_of?(Hash)
+          raise ArgumentError, "device_id filter cannot be specified alongside a client_id filter. Use one or the other" if params[:client_id] && params[:device_id]
+          IdiomaticRubyWrapper(params).as_json
+        end
+
+        async_wrap(callback) do
+          rest_device_registrations.remove_where(filter)
+        end
+      end
+
+      private
+      def rest_device_registrations
+        client.rest_client.push.admin.device_registrations
+      end
+
+      def logger
+        client.logger
+      end
+    end
+  end
+end

data/lib/ably/realtime/push.rb

@@ -0,0 +1,25 @@
+require 'ably/realtime/push/admin'
+
+module Ably
+  module Realtime
+    # Class providing push notification functionality
+    class Push
+      # @private
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+      end
+
+      # A {Ably::Realtime::Push::Admin} object.
+      #
+      # @spec RSH1
+      #
+      # @return [Ably::Realtime::Push::Admin]
+      #
+      def admin
+        @admin ||= Admin.new(self)
+      end
+    end
+  end
+end

data/lib/ably/realtime/recovery_key_context.rb

@@ -0,0 +1,36 @@
+require 'json'
+# frozen_string_literal: true
+
+module Ably
+  module Realtime
+    class RecoveryKeyContext
+      attr_reader :connection_key
+      attr_reader :msg_serial
+      attr_reader :channel_serials
+
+      def initialize(connection_key, msg_serial, channel_serials)
+        @connection_key = connection_key
+        @msg_serial = msg_serial
+        @channel_serials = channel_serials
+        if @channel_serials.nil?
+          @channel_serials = {}
+        end
+      end
+
+      def to_json
+        { 'connection_key' => @connection_key, 'msg_serial' => @msg_serial, 'channel_serials' => @channel_serials }.to_json
+      end
+
+      def self.from_json(obj, logger = nil)
+        begin
+          data = JSON.load obj
+          self.new data['connection_key'], data['msg_serial'], data['channel_serials']
+        rescue => e
+          logger.warn "unable to decode recovery key, found error #{e}" unless logger.nil?
+          return nil
+        end
+      end
+
+    end
+  end
+end

data/lib/ably/realtime.rb

@@ -0,0 +1,60 @@
+require 'eventmachine'
+require 'websocket/driver'
+require 'em-http-request'
+
+require 'ably/modules/event_emitter'
+
+require 'ably/realtime/auth'
+require 'ably/realtime/channel'
+require 'ably/realtime/channels'
+require 'ably/realtime/client'
+require 'ably/realtime/connection'
+require 'ably/realtime/push'
+require 'ably/realtime/presence'
+
+require 'ably/models/message_encoders/base'
+
+Dir.glob(File.expand_path("models/*.rb", File.dirname(__FILE__))).each do |file|
+  require file
+end
+
+Dir.glob(File.expand_path("realtime/models/*.rb", File.dirname(__FILE__))).each do |file|
+  require file
+end
+
+require 'ably/models/message_encoders/base'
+
+require 'ably/realtime/client/incoming_message_dispatcher'
+require 'ably/realtime/client/outgoing_message_dispatcher'
+
+module Ably
+  # Realtime provides the top-level class to be instanced for the Ably Realtime library
+  #
+  # @example
+  #   client = Ably::Realtime.new("xxxxx")
+  #   channel = client.channel("test")
+  #   channel.subscribe do |message|
+  #     message[:name] #=> "greeting"
+  #   end
+  #   channel.publish "greeting", "data"
+  #
+  module Realtime
+    # Convenience method providing an alias to {Ably::Realtime::Client} constructor.
+    #
+    # @param (see Ably::Realtime::Client#initialize)
+    # @option options (see Ably::Realtime::Client#initialize)
+    #
+    # @return [Ably::Realtime::Client]
+    #
+    # @example
+    #    # create a new client authenticating with basic auth
+    #    client = Ably::Realtime.new('key.id:secret')
+    #
+    #    # create a new client authenticating with basic auth and a client_id
+    #    client = Ably::Realtime.new(key: 'key.id:secret', client_id: 'john')
+    #
+    def self.new(options)
+      Ably::Realtime::Client.new(options)
+    end
+  end
+end

data/lib/ably/rest/channel/push_channel.rb

@@ -0,0 +1,59 @@
+module Ably::Rest
+  class Channel
+    # A push channel used for push notifications
+    # Each PushChannel maps to exactly one Rest Channel
+    #
+    class PushChannel
+      attr_reader :channel
+
+      def initialize(channel)
+        raise ArgumentError, "Unsupported channel type '#{channel.class}'" unless channel.kind_of?(Ably::Rest::Channel)
+        @channel = channel
+      end
+
+      def to_s
+        "<PushChannel: name=#{channel.name}>"
+      end
+
+      # Subscribe local device for push notifications on this channel
+      #
+      # @note This is unsupported in the Ruby library
+      def subscribe_device(*args)
+        raise_unsupported
+      end
+
+      # Subscribe all devices registered to this client's authenticated client_id for push notifications on this channel
+      #
+      # @note This is unsupported in the Ruby library
+      def subscribe_client_id(*args)
+        raise_unsupported
+      end
+
+      # Unsubscribe local device for push notifications on this channel
+      #
+      # @note This is unsupported in the Ruby library
+      def unsubscribe_device(*args)
+        raise_unsupported
+      end
+
+      # Unsubscribe all devices registered to this client's authenticated client_id for push notifications on this channel
+      #
+      # @note This is unsupported in the Ruby library
+      def unsubscribe_client_id(*args)
+        raise_unsupported
+      end
+
+      # Get list of subscriptions on this channel for this device or authenticate client_id
+      #
+      # @note This is unsupported in the Ruby library
+      def get_subscriptions(*args)
+        raise_unsupported
+      end
+
+      private
+      def raise_unsupported
+        raise Ably::Exceptions::PushNotificationsNotSupported, 'This device does not support receiving or subscribing to push notifications. All PushChannel methods are unavailable'
+      end
+    end
+  end
+end

data/lib/ably/rest/channel.rb

@@ -0,0 +1,194 @@
+module Ably
+  module Rest
+    # Enables messages to be published and historic messages to be retrieved for a channel.
+    #
+    class Channel
+      include Ably::Modules::Conversions
+
+      # Ably client associated with this channel
+      # @return [Ably::Realtime::Client]
+      # @api private
+      attr_reader :client
+
+      # The channel name.
+      # @return [String]
+      attr_reader :name
+
+      attr_reader :options
+
+      # A {Ably::Rest::Channel::PushChannel} object
+      # @spec RSH4
+      # @return [Ably::Rest::Channel::PushChannel]
+      # @api private
+      attr_reader :push
+
+      IDEMPOTENT_LIBRARY_GENERATED_ID_LENGTH = 9 # See spec RSL1k1
+
+      # Initialize a new Channel object
+      #
+      # @param client [Ably::Rest::Client]
+      # @param name [String] The name of the channel
+      # @param channel_options [Hash, Ably::Models::ChannelOptions]     A hash of options or a {Ably::Models::ChannelOptions}
+      #
+      def initialize(client, name, channel_options = {})
+        name = (ensure_utf_8 :name, name)
+
+        @options = Ably::Models::ChannelOptions(channel_options)
+        @client  = client
+        @name    = name
+        @push    = PushChannel.new(self)
+      end
+
+      # Publishes a message to the channel. A callback may optionally be passed in to this call to be notified of success or failure of the operation.
+      #
+      # @spec RSL1
+      #
+      # @param name [String, Array<Ably::Models::Message|Hash>, Ably::Models::Message, nil]   The event name of the message to publish, or an Array of [Ably::Model::Message] objects or [Hash] objects with +:name+ and +:data+ pairs, or a single Ably::Model::Message object
+      # @param data [String, Array, Hash, nil]   The message payload unless an Array of [Ably::Model::Message] objects passed in the first argument, in which case an optional hash of query parameters
+      # @param attributes [Hash, nil]   Optional additional message attributes such as :extras, :id, :client_id or :connection_id, applied when name attribute is nil or a string (Deprecated, will be removed in 2.0 in favour of constructing a Message object)
+      # @return [Boolean]  true if the message was published, otherwise false
+      #
+      # @example
+      #   # Publish a single message with (name, data) form
+      #   channel.publish 'click', { x: 1, y: 2 }
+      #
+      #   # Publish a single message with single Hash form
+      #   message = { name: 'click', data: { x: 1, y: 2 } }
+      #   channel.publish message
+      #
+      #   # Publish an array of message Hashes form
+      #   messages = [
+      #     { name: 'click', data: { x: 1, y: 2 } },
+      #     { name: 'click', data: { x: 2, y: 3 } }
+      #   ]
+      #   channel.publish messages
+      #
+      #   # Publish an array of Ably::Models::Message objects form
+      #   messages = [
+      #     Ably::Models::Message(name: 'click', data: { x: 1, y: 2 })
+      #     Ably::Models::Message(name: 'click', data: { x: 2, y: 3 })
+      #   ]
+      #   channel.publish messages
+      #
+      #   # Publish a single Ably::Models::Message object form
+      #   message = Ably::Models::Message(name: 'click', data: { x: 1, y: 2 })
+      #   channel.publish message
+      #
+      def publish(name, data = nil, attributes = {})
+        qs_params = nil
+        qs_params = data if name.kind_of?(Enumerable) || name.kind_of?(Ably::Models::Message)
+
+        messages = build_messages(name, data, attributes) # (RSL1a, RSL1b)
+
+        if messages.sum(&:size) > (max_message_size = client.max_message_size || Ably::Rest::Client::MAX_MESSAGE_SIZE)
+          raise Ably::Exceptions::MaxMessageSizeExceeded.new("Maximum message size exceeded #{max_message_size} bytes.")
+        end
+
+        payload = messages.map do |message|
+          Ably::Models::Message(message.dup).tap do |msg|
+            msg.encode client.encoders, options
+
+            next if msg.client_id.nil?
+            if msg.client_id == '*'
+              raise Ably::Exceptions::IncompatibleClientId.new('Wildcard client_id is reserved and cannot be used when publishing messages')
+            end
+            unless client.auth.can_assume_client_id?(msg.client_id)
+              raise Ably::Exceptions::IncompatibleClientId.new("Cannot publish with client_id '#{msg.client_id}' as it is incompatible with the current configured client_id '#{client.client_id}'")
+            end
+          end.as_json
+        end.tap do |payload|
+          if client.idempotent_rest_publishing
+            # We cannot mutate for idempotent publishing if one or more messages already has an ID
+            if payload.all? { |msg| !msg['id'] }
+              # Mutate the JSON to support idempotent publishing where a Message.id does not exist
+              idempotent_publish_id = SecureRandom.base64(IDEMPOTENT_LIBRARY_GENERATED_ID_LENGTH)
+              payload.each_with_index do |msg, idx|
+                msg['id'] = "#{idempotent_publish_id}:#{idx}"
+              end
+            end
+          end
+        end
+
+        options = qs_params ? { qs_params: qs_params } : {}
+        response = client.post("#{base_path}/publish", payload.length == 1 ? payload.first : payload, options)
+
+        [201, 204].include?(response.status)
+      end
+
+      # Retrieves a {Ably::Models::PaginatedResult} object, containing an array of historical {Ably::Models::Message}
+      # objects for the channel. If the channel is configured to persist messages, then messages can be retrieved from
+      # history for up to 72 hours in the past. If not, messages can only be retrieved from history for up to two minutes in the past.
+      #
+      # @spec RSL2a
+      #
+      # @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. RSL2b1
+      # @option options [Integer,Time] :end        The time until messages are retrieved, specified as milliseconds since the Unix epoch. RSL2b1
+      # @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. RSL2b2
+      # @option options [Integer]      :limit      An upper limit on the number of messages returned. The default is 100, and the maximum is 1000. RSL2b3
+      #
+      # @return [Ably::Models::PaginatedResult<Ably::Models::Message>] A {Ably::Models::PaginatedResult} object containing an array of {Ably::Models::Message} objects.
+      #
+      def history(options = {})
+        url = "#{base_path}/messages"
+        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::Message',
+          async_blocking_operations: options.delete(:async_blocking_operations),
+        }
+
+        response = client.get(url, options)
+
+        Ably::Models::PaginatedResult.new(response, url, client, paginated_options) do |message|
+          message.tap do |msg|
+            decode_message msg
+          end
+        end
+      end
+
+      # A {Ably::Rest::Presence} object.
+      # @spec RSL3
+      # @return [Ably::Rest::Presence]
+      def presence
+        @presence ||= Presence.new(client, self)
+      end
+
+      # Sets the {Ably::Models::ChannelOptions} for the channel.
+      # @spec RSL7
+      # @param channel_options [Hash, Ably::Models::ChannelOptions]  A hash of options or a {Ably::Models::ChannelOptions}
+      # @return [Ably::Models::ChannelOptions]
+      def set_options(channel_options)
+        @options = Ably::Models::ChannelOptions(channel_options)
+      end
+      alias options= set_options
+
+      # Retrieves a {Ably::Models::ChannelDetails} object for the channel, which includes status and occupancy metrics.
+      # @spec RSL8
+      # @return [Ably::Models::ChannelDetails] 	A {Ably::Models::ChannelDetails} object.
+      def status
+        Ably::Models::ChannelDetails.new(client.get(base_path).body)
+      end
+
+      private
+
+      def base_path
+        "/channels/#{URI.encode_www_form_component(name)}"
+      end
+
+      def decode_message(message)
+        message.decode client.encoders, options
+      rescue Ably::Exceptions::CipherError, Ably::Exceptions::EncoderError => e
+        client.logger.error { "Decoding Error on channel '#{name}', message event name '#{message.name}'. #{e.class.name}: #{e.message}" }
+      end
+    end
+  end
+end
+
+require 'ably/rest/channel/push_channel'

data/lib/ably/rest/channels.rb

@@ -0,0 +1,47 @@
+module Ably
+  module Rest
+    class Channels
+      include Ably::Modules::ChannelsCollection
+
+      # @return [Ably::Rest::Channels]
+      def initialize(client)
+        super client, Ably::Rest::Channel
+      end
+
+      # Return a {Ably::Rest::Channel} for the given name
+      #
+      # @param name [String] The name of the channel
+      # @param channel_options [Hash] Channel options, currently reserved for Encryption options
+      #
+      # @return [Ably::Rest::Channel]
+      #
+      def get(*args)
+        super
+      end
+
+      # Return a {Ably::Rest::Channel} for the given name if it exists, else the block will be called.
+      # This method is intentionally similar to {http://ruby-doc.org/core-2.1.3/Hash.html#method-i-fetch Hash#fetch} providing a simple way to check if a channel exists or not without creating one
+      #
+      # @param name [String] The name of the channel
+      # @yield [options] (optional) if a missing_block is passed to this method and no channel exists matching the name, this block is called
+      # @yieldparam [String] name of the missing channel
+      #
+      # @return [Ably::Rest::Channel]
+      #
+      def fetch(*args)
+        super
+      end
+
+      # Destroy the {Ably::Rest::Channel} and releases the associated resources.
+      #
+      # Releasing a {Ably::Rest::Channel} is not typically necessary as a channel consumes no resources other than the memory footprint of the
+      # {Ably::Rest::Channel} object. Explicitly release channels to free up resources if required
+      #
+      # @return [void]
+      #
+      def release(*args)
+        super
+      end
+    end
+  end
+end