ably 1.1.1 → 1.1.5

data/lib/ably/realtime/presence.rb

@@ -278,28 +278,14 @@ module Ably::Realtime
 
     # Return the presence messages history for the channel
     #
-    # Once attached to a channel, you can retrieve presence message history on the channel before the
-    # channel was attached with the option <tt>until_attach: true</tt>.  This is very useful for
-    # developers who wish to capture new presence events as well as retrieve historical presence state with
-    # the guarantee that no presence history has been missed.
-    #
     # @param (see Ably::Rest::Presence#history)
     # @option options (see Ably::Rest::Presence#history)
-    # @option options [Boolean]  :until_attach  When true, request for history will be limited only to messages published before the associated channel was attached. The associated channel must be attached.
     #
     # @yield [Ably::Models::PaginatedResult<Ably::Models::PresenceMessage>] First {Ably::Models::PaginatedResult page} of {Ably::Models::PresenceMessage} objects accessible with {Ably::Models::PaginatedResult#items #items}.
     #
     # @return [Ably::Util::SafeDeferrable]
     #
     def history(options = {}, &callback)
-      if options.delete(:until_attach)
-        unless channel.attached?
-          error = Ably::Exceptions::InvalidRequest.new('option :until_attach is invalid as the channel is not attached')
-          return Ably::Util::SafeDeferrable.new_and_fail_immediately(logger, error)
-        end
-        options[:from_serial] = channel.attached_serial
-      end
-
       async_wrap(callback) do
         rest_presence.history(options.merge(async_blocking_operations: true))
       end

data/lib/ably/rest/channel.rb

@@ -40,15 +40,14 @@ module Ably
         @push    = PushChannel.new(self)
       end
 
-      # Publish one or more messages to the channel.
-      #
-      # @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 :extras, :id, :client_id or :connection_id, applied when name attribute is nil or a string
+      # Publish one or more messages to the channel. Three overloaded forms
+      # @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, ByteArray, 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
+      #   # Publish a single message with (name, data) form
       #   channel.publish 'click', { x: 1, y: 2 }
       #
       #   # Publish an array of message Hashes
@@ -65,17 +64,25 @@ module Ably
       #   ]
       #   channel.publish messages
       #
-      def publish(name, data = nil, attributes = {})
-        messages = if name.kind_of?(Enumerable)
-          name
+      #   # Publish a single Ably::Models::Message object, with a query params
+      #   # specifying quickAck: true
+      #   message = Ably::Models::Message(name: 'click', { x: 1, y: 2 })
+      #   channel.publish message, quickAck: 'true'
+      #
+      def publish(first, second = nil, third = {})
+        messages, qs_params = if first.kind_of?(Enumerable)
+          # ([Message], qs_params) form
+          [first, second]
+        elsif first.kind_of?(Ably::Models::Message)
+          # (Message, qs_params) form
+          [[first], second]
         else
-          if name.kind_of?(Ably::Models::Message)
-            raise ArgumentError, "name argument does not support single Message objects, only arrays of Message objects"
-          end
-
-          name = ensure_utf_8(:name, name, allow_nil: true)
-          ensure_supported_payload data
-          [{ name: name, data: data }.merge(attributes)]
+          # (name, data, attributes) form
+          first = ensure_utf_8(:name, first, allow_nil: true)
+          ensure_supported_payload second
+          # RSL1h - attributes as an extra method parameter is extra-spec but need to
+          # keep it for backcompat until version 2
+          [[{ name: first, data: second }.merge(third)], nil]
         end
 
         payload = messages.each_with_index.map do |message, index|
@@ -103,7 +110,8 @@ module Ably
           end
         end
 
-        response = client.post("#{base_path}/publish", payload.length == 1 ? payload.first : payload)
+        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

data/lib/ably/rest/client.rb

@@ -3,6 +3,9 @@ require 'json'
 require 'logger'
 require 'uri'
 
+require 'typhoeus'
+require 'typhoeus/adapters/faraday'
+
 require 'ably/rest/middleware/exceptions'
 
 module Ably
