ably-rest 0.8.9 → 0.8.13

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

@@ -67,9 +67,9 @@ module Ably
       #      token_details #=> Ably::Models::TokenDetails
       #    end
       #
-      def authorise(token_params = {}, auth_options = {}, &success_callback)
+      def authorise(token_params = nil, auth_options = nil, &success_callback)
         async_wrap(success_callback) do
-          auth_sync.authorise(token_params, auth_options)
+          auth_sync.authorise(token_params, auth_options, &method(:upgrade_authentication_block).to_proc)
         end.tap do |deferrable|
           deferrable.errback do |error|
             client.connection.transition_state_machine :failed, reason: error if error.kind_of?(Ably::Exceptions::IncompatibleClientId)
@@ -82,8 +82,8 @@ module Ably
       # @option (see Ably::Auth#authorise)
       # @return [Ably::Models::TokenDetails]
       #
-      def authorise_sync(token_params = {}, auth_options = {})
-        auth_sync.authorise(token_params, auth_options)
+      def authorise_sync(token_params = nil, auth_options = nil)
+        auth_sync.authorise(token_params, auth_options, &method(:upgrade_authentication_block).to_proc)
       end
 
       # def_delegator :auth_sync, :request_token, :request_token_sync
@@ -196,6 +196,24 @@ module Ably
       def client
         @client
       end
+
+      # If authorise is called with true, this block is executed so that it
+      # can perform the authentication upgrade
+      def upgrade_authentication_block(new_token)
+        # This block is called if the authorisation was forced
+        if client.connection.connected? || client.connection.connecting?
+          logger.debug "Realtime::Auth - authorise called with { force: true } so forcibly disconnecting transport to initiate auth upgrade"
+          block = Proc.new do
+            if client.connection.transport
+              logger.debug "Realtime::Auth - current transport disconnected"
+              client.connection.transport.disconnect
+            else
+              EventMachine.add_timer(0.1, &block)
+            end
+          end
+          block.call
+        end
+      end
     end
   end
 end

data/lib/submodules/ably-ruby/lib/ably/realtime/client/incoming_message_dispatcher.rb

@@ -144,7 +144,7 @@ module Ably::Realtime
       end
 
       def process_connection_error(protocol_message)
-        connection.manager.error_received_from_server protocol_message.error
+        connection.manager.error_received_from_server(protocol_message.error || Ably::Models::ErrorInfo.new(message: 'Error reason unknown'))
       end
 
       def process_connected_message(protocol_message)

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

@@ -194,15 +194,15 @@ module Ably
 
       # Sends a ping to Ably and yields the provided block when a heartbeat ping request is echoed from the server.
       # This can be useful for measuring true roundtrip client to Ably server latency for a simple message, or checking that an underlying transport is responding currently.
-      # The elapsed milliseconds is passed as an argument to the block and represents the time taken to echo a ping heartbeat once the connection is in the `:connected` state.
+      # The elapsed time in seconds is passed as an argument to the block and represents the time taken to echo a ping heartbeat once the connection is in the `:connected` state.
       #
-      # @yield [Integer] if a block is passed to this method, then this block will be called once the ping heartbeat is received with the time elapsed in milliseconds.
+      # @yield [Integer] if a block is passed to this method, then this block will be called once the ping heartbeat is received with the time elapsed in seconds.
       #                  If the ping is not received within an acceptable timeframe, the block will be called with +nil+ as he first argument
       #
       # @example
       #    client = Ably::Rest::Client.new(key: 'key.id:secret')
-      #    client.connection.ping do |ms_elapsed|
-      #      puts "Ping took #{ms_elapsed}ms"
+      #    client.connection.ping do |elapsed_s|
+      #      puts "Ping took #{elapsed_s}s"
       #    end
       #
       # @return [void]
@@ -219,7 +219,7 @@ module Ably
           if protocol_message.action == Ably::Models::ProtocolMessage::ACTION.Heartbeat
             finished = true
             __incoming_protocol_msgbus__.unsubscribe(:protocol_message, &wait_for_ping)
-            time_passed = (Time.now.to_f * 1000 - started.to_f * 1000).to_i
+            time_passed = Time.now.to_f - started.to_f
             safe_yield block, time_passed if block_given?
           end
         end
