ably 0.8.3 → 0.8.4

data/lib/ably/realtime/connection.rb

@@ -55,6 +55,7 @@ module Ably
       )
       include Ably::Modules::StateEmitter
       include Ably::Modules::UsesStateMachine
+      ensure_state_machine_emits 'Ably::Models::ConnectionStateChange'
 
       # Expected format for a connection recover key
       RECOVER_REGEX = /^(?<recover>[\w-]+):(?<connection_serial>\-?\w+)$/

data/lib/ably/realtime/connection/connection_manager.rb

@@ -53,7 +53,7 @@ module Ably::Realtime
         end
 
         unless client.auth.authentication_security_requirements_met?
-          connection.transition_state_machine :failed, 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, 40103)
           return
         end
 
@@ -80,7 +80,8 @@ module Ably::Realtime
       # @api private
       def connection_opening_failed(error)
         logger.warn "ConnectionManager: Connection to #{connection.current_host}:#{connection.port} failed; #{error.message}"
-        connection.transition_state_machine next_retry_state, Ably::Exceptions::ConnectionError.new("Connection failed: #{error.message}", nil, 80000)
+        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)
       end
 
       # Called whenever a new connection is made
@@ -155,11 +156,10 @@ module Ably::Realtime
       # When a connection is disconnected whilst connecting, attempt reconnect and/or set state to :suspended or :failed
       #
       # @api private
-      def respond_to_transport_disconnected_when_connecting(current_transition)
+      def respond_to_transport_disconnected_when_connecting(error)
         return unless connection.disconnected? || connection.suspended? # do nothing if state has changed through an explicit request
         return unless retry_connection? # do not always reattempt connection or change state as client may be re-authorising
 
-        error = current_transition.metadata
         if error.kind_of?(Ably::Models::ErrorInfo)
           renew_token_and_reconnect error if error.code == RESOLVABLE_ERROR_CODES.fetch(:token_expired)
           return
@@ -172,23 +172,22 @@ module Ably::Realtime
         return if connection_retry_for(:suspended)
 
         # Fallback if no other criteria met
-        connection.transition_state_machine :failed, current_transition.metadata
+        connection.transition_state_machine :failed, reason: error
       end
 
       # When a connection is disconnected after connecting, attempt reconnect and/or set state to :suspended or :failed
       #
       # @api private
-      def respond_to_transport_disconnected_whilst_connected(current_transition)
+      def respond_to_transport_disconnected_whilst_connected(error)
         logger.warn "ConnectionManager: Connection to #{connection.transport.url} was disconnected unexpectedly"
 
-        error = current_transition.metadata
         if error.kind_of?(Ably::Models::ErrorInfo) && error.code != RESOLVABLE_ERROR_CODES.fetch(:token_expired)
           connection.emit :error, error
           logger.error "ConnectionManager: Error in Disconnected ProtocolMessage received from the server - #{error}"
         end
 
         destroy_transport
-        respond_to_transport_disconnected_when_connecting current_transition
+        respond_to_transport_disconnected_when_connecting error
       end
 
       # {Ably::Models::ProtocolMessage ProtocolMessage Error} received from server.
@@ -198,13 +197,13 @@ module Ably::Realtime
       def error_received_from_server(error)
         case error.code
         when RESOLVABLE_ERROR_CODES.fetch(:token_expired)
-          connection.transition_state_machine :disconnected
+          connection.transition_state_machine :disconnected, retry_in: 0
           connection.unsafe_once_or_if(:disconnected) do
             renew_token_and_reconnect error
           end
         else
           logger.error "ConnectionManager: Error #{error.class.name} code #{error.code} received from server '#{error.message}', transitioning to failed state"
-          connection.transition_state_machine :failed, error
+          connection.transition_state_machine :failed, reason: error
         end
       end
 
@@ -249,12 +248,26 @@ module Ably::Realtime
         timers.fetch(key, []).each(&:cancel)
       end
 