@@ -32,6 +35,13 @@ module Ably
 
       FALLBACK_RETRY_TIMEOUT = 10 * 60
 
+      # Faraday 1.0 introduced new error types, however we want to support Faraday <1 too which only used Faraday::ClientError
+      FARADAY_CLIENT_OR_SERVER_ERRORS = if defined?(Faraday::ParsingError)
+        [Faraday::ClientError, Faraday::ServerError, Faraday::ConnectionFailed, Faraday::SSLError, Faraday::ParsingError]
+      else
+        Faraday::ClientError
+      end
+
       def_delegators :auth, :client_id, :auth_options
 
       # Custom environment to use such as 'sandbox' when testing the client library against an alternate Ably environment
@@ -174,16 +184,18 @@ module Ably
         @idempotent_rest_publishing = options.delete(:idempotent_rest_publishing) || Ably.major_minor_version_numeric > 1.1
 
 
-        if options[:fallback_hosts_use_default] && options[:fallback_jhosts]
-          raise ArgumentError, "fallback_hosts_use_default cannot be set to trye when fallback_jhosts is also provided"
+        if options[:fallback_hosts_use_default] && options[:fallback_hosts]
+          raise ArgumentError, "fallback_hosts_use_default cannot be set to try when fallback_hosts is also provided"
         end
         @fallback_hosts = case
         when options.delete(:fallback_hosts_use_default)
           Ably::FALLBACK_HOSTS
         when options_fallback_hosts = options.delete(:fallback_hosts)
           options_fallback_hosts
-        when environment || custom_host || options[:realtime_host] || custom_port || custom_tls_port
+        when custom_host || options[:realtime_host] || custom_port || custom_tls_port
           []
+        when environment
+          CUSTOM_ENVIRONMENT_FALLBACKS_SUFFIXES.map { |host| "#{environment}#{host}" }
         else
           Ably::FALLBACK_HOSTS
         end
@@ -195,6 +207,8 @@ module Ably
         @http_defaults = HTTP_DEFAULTS.dup
         options.each do |key, val|
           if http_key = key[/^http_(.+)/, 1]
+            # Typhoeus converts decimal durations to milliseconds, so 0.0001 timeout is treated as 0 (no timeout)
+            val = 0.001 if val.kind_of?(Numeric) && (val > 0) && (val < 0.001)
             @http_defaults[http_key.to_sym] = val if val && @http_defaults.has_key?(http_key.to_sym)
           end
         end
@@ -336,14 +350,14 @@ module Ably
       #
       # @return [Ably::Models::HttpPaginatedResponse<>]
       def request(method, path, params = {}, body = nil, headers = {}, options = {})
-        raise "Method #{method.to_s.upcase} not supported" unless [:get, :put, :post].include?(method.to_sym)
+        raise "Method #{method.to_s.upcase} not supported" unless %i(get put patch post delete).include?(method.to_sym)
 
         response = case method.to_sym
-        when :get
+        when :get, :delete
           reauthorize_on_authorization_failure do
             send_request(method, path, params, headers: headers)
           end
-        when :post
+        when :post, :patch, :put
           path_with_params = Addressable::URI.new
           path_with_params.query_values = params || {}
           query = path_with_params.query
@@ -471,11 +485,13 @@ module Ably
 
       # Allowable duration for an external auth request
       # For REST client this defaults to request_timeout
-      # For Realtime clients this defaults to realtime_request_timeout
+      # For Realtime clients this defaults to 250ms less than the realtime_request_timeout
+      #   ensuring an auth failure will be triggered before the realtime request timeout fires
+      #   which would lead to a misleading error message (connection timeout as opposed to auth request timeout)
       # @api private
       def auth_request_timeout
         if @realtime_client
-          @realtime_client.connection.defaults.fetch(:realtime_request_timeout)
+          @realtime_client.connection.defaults.fetch(:realtime_request_timeout) - 0.25
         else
           http_defaults.fetch(:request_timeout)
         end
@@ -557,12 +573,14 @@ module Ably
               request.options.context = {} if request.options.context.nil?
               request.options.context[:request_id] = request_id
             end