@@ -387,7 +387,9 @@ module Ably
             auth_deferrable.callback do |auth_params|
               url_params = auth_params.merge(
                 format:    client.protocol,
-                echo:      client.echo_messages
+                echo:      client.echo_messages,
+                v:         Ably::PROTOCOL_VERSION,
+                lib:       Ably::LIB_VERSION_ID,
               )
 
               url_params['clientId'] = client.auth.client_id if client.auth.has_client_id?

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

@@ -402,7 +402,7 @@ module Ably::Realtime
           @renewing_token = true
           logger.info "ConnectionManager: Token has expired and is renewable, renewing token now"
 
-          client.auth.authorise({}, force: true).tap do |authorise_deferrable|
+          client.auth.authorise(nil, force: true).tap do |authorise_deferrable|
             authorise_deferrable.callback do |token_details|
               logger.info 'ConnectionManager: Token renewed succesfully following expiration'
 

data/lib/submodules/ably-ruby/lib/ably/rest/client.rb

@@ -120,7 +120,7 @@ module Ably
 
         options = options.clone
         if options.kind_of?(String)
-          options = if options.match(/^[\w]{2,}\.[\w]{2,}:[\w]{2,}$/)
+          options = if options.match(/^[\w-]{2,}\.[\w-]{2,}:[\w-]{2,}$/)
             { key: options }
           else
             { token: options }
@@ -352,6 +352,8 @@ module Ably
             unless options[:send_auth_header] == false
               request.headers[:authorization] = auth.auth_header
             end
+            request.headers['X-Ably-Version'] = Ably::PROTOCOL_VERSION
+            request.headers['X-Ably-Lib'] = Ably::LIB_VERSION_ID
           end
 
         rescue Faraday::TimeoutError, Faraday::ClientError, Ably::Exceptions::ServerError => error
@@ -376,7 +378,7 @@ module Ably
         yield
       rescue Ably::Exceptions::TokenExpired => e
         if auth.token_renewable?
-          auth.authorise({}, force: true)
+          auth.authorise(nil, force: true)
           yield
         else
           raise e

data/lib/submodules/ably-ruby/lib/ably/version.rb

@@ -1,3 +1,5 @@
 module Ably
-  VERSION = '0.8.9'
+  VERSION = '0.8.13'
+  PROTOCOL_VERSION = '0.8'
+  LIB_VERSION_ID = "ruby-#{Ably::VERSION}"
 end

data/lib/submodules/ably-ruby/spec/acceptance/realtime/auth_spec.rb

@@ -254,6 +254,195 @@ describe Ably::Realtime::Auth, :event_machine do
             end
           end
         end