-      def next_retry_state
-        if connection_retry_from_suspended_state? || time_passed_since_disconnected > CONNECT_RETRY_CONFIG.fetch(:disconnected).fetch(:max_time_in_state)
+      def get_next_retry_state_info
+        retry_state = if connection_retry_from_suspended_state? || !can_reattempt_connect_for_state?(:disconnected)
           :suspended
         else
           :disconnected
         end
+        {
+          state: retry_state,
+          pause: next_retry_pause(retry_state)
+        }
+      end
+
+      def next_retry_pause(retry_state)
+        return nil unless CONNECT_RETRY_CONFIG.fetch(retry_state)
+
+        if retries_for_state(retry_state, ignore_states: [:connecting]).empty?
+          0
+        else
+          CONNECT_RETRY_CONFIG.fetch(retry_state).fetch(:retry_every)
+        end
       end
 
       def connection_retry_from_suspended_state?
@@ -348,13 +361,12 @@ module Ably::Realtime
             connection.transition_state_machine :closed
           elsif !connection.closed? && !connection.disconnected?
             exception = if reason
-              Ably::Exceptions::ConnectionClosed.new(reason)
-            end
-            if connection_retry_from_suspended_state? || !can_reattempt_connect_for_state?(:disconnected)
-              connection.transition_state_machine :suspended, exception
+              Ably::Exceptions::TransportClosed.new(reason, nil, 80003)
             else
-              connection.transition_state_machine :disconnected, exception
+              Ably::Exceptions::TransportClosed.new('Transport disconnected unexpectedly', nil, 80003)
             end
+            next_state = get_next_retry_state_info
+            connection.transition_state_machine next_state.fetch(:state), retry_in: next_state.fetch(:pause), reason: exception
           end
         end
       end
@@ -362,7 +374,7 @@ module Ably::Realtime
       def renew_token_and_reconnect(error)
         if client.auth.token_renewable?
           if @renewing_token
-            connection.transition_state_machine :failed, error
+            connection.transition_state_machine :failed, reason: error
             return
           end
 
@@ -383,18 +395,18 @@ module Ably::Realtime
               if token_details && !token_details.expired?
                 connection.connect
               else
-                connection.transition_state_machine :failed, error unless connection.failed?
+                connection.transition_state_machine :failed, reason: error unless connection.failed?
               end
             end
 
             authorise_deferrable.errback do |auth_error|
               logger.error "ConnectionManager: Error authorising following token expiry: #{auth_error}"
-              connection.transition_state_machine :failed, auth_error
+              connection.transition_state_machine :failed, reason: auth_error
             end
           end
         else
           logger.error "ConnectionManager: Token has expired and is not renewable - #{error}"
-          connection.transition_state_machine :failed, error
+          connection.transition_state_machine :failed, reason: error
         end
       end
 

data/lib/ably/realtime/connection/connection_state_machine.rb

@@ -41,23 +41,25 @@ module Ably::Realtime
       end
 
       before_transition(to: [:connected]) do |connection, current_transition|
-        connection.manager.connected current_transition.metadata
+        connection.manager.connected current_transition.metadata.protocol_message
       end
 
       after_transition(to: [:connected]) do |connection, current_transition|
-        protocol_message = current_transition.metadata
-        if is_error_type?(protocol_message.error)
-          connection.logger.warn "ConnectionManager: Connected with error - #{protocol_message.error.message}"
-          connection.emit :error, protocol_message.error
+        error = current_transition.metadata.reason
+        if is_error_type?(error)
+          connection.logger.warn "ConnectionManager: Connected with error - #{error.message}"
+          connection.emit :error, error
         end
       end
 
       after_transition(to: [:disconnected, :suspended], from: [:connecting]) do |connection, current_transition|
-        connection.manager.respond_to_transport_disconnected_when_connecting current_transition
+        err = error_from_state_change(current_transition)
+        connection.manager.respond_to_transport_disconnected_when_connecting err
       end
 
       after_transition(to: [:disconnected], from: [:connected]) do |connection, current_transition|