+            if options[:qs_params]
+              request.params.merge!(options[:qs_params])
+            end
             unless options[:send_auth_header] == false
               request.headers[:authorization] = auth.auth_header
-              if options[:headers]
-                options[:headers].map do |key, val|
-                  request.headers[key] = val
-                end
+
+              options[:headers].to_h.merge(auth.extra_auth_headers).map do |key, val|
+                request.headers[key] = val
               end
             end
           end.tap do
@@ -576,7 +594,7 @@ module Ably
             end
           end
 
-        rescue Faraday::TimeoutError, Faraday::ClientError, Ably::Exceptions::ServerError => error
+        rescue *([Faraday::TimeoutError, Ably::Exceptions::ServerError] + FARADAY_CLIENT_OR_SERVER_ERRORS) => error
           retry_sequence_id ||= SecureRandom.urlsafe_base64(4)
           time_passed = Time.now - requested_at
 
@@ -596,7 +614,7 @@ module Ably
           case error
             when Faraday::TimeoutError
               raise Ably::Exceptions::ConnectionTimeout.new(error.message, nil, Ably::Exceptions::Codes::CONNECTION_TIMED_OUT, error, { request_id: request_id })
-            when Faraday::ClientError
+            when *FARADAY_CLIENT_OR_SERVER_ERRORS
               # request_id is also available in the request context
               raise Ably::Exceptions::ConnectionError.new(error.message, nil, Ably::Exceptions::Codes::CONNECTION_FAILED, error, { request_id: request_id })
             else
@@ -654,7 +672,7 @@ module Ably
         }
       end
 
-      # Return a Faraday middleware stack to initiate the Faraday::Connection with
+      # Return a Faraday middleware stack to initiate the Faraday::RackBuilder with
       #
       # @see http://mislav.uniqpath.com/2011/07/faraday-advanced-http/
       def middleware
@@ -666,8 +684,8 @@ module Ably
 
           setup_incoming_middleware builder, logger, fail_if_unsupported_mime_type: true
 
-          # Set Faraday's HTTP adapter
-          builder.adapter :excon
+          # Set Faraday's HTTP adapter with support for HTTP/2
+          builder.adapter :typhoeus, http_version: :httpv2_0
         end
       end
 

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

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

data/lib/ably/version.rb

@@ -1,5 +1,5 @@
 module Ably
-  VERSION = '1.1.1'
+  VERSION = '1.1.5'
   PROTOCOL_VERSION = '1.1'
 
   # Allow a variant to be configured for all instances of this client library

data/spec/acceptance/realtime/auth_spec.rb

@@ -1058,7 +1058,7 @@ describe Ably::Realtime::Auth, :event_machine do
 
           it 'disconnected includes and invalid signature message' do
             client.connection.once(:disconnected) do |state_change|
-              expect(state_change.reason.message.match(/invalid signature/i)).to_not be_nil
+              expect(state_change.reason.message.match(/signature verification failed/i)).to_not be_nil
               expect(state_change.reason.code).to eql(40144)
               stop_reactor
             end
@@ -1111,7 +1111,7 @@ describe Ably::Realtime::Auth, :event_machine do
 
           it 'authentication fails and reason for disconnection is invalid signature' do
             client.connection.once(:disconnected) do |state_change|
-              expect(state_change.reason.message.match(/invalid signature/i)).to_not be_nil
+              expect(state_change.reason.message.match(/signature verification failed/i)).to_not be_nil
               expect(state_change.reason.code).to eql(40144)
               stop_reactor
             end
@@ -1139,10 +1139,11 @@ describe Ably::Realtime::Auth, :event_machine do
         context 'when credentials are invalid' do
           let(:key_secret) { 'invalid' }
           let(:token) { Faraday.get("#{auth_url}?keyName=#{key_name}&keySecret=#{key_secret}").body }
+          let(:client_options) { { token: token, environment: environment, protocol: protocol, log_level: :none } }
 
           it 'fails with an invalid signature error' do
             client.connection.once(:disconnected) do |state_change|