+
+        context 'with force: true to trigger an authentication upgrade' do
+          let(:rest_client)      { Ably::Rest::Client.new(default_options) }
+          let(:client_publisher) { auto_close Ably::Realtime::Client.new(default_options) }
+          let(:basic_capability) { JSON.dump("foo" => ["subscribe"]) }
+          let(:basic_token_cb)   { Proc.new do
+            rest_client.auth.create_token_request({ capability: basic_capability })
+          end }
+          let(:upgraded_capability) { JSON.dump({ "foo" => ["subscribe", "publish"] }) }
+          let(:upgraded_token_cb)   { Proc.new do
+            rest_client.auth.create_token_request({ capability: upgraded_capability })
+          end }
+          let(:identified_token_cb) { Proc.new do
+            rest_client.auth.create_token_request({ client_id: 'bob' })
+          end }
+          let(:downgraded_capability) { JSON.dump({ "bar" => ["subscribe"] }) }
+          let(:downgraded_token_cb)   { Proc.new do
+            rest_client.auth.create_token_request({ capability: downgraded_capability })
+          end }
+
+          let(:client_options) { default_options.merge(auth_callback: basic_token_cb) }
+
+          it 'forces the connection to disconnect and reconnect with a new token when in the CONNECTED state' do
+            client.connection.once(:connected) do
+              existing_token = client.auth.current_token_details
+              client.auth.authorise(nil, force: true)
+              client.connection.once(:disconnected) do
+                client.connection.once(:connected) do
+                  expect(existing_token).to_not eql(client.auth.current_token_details)
+                  stop_reactor
+                end
+              end
+            end
+          end
+
+          it 'forces the connection to disconnect and reconnect with a new token when in the CONNECTING state' do
+            client.connection.once(:connecting) do
+              existing_token = client.auth.current_token_details
+              client.auth.authorise(nil, force: true)
+              client.connection.once(:disconnected) do
+                client.connection.once(:connected) do
+                  expect(existing_token).to_not eql(client.auth.current_token_details)
+                  stop_reactor
+                end
+              end
+            end
+          end
+
+          context 'when client is identified' do
+            let(:client_options) { default_options.merge(auth_callback: basic_token_cb, log_level: :none) }
+
+            let(:basic_token_cb)   { Proc.new do
+              rest_client.auth.create_token_request({ client_id: 'mike', capability: basic_capability })
+            end }
+
+            it 'transisitions the connection state to FAILED if the client_id changes' do
+              client.connection.once(:connected) do
+                client.auth.authorise(nil, auth_callback: identified_token_cb, force: true)
+                client.connection.once(:failed) do
+                  expect(client.connection.error_reason.message).to match(/incompatible.*client ID/)
+                  stop_reactor
+                end
+              end
+            end
+          end
+
+          context 'when upgrading capabilities' do
+            let(:client_options) { default_options.merge(auth_callback: basic_token_cb, log_level: :error) }
+
+            it 'is allowed' do
+              client.connection.once(:connected) do
+                channel = client.channels.get('foo')
+                channel.publish('not-allowed').errback do |error|
+                  expect(error.code).to eql(40160)
+                  expect(error.message).to match(/permission denied/)
+                  client.auth.authorise(nil, auth_callback: upgraded_token_cb, force: true)
+                  client.connection.once(:connected) do
+                    expect(client.connection.error_reason).to be_nil
+                    channel.subscribe('allowed') do |message|
+                      stop_reactor
+                    end
+                    channel.publish 'allowed'
+                  end
+                end
+              end
+            end
+          end
+
+          context 'when downgrading capabilities' do
+            let(:client_options) { default_options.merge(auth_callback: basic_token_cb, log_level: :none) }
+
+            it 'is allowed and channels are detached' do
+              client.connection.once(:connected) do
+                channel = client.channels.get('foo')
+                channel.attach do
+                  client.auth.authorise(nil, auth_callback: downgraded_token_cb, force: true)
+                  channel.once(:failed) do
+                    expect(channel.error_reason.code).to eql(40160)
+                    expect(channel.error_reason.message).to match(/Channel denied access/)
+                    stop_reactor
+                  end
+                end
+              end
+            end
+          end
+
+          it 'ensures message delivery continuity whilst upgrading' do
+            received_messages = []
+            subscriber_channel = client.channels.get('foo')
+            publisher_channel  = client_publisher.channels.get('foo')
+            subscriber_channel.attach do
+              subscriber_channel.subscribe do |message|
+                received_messages << message
+              end
+              publisher_channel.attach do
+                publisher_channel.publish('foo') do
+                  EventMachine.add_timer(2) do
+                    expect(received_messages.length).to eql(1)
+                    client.auth.authorise(nil, force: true)
+                    client.connection.once(:disconnected) do
+                      publisher_channel.publish('bar') do
+                        expect(received_messages.length).to eql(1)
+                      end
+                    end
+                    client.connection.once(:connected) do
+                      EventMachine.add_timer(2) do
+                        expect(received_messages.length).to eql(2)
+                        stop_reactor
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          it 'does not change the connection state if current connection state is closing' do
+            client.connection.once(:connected) do
+              client.connection.once(:closing) do
+                client.auth.authorise(nil, force: true)
+                client.connection.once(:connected) do
+                  raise "Should not reconnect following auth force: true"
+                end
+                EventMachine.add_timer(4) do
+                  expect(client.connection).to be_closed
+                  stop_reactor
+                end
+              end
+              client.connection.close
+            end
+          end
+
+          it 'does not change the connection state if current connection state is closed' do
+            client.connection.once(:connected) do
+              client.connection.once(:closed) do
+                client.auth.authorise(nil, force: true)
+                client.connection.once(:connected) do
+                  raise "Should not reconnect following auth force: true"
+                end
+                EventMachine.add_timer(4) do
+                  expect(client.connection).to be_closed
+                  stop_reactor
+                end
+              end
+              client.connection.close
+            end
+          end
+
+          context 'when state is failed' do
+            let(:client_options) { default_options.merge(auth_callback: basic_token_cb, log_level: :none) }
+
+            it 'does not change the connection state' do
+              client.connection.once(:connected) do
+                client.connection.once(:failed) do
+                  client.auth.authorise(nil, force: true)
+                  client.connection.once(:connected) do
+                    raise "Should not reconnect following auth force: true"
+                  end
+                  EventMachine.add_timer(4) do
+                    expect(client.connection).to be_failed
+                    stop_reactor
+                  end
+                end
+                protocol_message = Ably::Models::ProtocolMessage.new(action: Ably::Models::ProtocolMessage::ACTION.Error.to_i)
+                client.connection.__incoming_protocol_msgbus__.publish :protocol_message, protocol_message
+              end
+            end
+          end
+        end
       end
 
       context '#authorise_async' do