-        connection.manager.respond_to_transport_disconnected_whilst_connected current_transition
+        err = error_from_state_change(current_transition)
+        connection.manager.respond_to_transport_disconnected_whilst_connected err
       end
 
       after_transition(to: [:disconnected, :suspended]) do |connection|
@@ -65,7 +67,8 @@ module Ably::Realtime
       end
 
       before_transition(to: [:failed]) do |connection, current_transition|
-        connection.manager.fail current_transition.metadata
+        err = error_from_state_change(current_transition)
+        connection.manager.fail err
       end
 
       after_transition(to: [:closing], from: [:initialized, :disconnected, :suspended]) do |connection|
@@ -82,24 +85,29 @@ module Ably::Realtime
 
       # Transitions responsible for updating connection#error_reason
       before_transition(to: [:disconnected, :suspended, :failed]) do |connection, current_transition|
-        connection.set_failed_connection_error_reason current_transition.metadata
+        err = error_from_state_change(current_transition)
+        connection.set_failed_connection_error_reason err
       end
 
       before_transition(to: [:connected, :closed]) do |connection, current_transition|
-        error = if current_transition.metadata.kind_of?(Ably::Models::ProtocolMessage)
-          current_transition.metadata.error
-        else
-          current_transition.metadata
-        end
+        err = error_from_state_change(current_transition)
 
-        if is_error_type?(error)
-          connection.set_failed_connection_error_reason error
+        if err
+          connection.set_failed_connection_error_reason err
         else
           # Connected & Closed are "healthy" final states so reset the error reason
           connection.clear_error_reason
         end
       end
 
+      def self.error_from_state_change(current_transition)
+        # ConnectionStateChange object is always passed in current_transition metadata object
+        connection_state_change = current_transition.metadata
+        # Reason attribute contains errors
+        err = connection_state_change && connection_state_change.reason
+        err if is_error_type?(err)
+      end
+
       private
       def connection
         object

data/lib/ably/rest/channel.rb

@@ -34,6 +34,7 @@ module Ably
       #
       # @param name [String, Array<Ably::Models::Message|Hash>, 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
       # @param data [String, ByteArray, nil]   The message payload unless an Array of [Ably::Model::Message] objects passed in the first argument
+      # @param attributes [Hash, nil]   Optional additional message attributes such as :client_id or :connection_id, applied when name attribute is nil or a string
       # @return [Boolean]  true if the message was published, otherwise false
       #
       # @example
@@ -54,13 +55,13 @@ module Ably
       #   ]
       #   channel.publish messages
       #
-      def publish(name, data = nil)
+      def publish(name, data = nil, attributes = {})
         messages = if name.kind_of?(Enumerable)
           name
         else
           ensure_utf_8 :name, name, allow_nil: true
           ensure_supported_payload data
-          [{ name: name, data: data }]
+          [{ name: name, data: data }.merge(attributes)]
         end
 
         payload = messages.map do |message|

data/lib/ably/util/crypto.rb

@@ -37,6 +37,21 @@ module Ably::Util
       @options = DEFAULTS.merge(options).freeze
     end
 
+    # Obtain a default CipherParams. This uses default algorithm, mode and
+    # padding and key length. A key and IV are generated using the default
+    # system SecureRandom; the key may be obtained from the returned CipherParams
+    # for out-of-band distribution to other clients.
+    #
+    # @return [Hash]   CipherParam options Hash with attributes :key, :algorithn, :mode, :key_length
+    #
+    def self.get_default_params(key = nil)
+      params = DEFAULTS.merge(key: key)
+      params[:key_length] = key.unpack('b*').first.length if params[:key]
+      cipher_type = "#{params[:algorithm]}-#{params[:key_length]}-#{params[:mode]}"
+      params[:key] = OpenSSL::Cipher.new(cipher_type.upcase).random_key unless params[:key]
+      params
+    end
+
     # Encrypt payload using configured Cipher
     #
     # @param [String] payload           the payload to be encrypted

data/lib/ably/version.rb

@@ -1,3 +1,3 @@
 module Ably