-              expect(state_change.reason.message.match(/invalid signature/i)).to_not be_nil
+              expect(state_change.reason.message.match(/signature verification failed/i)).to_not be_nil
               expect(state_change.reason.code).to eql(40144)
               stop_reactor
             end
@@ -1239,7 +1240,7 @@ describe Ably::Realtime::Auth, :event_machine do
             Faraday.get("#{auth_url}?keyName=#{key_name}&keySecret=#{key_secret}&capability=#{URI.escape(basic_capability)}").body
           end
         end
-        let(:client_options) { default_options.merge(auth_callback: auth_callback) }
+        let(:client_options) { default_options.merge(auth_callback: auth_callback, log_level: :error) }
 
         it 'client fails to publish to a channel with subscribe-only capability and publishes successfully on a channel with permissions' do
           client.connection.once(:connected) do

data/spec/acceptance/realtime/channel_spec.rb

@@ -83,6 +83,16 @@ describe Ably::Realtime::Channel, :event_machine do
           end
         end
 
+        it 'sets attach_serial property after the attachment (#RTL15a)' do
+          expect(channel.properties.attach_serial).to be_nil
+
+          channel.attach
+          channel.on(:attached) do
+            expect(channel.properties.attach_serial).to_not be_nil
+            stop_reactor
+          end
+        end
+
         it 'sends an ATTACH and waits for an ATTACHED (#RTL4c)' do
           connection.once(:connected) do
             attach_count = 0
@@ -279,8 +289,7 @@ describe Ably::Realtime::Channel, :event_machine do
             key: restricted_api_key,
             log_level: :fatal,
             use_token_auth: true,
-            # TODO: Use wildcard / default when intersection issue resolved, realtime#780
-            default_token_params: { capability: { "canpublish:foo" => ["publish"] } }
+            default_token_params: { capability: { "canpublish:foo" => ["*"] } }
           )
         end
         let(:restricted_client) do
@@ -1009,9 +1018,6 @@ describe Ably::Realtime::Channel, :event_machine do
 
             it 'publishes the message without a name attribute in the payload' do
               published = false
-              channel.publish(nil, data) do
-                published = true
-              end
 
               channel.subscribe do |message|
                 expect(message.name).to be_nil
@@ -1024,6 +1030,10 @@ describe Ably::Realtime::Channel, :event_machine do
                   end
                 end
               end
+
+              channel.publish(nil, data) do
+                published = true
+              end
             end
           end
 
@@ -1032,9 +1042,6 @@ describe Ably::Realtime::Channel, :event_machine do
 
             it 'publishes the message without a data attribute in the payload' do
               published = false
-              channel.publish(name, nil) do
-                published = true
-              end
 
               channel.subscribe do |message|
                 expect(message.data).to be_nil
@@ -1047,6 +1054,10 @@ describe Ably::Realtime::Channel, :event_machine do
                   end
                 end
               end
+
+              channel.publish(name, nil) do
+                published = true
+              end
             end
           end
 
@@ -1997,6 +2008,8 @@ describe Ably::Realtime::Channel, :event_machine do
         end
 
         context '#resume (#RTL2f)' do
+          let(:client_options) { default_options.merge(log_level: :fatal) }
+
           it 'is false when a channel first attaches' do
             channel.attach
             channel.on(:attached) do |channel_state_change|

data/spec/acceptance/realtime/client_spec.rb

@@ -87,22 +87,6 @@ describe Ably::Realtime::Client, :event_machine do
                 end
               end
             end
-
-            context 'with client_id' do
-              let(:client_options) do
-                default_options.merge(client_id: random_str)
-              end
-              it 'connects using token auth' do
-                run_reactor do
-                  connection.on(:connected) do
-                    expect(connection.state).to eq(:connected)
-                    expect(auth_params[:access_token]).to_not be_nil
-                    expect(auth_params[:key]).to be_nil
-                    stop_reactor
-                  end
-                end
-              end
-            end
           end
         end
 
@@ -249,6 +233,8 @@ describe Ably::Realtime::Client, :event_machine do
 
     context '#request (#RSC19*)' do
       let(:client_options) { default_options.merge(key: api_key) }
