ably-rest 1.0.5 → 1.1.3

data/lib/submodules/ably-ruby/lib/ably/realtime/connection/connection_manager.rb

@@ -43,25 +43,38 @@ module Ably::Realtime
         end
 
         unless client.auth.authentication_security_requirements_met?
-          connection.transition_state_machine :failed, reason: Ably::Exceptions::InsecureRequest.new('Cannot use Basic Auth over non-TLS connections', 401, 40103)
+          connection.transition_state_machine :failed, reason: Ably::Exceptions::InsecureRequest.new('Cannot use Basic Auth over non-TLS connections', 401, Ably::Exceptions::Codes::INVALID_USE_OF_BASIC_AUTH_OVER_NONTLS_TRANSPORT)
           return
         end
 
         logger.debug { 'ConnectionManager: Opening a websocket transport connection' }
 
+        # The socket attempt can fail at the same time as a timer firing so ensure
+        #   only one outcome is processed from this setup attempt
+        setup_attempt_status = {}
+        setup_failed = lambda do
+          return true if setup_attempt_status[:failed]
+          setup_attempt_status[:failed] = true
+          false
+        end
+
         connection.create_websocket_transport.tap do |socket_deferrable|
           socket_deferrable.callback do |websocket_transport|
             subscribe_to_transport_events websocket_transport
             yield websocket_transport if block_given?
           end
           socket_deferrable.errback do |error|
+            next if setup_failed.call
             connection_opening_failed error
           end
         end
 
+        # The connection request timeout must be marginally higher than the REST request timeout to ensure
+        #   any HTTP auth request failure due to timeout triggers before the connection timer kicks in
         logger.debug { "ConnectionManager: Setting up automatic connection timeout timer for #{realtime_request_timeout}s" }
         create_timeout_timer_whilst_in_state(:connecting, realtime_request_timeout) do
-          connection_opening_failed Ably::Exceptions::ConnectionTimeout.new("Connection to Ably timed out after #{realtime_request_timeout}s", nil, 80014)
+          next if setup_failed.call
+          connection_opening_failed Ably::Exceptions::ConnectionTimeout.new("Connection to Ably timed out after #{realtime_request_timeout}s", nil, Ably::Exceptions::Codes::CONNECTION_TIMED_OUT)
         end
       end
 
@@ -72,7 +85,7 @@ module Ably::Realtime
         if error.kind_of?(Ably::Exceptions::BaseAblyException)
           # Authentication errors that indicate the authentication failure is terminal should move to the failed state
           if ([401, 403].include?(error.status) && !RESOLVABLE_ERROR_CODES.fetch(:token_expired).include?(error.code)) ||
-             (error.code == Ably::Exceptions::INVALID_CLIENT_ID)
+             (error.code == Ably::Exceptions::Codes::INVALID_CLIENT_ID)
             connection.transition_state_machine :failed, reason: error
             return
           end
@@ -80,7 +93,12 @@ module Ably::Realtime
 
         logger.warn { "ConnectionManager: Connection to #{connection.current_host}:#{connection.port} failed; #{error.message}" }
         next_state = get_next_retry_state_info
-        connection.transition_state_machine next_state.fetch(:state), retry_in: next_state.fetch(:pause), reason: Ably::Exceptions::ConnectionError.new("Connection failed: #{error.message}", nil, 80000, error)
+
+        if connection.state == next_state.fetch(:state)
+          logger.error { "ConnectionManager: Skipping next retry state after connection opening failed as already in state #{next_state}\n#{caller[0..20].join("\n")}" }
+        else
+          connection.transition_state_machine next_state.fetch(:state), retry_in: next_state.fetch(:pause), reason: Ably::Exceptions::ConnectionError.new("Connection failed: #{error.message}", nil, Ably::Exceptions::Codes::CONNECTION_FAILED, error)
+        end
       end
 
       # Called whenever a new connection is made
@@ -100,13 +118,11 @@ module Ably::Realtime
             resend_pending_message_ack_queue
           else
             logger.debug { "ConnectionManager: Connection was not resumed, old connection ID #{connection.id} has been updated with new connection ID #{protocol_message.connection_id} and key #{protocol_message.connection_key}" }
-            connection.reset_client_serial
             nack_messages_on_all_channels protocol_message.error
             force_reattach_on_channels protocol_message.error
           end
         else
           logger.debug { "ConnectionManager: New connection created with ID #{protocol_message.connection_id} and key #{protocol_message.connection_key}" }
-          connection.reset_client_serial
         end
 
         reattach_suspended_channels protocol_message.error