-  VERSION = '0.8.3'
+  VERSION = '0.8.4'
 end

data/spec/acceptance/realtime/channel_spec.rb

@@ -92,7 +92,7 @@ describe Ably::Realtime::Channel, :event_machine do
 
         it 'reattaches' do
           channel.attach do
-            channel.transition_state_machine :failed, RuntimeError.new
+            channel.transition_state_machine :failed, reason: RuntimeError.new
             expect(channel).to be_failed
             channel.attach do
               expect(channel).to be_attached
@@ -154,9 +154,9 @@ describe Ably::Realtime::Channel, :event_machine do
 
         it 'emits failed event' do
           restricted_channel.attach
-          restricted_channel.on(:failed) do |error|
+          restricted_channel.on(:failed) do |connection_state|
             expect(restricted_channel.state).to eq(:failed)
-            expect(error.status).to eq(401)
+            expect(connection_state.reason.status).to eq(401)
             stop_reactor
           end
         end
@@ -262,7 +262,7 @@ describe Ably::Realtime::Channel, :event_machine do
 
         it 'raises an exception' do
           channel.attach do
-            channel.transition_state_machine :failed, RuntimeError.new
+            channel.transition_state_machine :failed, reason: RuntimeError.new
             expect(channel).to be_failed
             expect { channel.detach }.to raise_error Ably::Exceptions::InvalidStateChange
             stop_reactor
@@ -433,6 +433,19 @@ describe Ably::Realtime::Channel, :event_machine do
             end
           end
         end
+
+        context 'and additional attributes' do
+          let(:client_id) { random_str }
+
+          it 'publishes the message with the attributes and return true indicating success' do
+            channel.publish(name, data, client_id: client_id) do
+              channel.history do |page|
+                expect(page.items.first.client_id).to eql(client_id)
+                stop_reactor
+              end
+            end
+          end
+        end
       end
 
       context 'with an array of Hash objects with :name and :data attributes' do
@@ -666,7 +679,8 @@ describe Ably::Realtime::Channel, :event_machine do
         context 'an :attached channel' do
           it 'transitions state to :failed' do
             channel.attach do
-              channel.on(:failed) do |error|
+              channel.on(:failed) do |connection_state_change|
+                error = connection_state_change.reason
                 expect(error).to be_a(Ably::Exceptions::ConnectionFailed)
                 expect(error.code).to eql(80002)
                 stop_reactor
@@ -688,7 +702,8 @@ describe Ably::Realtime::Channel, :event_machine do
 
           it 'updates the channel error_reason' do
             channel.attach do
-              channel.on(:failed) do |error|
+              channel.on(:failed) do |connection_state_change|
+                error = connection_state_change.reason
                 expect(error).to be_a(Ably::Exceptions::ConnectionFailed)
                 expect(error.code).to eql(80002)
                 stop_reactor
@@ -734,7 +749,7 @@ describe Ably::Realtime::Channel, :event_machine do
                 fake_error connection_error
               end
 
-              channel.transition_state_machine :failed, original_error
+              channel.transition_state_machine :failed, reason: original_error
             end
           end
         end
@@ -783,8 +798,8 @@ describe Ably::Realtime::Channel, :event_machine do
         end
 
         context 'a :failed channel' do
-          let(:original_error) { RuntimeError.new }
           let(:client_options)   { default_options.merge(log_level: :fatal) }
+          let(:original_error) { Ably::Models::ErrorInfo.new(message: 'Error') }
 
           it 'remains in the :failed state and retains the error_reason' do
             channel.attach do
@@ -801,7 +816,7 @@ describe Ably::Realtime::Channel, :event_machine do
                 client.connection.close
               end
 
-              channel.transition_state_machine :failed, original_error
+              channel.transition_state_machine :failed, reason: original_error
             end
           end
         end
@@ -830,6 +845,75 @@ describe Ably::Realtime::Channel, :event_machine do
           end
         end
       end