+      let(:device_id) { random_str }
+      let(:endpoint) { subject.rest_client.endpoint }
 
       context 'get' do
         it 'returns an HttpPaginatedResponse object' do
@@ -297,6 +283,76 @@ describe Ably::Realtime::Client, :event_machine do
           end
         end
       end
+
+
+      context 'post', :webmock do
+        before do
+          stub_request(:delete, "#{endpoint}/push/deviceRegistrations/#{device_id}/resetUpdateToken").
+            to_return(status: 200, body: '{}', headers: { 'Content-Type' => 'application/json' })
+        end
+
+        it 'supports post' do
+          subject.request(:delete, "push/deviceRegistrations/#{device_id}/resetUpdateToken").callback do |response|
+            expect(response).to be_success
+            stop_reactor
+          end
+        end
+      end
+
+      context 'delete', :webmock do
+        before do
+          stub_request(:delete, "#{endpoint}/push/channelSubscriptions?deviceId=#{device_id}").
+            to_return(status: 200, body: '{}', headers: { 'Content-Type' => 'application/json' })
+        end
+
+        it 'supports delete' do
+          subject.request(:delete, "/push/channelSubscriptions", { deviceId: device_id}).callback do |response|
+            expect(response).to be_success
+            stop_reactor
+          end
+        end
+      end
+
+      context 'patch', :webmock do
+        let(:body_params) { { 'metadata' => { 'key' => 'value' } } }
+
+        before do
+          stub_request(:patch, "#{endpoint}/push/deviceRegistrations/#{device_id}")
+            .with(body: serialize_body(body_params, protocol))
+            .to_return(status: 200, body: '{}', headers: { 'Content-Type' => 'application/json' })
+        end
+
+        it 'supports patch' do
+          subject.request(:patch, "/push/deviceRegistrations/#{device_id}", {}, body_params).callback do |response|
+            expect(response).to be_success
+            stop_reactor
+          end
+        end
+      end
+
+      context 'put', :webmock do
+        let(:body_params) do
+          {
+            'id' => random_str,
+            'platform' => 'ios',
+            'formFactor' => 'phone',
+            'metadata' => { 'key' => 'value' }
+          }
+        end
+
+        before do
+          stub_request(:put, "#{endpoint}/push/deviceRegistrations/#{device_id}")
+            .with(body: serialize_body(body_params, protocol))
+            .to_return(status: 200, body: '{}', headers: { 'Content-Type' => 'application/json' })
+        end
+
+        it 'supports put' do
+          subject.request(:put, "/push/deviceRegistrations/#{device_id}", {}, body_params).callback do |response|
+            expect(response).to be_success
+            stop_reactor
+          end
+        end
+      end
     end
 
     context '#publish (#TBC)' do
@@ -315,8 +371,9 @@ describe Ably::Realtime::Client, :event_machine do
             expect(msg.data).to eql(data)
             stop_reactor
           end
+
+          subject.publish channel_name, event_name, data
         end
-        subject.publish channel_name, event_name, data
       end
 
       specify 'publishing does not result in a channel being created' do
@@ -341,8 +398,9 @@ describe Ably::Realtime::Client, :event_machine do
               expect(msg.extras).to eql(extras)
               stop_reactor
             end
+
+            subject.publish channel_name, event_name, {}, extras: extras
           end
-          subject.publish channel_name, event_name, {}, extras: extras
         end
       end
 
@@ -353,8 +411,9 @@ describe Ably::Realtime::Client, :event_machine do
             expect(msg.data).to eql(data)
             stop_reactor
           end
+
+          subject.publish channel_name, [message]
         end
-        subject.publish channel_name, [message]
       end
 
       specify 'publishing supports an array of Hash objects' do
@@ -364,8 +423,9 @@ describe Ably::Realtime::Client, :event_machine do
             expect(msg.data).to eql(data)
             stop_reactor
           end
+
+          subject.publish channel_name, [name: event_name, data: data]
         end
-        subject.publish channel_name, [name: event_name, data: data]
       end
 
       specify 'publishing on a closed connection fails' do