@@ -319,7 +335,7 @@ module Ably::Realtime
         @liveness_timer = EventMachine::Timer.new(connection.heartbeat_interval + 0.1) do
           if connection.connected? && (connection.time_since_connection_confirmed_alive? >= connection.heartbeat_interval)
             msg = "No activity seen from realtime in #{connection.heartbeat_interval}; assuming connection has dropped";
-            error = Ably::Exceptions::ConnectionTimeout.new(msg, 80003, 408)
+            error = Ably::Exceptions::ConnectionTimeout.new(msg, Ably::Exceptions::Codes::DISCONNECTED, 408)
             connection.transition_state_machine! :disconnected, reason: error
           end
         end
@@ -492,9 +508,9 @@ module Ably::Realtime
             connection.transition_state_machine :closed
           elsif !connection.closed? && !connection.disconnected? && !connection.failed? && !connection.suspended?
             exception = if reason
-              Ably::Exceptions::TransportClosed.new(reason, nil, 80003)
+              Ably::Exceptions::TransportClosed.new(reason, nil, Ably::Exceptions::Codes::DISCONNECTED)
             else
-              Ably::Exceptions::TransportClosed.new('Transport disconnected unexpectedly', nil, 80003)
+              Ably::Exceptions::TransportClosed.new('Transport disconnected unexpectedly', nil, Ably::Exceptions::Codes::DISCONNECTED)
             end
             next_state = get_next_retry_state_info
             connection.transition_state_machine next_state.fetch(:state), retry_in: next_state.fetch(:pause), reason: exception

data/lib/submodules/ably-ruby/lib/ably/realtime/connection/websocket_transport.rb

@@ -157,7 +157,7 @@ module Ably::Realtime
           logger.debug { "WebsocketTransport: Prot msg recv <=: #{action_name} - #{event_data}" }
 
           if protocol_message.invalid?