data/lib/submodules/ably-ruby/spec/acceptance/realtime/channel_spec.rb

@@ -908,6 +908,25 @@ describe Ably::Realtime::Channel, :event_machine do
         end
       end
 
+      context 'with a callback that raises an exception' do
+        let(:exception) { StandardError.new("Intentional error") }
+
+        it 'logs the error and continues' do
+          emitted_exception = false
+          expect(client.logger).to receive(:error).with(/#{exception.message}/)
+          channel.subscribe('click') do |message|
+            emitted_exception = true
+            raise exception
+          end
+          channel.publish('click', 'data') do
+            EventMachine.add_timer(1) do
+              expect(emitted_exception).to eql(true)
+              stop_reactor
+            end
+          end
+        end
+      end
+
       context 'many times with different event names' do
         it 'filters events accordingly to each callback' do
           click_callback = proc { |message| messages << message }

data/lib/submodules/ably-ruby/spec/acceptance/realtime/connection_spec.rb

@@ -1356,5 +1356,25 @@ describe Ably::Realtime::Connection, :event_machine do
         end
       end
     end
+
+    context 'version params' do
+      it 'sends the protocol version param v' do
+        expect(EventMachine).to receive(:connect) do |host, port, transport, object, url|
+          uri = URI.parse(url)
+          expect(CGI::parse(uri.query)['v'][0]).to eql(Ably::PROTOCOL_VERSION)
+          stop_reactor
+        end
+        client
+      end
+
+      it 'sends the lib version param lib' do
+        expect(EventMachine).to receive(:connect) do |host, port, transport, object, url|
+          uri = URI.parse(url)
+          expect(CGI::parse(uri.query)['lib'][0]).to eql("ruby-#{Ably::VERSION}")
+          stop_reactor
+        end
+        client
+      end
+    end
   end
 end

data/lib/submodules/ably-ruby/spec/acceptance/realtime/message_spec.rb

@@ -483,11 +483,13 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
           payload_description = "#{payload.class}#{" #{payload.encoding}" if payload.kind_of?(String)}"
 
           it "delivers a #{payload_description} payload to the receiver" do
-            encrypted_channel_client1.publish 'example', payload
-            encrypted_channel_client2.subscribe do |message|
-              expect(message.data).to eql(payload)
-              expect(message.encoding).to be_nil
-              stop_reactor
+            encrypted_channel_client2.attach do
+              encrypted_channel_client1.publish 'example', payload
+              encrypted_channel_client2.subscribe do |message|
+                expect(message.data).to eql(payload)
+                expect(message.encoding).to be_nil
+                stop_reactor
+              end
             end
           end
         end
@@ -520,11 +522,13 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
         let(:payload) { MessagePack.pack({ 'key' => random_str }) }
 
         it 'delivers the message but still encrypted with a value in the #encoding attribute' do
-          encrypted_channel_client1.publish 'example', payload
-          unencrypted_channel_client2.subscribe do |message|
-            expect(message.data).to_not eql(payload)
-            expect(message.encoding).to match(/^cipher\+aes-256-cbc/)
-            stop_reactor
+          unencrypted_channel_client2.attach do
+            encrypted_channel_client1.publish 'example', payload
+            unencrypted_channel_client2.subscribe do |message|
+              expect(message.data).to_not eql(payload)
+              expect(message.encoding).to match(/^cipher\+aes-256-cbc/)
+              stop_reactor
+            end
           end
         end
 
@@ -732,4 +736,122 @@ describe 'Ably::Realtime::Channel Message', :event_machine do
       end
     end
   end
+
+  context 'message encoding interoperability' do
+    let(:client_options)  { { key: api_key, environment: environment, protocol: :json } }
+    let(:channel_name) { "subscribe_send_text-#{random_str}" }
+
+    fixtures_path = File.expand_path('../../../../lib/submodules/ably-common/test-resources/messages-encoding.json', __FILE__)
+
+    context 'over a JSON transport' do
+      let(:realtime_client) do
+        auto_close Ably::Realtime::Client.new(client_options)
+      end
+      let(:rest_client) do
+        Ably::Rest::Client.new(client_options)
+      end
+      let(:realtime_channel) { realtime_client.channels.get(channel_name) }
+
+      JSON.parse(File.read(fixtures_path))['messages'].each do |encoding_spec|
+        context "when decoding #{encoding_spec['expectedType']}" do
+          it 'ensures that client libraries have compatible encoding and decoding using common fixtures' do
+            realtime_channel.attach do
+              realtime_channel.subscribe do |message|
+                if encoding_spec['expectedHexValue']
+                  expect(message.data.unpack('H*').first).to eql(encoding_spec['expectedHexValue'])
+                else
+                  expect(message.data).to eql(encoding_spec['expectedValue'])
+                end
+                stop_reactor
+              end
+
+              raw_message = { "data" => encoding_spec['data'], "encoding" => encoding_spec['encoding'] }
+              rest_client.post("/channels/#{channel_name}/messages", JSON.dump(raw_message))
+            end
+          end
+        end
+
+        context "when encoding #{encoding_spec['expectedType']}" do
+          it 'ensures that client libraries have compatible encoding and decoding using common fixtures' do
+            data = if encoding_spec['expectedHexValue']
+              encoding_spec['expectedHexValue'].scan(/../).map { |x| x.hex }.pack('c*')
+            else
+              encoding_spec['expectedValue']
+            end
+
+            realtime_channel.publish("event", data) do
+              response = rest_client.get("/channels/#{channel_name}/messages")
+              message = response.body[0]
+              expect(message['encoding']).to eql(encoding_spec['encoding'])
+              if message['encoding'] == 'json'
+                expect(JSON.parse(encoding_spec['data'])).to eql(JSON.parse(message['data']))
+              else
+                expect(encoding_spec['data']).to eql(message['data'])
+              end
+              stop_reactor
+            end
+          end
+        end
+      end
+    end
+
+    context 'over a MsgPack transport' do
+      JSON.parse(File.read(fixtures_path))['messages'].each do |encoding_spec|
+        context "when publishing a #{encoding_spec['expectedType']} using JSON protocol" do
+          let(:rest_publish_client) do
+            Ably::Rest::Client.new(client_options.merge(protocol: :json))
+          end
+          let(:realtime_subscribe_client) do
+            Ably::Realtime::Client.new(client_options.merge(protocol: :msgpack))
+          end
+          let(:realtime_subscribe_channel) { realtime_subscribe_client.channels.get(channel_name) }
+
+          it 'receives the message over MsgPack and the data matches' do
+            expect(realtime_subscribe_client).to be_protocol_binary
+
+            realtime_subscribe_channel.attach do
+              realtime_subscribe_channel.subscribe do |message|
+                if encoding_spec['expectedHexValue']
+                  expect(message.data.unpack('H*').first).to eql(encoding_spec['expectedHexValue'])
+                else
+                  expect(message.data).to eql(encoding_spec['expectedValue'])
+                end
+                stop_reactor
+              end
+
+              raw_message = { "data" => encoding_spec['data'], "encoding" => encoding_spec['encoding'] }
+              rest_publish_client.post("/channels/#{channel_name}/messages", JSON.dump(raw_message))
+            end
+          end
+        end
+
+        context "when retrieving a #{encoding_spec['expectedType']} using JSON protocol" do
+          let(:rest_publish_client) do
+            Ably::Rest::Client.new(client_options.merge(protocol: :msgpack))
+          end
+          let(:rest_retrieve_client) do
+            Ably::Rest::Client.new(client_options.merge(protocol: :json))
+          end
+          let(:rest_publish_channel) { rest_publish_client.channels.get(channel_name) }
+
+          it 'is compatible with a publishes using MsgPack' do
+            expect(rest_publish_client).to be_protocol_binary
+
+            data = if encoding_spec['expectedHexValue']
+              encoding_spec['expectedHexValue'].scan(/../).map { |x| x.hex }.pack('c*')
+            else
+              encoding_spec['expectedValue']
+            end
+            rest_publish_channel.publish "event", data
+
+            response = rest_retrieve_client.get("/channels/#{channel_name}/messages")
+            message = response.body[0]
+            expect(message['encoding']).to eql(encoding_spec['encoding'])
+            expect(encoding_spec['data']).to eql(message['data'])
+            stop_reactor
+          end
+        end
+      end
+    end
+  end
 end