+
+      context ':suspended' do
+        context 'an :attached channel' do
+          let(:client_options) { default_options.merge(log_level: :fatal) }
+
+          it 'transitions state to :detached' do
+            channel.attach do
+              channel.on(:detached) do
+                stop_reactor
+              end
+              client.connection.transition_state_machine :suspended
+            end
+          end
+        end
+
+        context 'a :detached channel' do
+          it 'remains in the :detached state' do
+            channel.attach do
+              channel.detach do
+                channel.on(:detached) { raise 'Detached state should not have been reached' }
+                channel.on(:error)    { raise 'Error should not have been emitted' }
+
+                EventMachine.add_timer(1) do
+                  expect(channel).to be_detached
+                  stop_reactor
+                end
+
+                client.connection.transition_state_machine :suspended
+              end
+            end
+          end
+        end
+
+        context 'a :failed channel' do
+          let(:original_error) { RuntimeError.new }
+          let(:client_options)   { default_options.merge(log_level: :fatal) }
+
+          it 'remains in the :failed state and retains the error_reason' do
+            channel.attach do
+              channel.once(:error) do
+                channel.on(:detached) { raise 'Detached state should not have been reached' }
+                channel.on(:error)    { raise 'Error should not have been emitted' }
+
+                EventMachine.add_timer(1) do
+                  expect(channel).to be_failed
+                  expect(channel.error_reason).to eql(original_error)
+                  stop_reactor
+                end
+
+                client.connection.transition_state_machine :suspended
+              end
+
+              channel.transition_state_machine :failed, reason: original_error
+            end
+          end
+        end
+
+        context 'a channel ATTACH request when connection SUSPENDED' do
+          it 'raises an exception' do
+            client.connect do
+              client.connection.once(:suspended) do
+                expect { channel.attach }.to raise_error Ably::Exceptions::InvalidStateChange
+                stop_reactor
+              end
+              client.connection.transition_state_machine :suspended
+            end
+          end
+        end
+      end
     end
 
     describe '#presence' do
@@ -838,5 +922,67 @@ describe Ably::Realtime::Channel, :event_machine do
         stop_reactor
       end
     end
+
+    context 'channel state change' do
+      it 'emits a ChannelStateChange object' do
+        channel.on(:attached) do |channel_state_change|
+          expect(channel_state_change).to be_a(Ably::Models::ChannelStateChange)
+          stop_reactor
+        end
+        channel.attach
+      end
+
+      context 'ChannelStateChange object' do
+        it 'has current state' do
+          channel.on(:attached) do |channel_state_change|
+            expect(channel_state_change.current).to eq(:attached)
+            stop_reactor
+          end
+          channel.attach
+        end
+
+        it 'has a previous state' do
+          channel.on(:attached) do |channel_state_change|
+            expect(channel_state_change.previous).to eq(:attaching)
+            stop_reactor
+          end
+          channel.attach
+        end
+
+        it 'contains a private API protocol_message attribute that is used for special state change events', :api_private do
+          channel.on(:attached) do |channel_state_change|
+            expect(channel_state_change.protocol_message).to be_a(Ably::Models::ProtocolMessage)
+            expect(channel_state_change.reason).to be_nil
+            stop_reactor
+          end
+          channel.attach
+        end
+
+        it 'has an empty reason when there is no error' do
+          channel.on(:detached) do |channel_state_change|
+            expect(channel_state_change.reason).to be_nil
+            stop_reactor
+          end
+          channel.attach do
+            channel.detach
+          end
+        end
+
+        context 'on failure' do
+          let(:client_options) { default_options.merge(log_level: :none) }
+
+          it 'has a reason Error object when there is an error on the channel' do
+            channel.on(:failed) do |channel_state_change|
+              expect(channel_state_change.reason).to be_a(Ably::Exceptions::BaseAblyException)
+              stop_reactor
+            end
+            channel.attach do
+              error = Ably::Exceptions::ConnectionFailed.new('forced failure', 500, 50000)
+              client.connection.manager.error_received_from_server error
+            end
+          end
+        end
+      end
+    end
   end
 end