-            error = Ably::Exceptions::ProtocolError.new("Invalid Protocol Message received: #{event_data}\nConnection moving to the failed state as the protocol is invalid and unsupported", 400, 80013)
+            error = Ably::Exceptions::ProtocolError.new("Invalid Protocol Message received: #{event_data}\nConnection moving to the failed state as the protocol is invalid and unsupported", 400, Ably::Exceptions::Codes::PROTOCOL_ERROR)
             logger.fatal { "WebsocketTransport: #{error.message}" }
             failed_protocol_message = Ably::Models::ProtocolMessage.new(
               action: Ably::Models::ProtocolMessage::ACTION.Error,
@@ -208,7 +208,7 @@ module Ably::Realtime
 
       def create_pub_sub_message_bus
         Ably::Util::PubSub.new(
-          coerce_into: Proc.new do |event|
+          coerce_into: lambda do |event|
             raise KeyError, "Expected :protocol_message, :#{event} is disallowed" unless event == :protocol_message
             :protocol_message
           end

data/lib/submodules/ably-ruby/lib/ably/realtime/presence.rb

@@ -71,7 +71,7 @@ module Ably::Realtime
 
       ensure_channel_attached(deferrable) do
         if entering?
-          once_or_if(STATE.Entered, else: proc { |args| deferrable_fail deferrable, *args }) do
+          once_or_if(STATE.Entered, else: lambda { |args| deferrable_fail deferrable, *args }) do
             deferrable_succeed deferrable, &success_block
           end
         else
@@ -132,7 +132,7 @@ module Ably::Realtime
 
       ensure_channel_attached(deferrable) do
         if leaving?
-          once_or_if(STATE.Left, else: proc { |error|deferrable_fail deferrable, *args }) do
+          once_or_if(STATE.Left, else: lambda { |error|deferrable_fail deferrable, *args }) do
             deferrable_succeed deferrable, &success_block
           end
         else
@@ -233,7 +233,7 @@ module Ably::Realtime
           deferrable.fail Ably::Exceptions::InvalidState.new(
             'Presence state is out of sync as channel is SUSPENDED. Presence#get on a SUSPENDED channel is only supported with option wait_for_sync: false',
             nil,
-            91005
+            Ably::Exceptions::Codes::PRESENCE_STATE_IS_OUT_OF_SYNC
           )
         end
         return deferrable
@@ -310,7 +310,7 @@ module Ably::Realtime
     # @api private
     def __incoming_msgbus__
       @__incoming_msgbus__ ||= Ably::Util::PubSub.new(
-        coerce_into: Proc.new { |event| Ably::Models::ProtocolMessage::ACTION(event) }
+        coerce_into: lambda { |event| Ably::Models::ProtocolMessage::ACTION(event) }
       )
     end
 
@@ -330,7 +330,7 @@ module Ably::Realtime
     def send_presence_protocol_message(presence_action, client_id, data)
       presence_message = create_presence_message(presence_action, client_id, data)
       unless presence_message.client_id
-        raise Ably::Exceptions::Standard.new('Unable to enter create presence message without a client_id', 400, 91000)
+        raise Ably::Exceptions::Standard.new('Unable to enter create presence message without a client_id', 400, Ably::Exceptions::Codes::UNABLE_TO_ENTER_PRESENCE_CHANNEL_NO_CLIENTID)
       end
 
       protocol_message = {
@@ -437,13 +437,13 @@ module Ably::Realtime
 
     def attach_channel_then(deferrable)
       if channel.detached? || channel.failed?
-        deferrable.fail Ably::Exceptions::InvalidState.new("Operation is not allowed when channel is in #{channel.state}", 400, 91001)
+        deferrable.fail Ably::Exceptions::InvalidState.new("Operation is not allowed when channel is in #{channel.state}", 400, Ably::Exceptions::Codes::UNABLE_TO_ENTER_PRESENCE_CHANNEL_INVALID_CHANNEL_STATE)
       else
         channel.unsafe_once(:attached, :detached, :failed) do |channel_state_change|
           if channel_state_change.current == :attached
             yield
           else
-            deferrable.fail Ably::Exceptions::InvalidState.new("Operation failed as channel transitioned to #{channel_state_change.current}", 400, 91001)
+            deferrable.fail Ably::Exceptions::InvalidState.new("Operation failed as channel transitioned to #{channel_state_change.current}", 400, Ably::Exceptions::Codes::UNABLE_TO_ENTER_PRESENCE_CHANNEL_INVALID_CHANNEL_STATE)
           end
         end
         channel.attach

data/lib/submodules/ably-ruby/lib/ably/realtime/presence/members_map.rb

@@ -94,7 +94,7 @@ module Ably::Realtime
         wait_for_sync = options.fetch(:wait_for_sync, true)
         deferrable    = Ably::Util::SafeDeferrable.new(logger)
 
-        result_block = proc do
+        result_block = lambda do
           present_members.tap do |members|
             members.keep_if { |member| member.connection_id == options[:connection_id] } if options[:connection_id]
             members.keep_if { |member| member.client_id == options[:client_id] } if options[:client_id]
@@ -110,17 +110,17 @@ module Ably::Realtime
           # Must be defined before subsequent procs reference this callback
           reset_callbacks = nil
 
-          in_sync_callback = proc do
-            reset_callbacks
+          in_sync_callback = lambda do
+            reset_callbacks.call if reset_callbacks
             result_block.call
           end
 
-          failed_callback = proc do |error|
-            reset_callbacks
+          failed_callback = lambda do |error|
+            reset_callbacks.call if reset_callbacks
             deferrable.fail error
           end
 
-          reset_callbacks = proc do
+          reset_callbacks = lambda do
             off(&in_sync_callback)
             off(&failed_callback)
             channel.off(&failed_callback)
@@ -275,7 +275,7 @@ module Ably::Realtime
             presence_message_client_id = presence_message.client_id || client.auth.client_id
             re_enter_error = Ably::Models::ErrorInfo.new(
               message: "unable to automatically re-enter presence channel for client_id '#{presence_message_client_id}'. Source error code #{error.code} and message '#{error.message}'",
-              code: 91004
+              code: Ably::Exceptions::Codes::UNABLE_TO_AUTOMATICALLY_REENTER_PRESENCE_CHANNEL
             )
             channel.emit :update, Ably::Models::ChannelStateChange.new(
               current: channel.state,
@@ -312,14 +312,14 @@ module Ably::Realtime
         when Ably::Models::PresenceMessage::ACTION.Leave
           remove_presence_member presence_message
         else
-          Ably::Exceptions::ProtocolError.new("Protocol error, unknown presence action #{presence_message.action}", 400, 80013)
+          Ably::Exceptions::ProtocolError.new("Protocol error, unknown presence action #{presence_message.action}", 400, Ably::Exceptions::Codes::PROTOCOL_ERROR)
         end
       end
 
       def ensure_presence_message_is_valid(presence_message)
         return true if presence_message.connection_id
 
-        error = Ably::Exceptions::ProtocolError.new("Protocol error, presence message is missing connectionId", 400, 80013)
+        error = Ably::Exceptions::ProtocolError.new("Protocol error, presence message is missing connectionId", 400, Ably::Exceptions::Codes::PROTOCOL_ERROR)
         logger.error { "PresenceMap: On channel '#{channel.name}' error: #{error}" }
       end
 

data/lib/submodules/ably-ruby/lib/ably/realtime/push.rb

@@ -0,0 +1,40 @@
+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
+
+      # Admin features for push notifications like managing devices and channel subscriptions
+      # @return [Ably::Realtime::Push::Admin]
+      def admin
+        @admin ||= Admin.new(self)
+      end
+
+      # Activate this device for push notifications by registering with the push transport such as GCM/APNS
+      #
+      # @note This is unsupported in the Ruby library
+      def activate(*arg)
+        raise_unsupported
+      end
+
+      # Deactivate this device for push notifications by removing the registration with the push transport such as GCM/APNS
+      #
+      # @note This is unsupported in the Ruby library
+      def deactivate(*arg)
+        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/submodules/ably-ruby/lib/ably/realtime/push/admin.rb

@@ -0,0 +1,61 @@
+require 'ably/realtime/push/device_registrations'
+require 'ably/realtime/push/channel_subscriptions'
+
+module Ably::Realtime
+  class Push
+    # Class providing push notification administrative functionality
+    # for registering devices and attaching to channels etc.
+    class Admin
+      include Ably::Modules::AsyncWrapper
+      include Ably::Modules::Conversions
+
+      # @api private
+      attr_reader :client
+
+      # @api private
+      attr_reader :push
+
+      def initialize(push)
+        @push = push
+        @client = push.client
+      end
+
+      # (see Ably::Rest::Push#publish)
+      #
+      # @yield  Block is invoked upon successful publish of the message
+      # @return [Ably::Util::SafeDeferrable]
+      #
+      def publish(recipient, data, &callback)
+        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?
+
+        async_wrap(callback) do
+          rest_push_admin.publish(recipient, data)
+        end
+      end
+
+      # Manage device registrations
+      # @return [Ably::Realtime::Push::DeviceRegistrations]
+      def device_registrations
+        @device_registrations ||= DeviceRegistrations.new(self)
+      end
+
+      # Manage channel subscriptions for devices or clients
+      # @return [Ably::Realtime::Push::ChannelSubscriptions]
+      def channel_subscriptions
+        @channel_subscriptions ||= ChannelSubscriptions.new(self)
+      end
+
+      private
+      def rest_push_admin
+        client.rest_client.push.admin
+      end
+
+      def logger
+        client.logger
+      end
+    end
+  end
+end

data/lib/submodules/ably-ruby/lib/ably/realtime/push/channel_subscriptions.rb

@@ -0,0 +1,108 @@
+module Ably::Realtime
+  class Push
+    # Manage push notification channel subscriptions for devices or clients
+    class ChannelSubscriptions
+      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::ChannelSubscriptions#list)
+      #
+      # @yield  Block is invoked when request succeeds
+      # @return [Ably::Util::SafeDeferrable]
+      #
+      def list(params, &callback)
+        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
+
+        async_wrap(callback) do
+          rest_channel_subscriptions.list(params.merge(async_blocking_operations: true))
+        end
+      end
+
+      # (see Ably::Rest::Push::ChannelSubscriptions#list_channels)
+      #
+      # @yield  Block is invoked when request succeeds
+      # @return [Ably::Util::SafeDeferrable]
+      #
+      def list_channels(params = {}, &callback)
+        params = {} if params.nil?
+        raise ArgumentError, "params must be a Hash" unless params.kind_of?(Hash)
+
+        async_wrap(callback) do
+          rest_channel_subscriptions.list_channels(params.merge(async_blocking_operations: true))
+        end
+      end
+
+      # (see Ably::Rest::Push::ChannelSubscriptions#save)
+      #
+      # @yield  Block is invoked when request succeeds
+      # @return [Ably::Util::SafeDeferrable]
+      #
+      def save(push_channel_subscription, &callback)
+        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?
+
+        async_wrap(callback) do
+          rest_channel_subscriptions.save(push_channel_subscription)
+        end
+      end
+
+      # (see Ably::Rest::Push::ChannelSubscriptions#remove)
+      #
+      # @yield  Block is invoked when request succeeds
+      # @return [Ably::Util::SafeDeferrable]
+      #
+      def remove(push_channel_subscription, &callback)
+        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
+
+        async_wrap(callback) do
+          rest_channel_subscriptions.remove(push_channel_subscription)
+        end
+      end
+
+      # (see Ably::Rest::Push::ChannelSubscriptions#remove_where)
+      #
+      # @yield  Block is invoked when request succeeds
+      # @return [Ably::Util::SafeDeferrable]
+      #
+      def remove_where(params, &callback)
+        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
+
+        async_wrap(callback) do
+          rest_channel_subscriptions.remove_where(params)
+        end
+      end
+
+      private
+      def rest_channel_subscriptions
+        client.rest_client.push.admin.channel_subscriptions
+      end
+
+      def logger
+        client.logger
+      end
+    end
+  end
+end

data/lib/submodules/ably-ruby/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