ably 1.1.0 → 1.1.4

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

@@ -1,3 +1,5 @@
+require 'openssl'
+
 module Ably::Realtime
   class Connection
     # EventMachine WebSocket transport
@@ -16,10 +18,13 @@ module Ably::Realtime
       )
       include Ably::Modules::StateEmitter
 
+      attr_reader :host
+
       def initialize(connection, url)
         @connection = connection
         @state      = STATE.Initialized
         @url        = url
+        @host       = URI.parse(url).hostname
 
         setup_event_handlers
       end
@@ -49,7 +54,7 @@ module Ably::Realtime
       # Required {http://www.rubydoc.info/github/eventmachine/eventmachine/EventMachine/Connection EventMachine::Connection} interface
       def connection_completed
         change_state STATE.Connected
-        start_tls if client.use_tls?
+        start_tls(tls_opts) if client.use_tls?
         driver.start
       end
 
@@ -77,6 +82,51 @@ module Ably::Realtime
         send_data(data)
       end
 
+      # TLS verification support, original implementation by Mislav Marohnić:
+      #
+      # https://github.com/lostisland/faraday/commit/63cf47c95b573539f047c729bd9ad67560bc83ff
+      def ssl_verify_peer(cert_string)
+        cert = nil
+        begin
+          cert = OpenSSL::X509::Certificate.new(cert_string)
+        rescue OpenSSL::X509::CertificateError => e
+          disconnect_with_reason "Websocket host '#{host}' returned an invalid TLS certificate: #{e.message}"
+          return false
+        end
+
+        @last_seen_cert = cert
+
+        if certificate_store.verify(@last_seen_cert)
+          begin
+            certificate_store.add_cert(@last_seen_cert)
+          rescue OpenSSL::X509::StoreError => e
+            unless e.message == 'cert already in hash table'
+              disconnect_with_reason "Websocket host '#{host}' returned an invalid TLS certificate: #{e.message}"
+              return false
+            end
+          end
+          true
+        else
+          disconnect_with_reason "Websocket host '#{host}' returned an invalid TLS certificate"
+          false
+        end
+      end
+
+      def ssl_handshake_completed
+        unless OpenSSL::SSL.verify_certificate_identity(@last_seen_cert, host)
+          disconnect_with_reason "Websocket host '#{host}' returned an invalid TLS certificate"
+          false
+        else
+          true
+        end
+      end
+
+      def certificate_store
+        @certificate_store ||= OpenSSL::X509::Store.new.tap do |store|
+          store.set_default_paths
+        end
+      end
+
       # True if socket connection is ready to be released
       # i.e. it is not currently connecting or connected
       def ready_for_release?
@@ -106,6 +156,12 @@ module Ably::Realtime
         @connection
       end
 
+      def disconnect_with_reason(reason)
+        client.logger.error { "WebsocketTransport: Disconnecting due to error: #{reason}" }
+        @reason_closed = reason
+        disconnect
+      end
+
       def reason_closed
         @reason_closed
       end
@@ -214,6 +270,16 @@ module Ably::Realtime
           end
         )
       end
+
+      # TLS options to pass to EventMachine::Connection#start_tls
+      #
+      # See https://www.rubydoc.info/github/eventmachine/eventmachine/EventMachine/Connection#start_tls-instance_method
+      def tls_opts
+        {
+          sni_hostname: host,
+          verify_peer:  true,
+        }
+      end
     end
   end
 end

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

@@ -32,6 +32,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
@@ -336,14 +343,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 +478,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 +566,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 +587,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 +607,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

data/lib/ably/version.rb

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

data/spec/acceptance/realtime/auth_spec.rb

@@ -661,17 +661,19 @@ describe Ably::Realtime::Auth, :event_machine do
                 client.connection.once(:disconnected) { raise 'Upgrade does not require a disconnect' }
 
                 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/)
+                channel.attach do
+                  channel.publish('not-allowed').errback do |error|
+                    expect(error.code).to eql(40160)
+                    expect(error.message).to match(/permission denied/)
 
-                  client.auth.authorize(nil, auth_callback: upgraded_token_cb)
-                  client.connection.once(:update) do
-                    expect(client.connection.error_reason).to be_nil
-                    channel.subscribe('now-allowed') do |message|
-                      stop_reactor
+                    client.auth.authorize(nil, auth_callback: upgraded_token_cb)
+                    client.connection.once(:update) do
+                      expect(client.connection.error_reason).to be_nil
+                      channel.subscribe('now-allowed') do |message|
+                        stop_reactor
+                      end
+                      channel.publish 'now-allowed'
                     end
-                    channel.publish 'now-allowed'
                   end
                 end
               end
@@ -1056,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
@@ -1109,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
@@ -1137,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
@@ -1237,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_history_spec.rb

@@ -112,22 +112,26 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
 
       context 'in multiple ProtocolMessages', em_timeout: (30 / 10) + 5 do
         it 'retrieves limited history forwards with pagination' do
-          messages_sent.times do |index|
-            EventMachine.add_timer(index.to_f / rate_per_second) do
-              channel.publish('event', "history#{index}") do
-                next unless index == messages_sent - 1
-                ensure_message_history_direction_and_paging_is_correct :forwards
+          channel.attach do
+            messages_sent.times do |index|
+              EventMachine.add_timer(index.to_f / rate_per_second) do
+                channel.publish('event', "history#{index}") do
+                  next unless index == messages_sent - 1
+                  ensure_message_history_direction_and_paging_is_correct :forwards
+                end
               end
             end
           end
         end
 
         it 'retrieves limited history backwards with pagination' do
-          messages_sent.times.to_a.reverse.each do |index|
-            EventMachine.add_timer((messages_sent - index).to_f / rate_per_second) do
-              channel.publish('event', "history#{index}") do
-                next unless index == 0
-                ensure_message_history_direction_and_paging_is_correct :backwards if index == 0
+          channel.attach do
+            messages_sent.times.to_a.reverse.each do |index|
+              EventMachine.add_timer((messages_sent - index).to_f / rate_per_second) do
+                channel.publish('event', "history#{index}") do
+                  next unless index == 0
+                  ensure_message_history_direction_and_paging_is_correct :backwards if index == 0
+                end
               end
             end
           end
@@ -139,18 +143,20 @@ describe Ably::Realtime::Channel, '#history', :event_machine do
         let(:messages_per_batch) { 10 }
 
         it 'return the same results with unique matching message IDs' do
-          batches.times do |batch|
-            EventMachine.add_timer(batch.to_f / batches.to_f) do
-              messages_per_batch.times { channel.publish('event', 'data') }
+          channel.attach do
+            batches.times do |batch|
+              EventMachine.add_timer(batch.to_f / batches.to_f) do
+                messages_per_batch.times { |index| channel.publish('event') }
+              end
             end
-          end
 
-          channel.subscribe('event') do |message|
-            messages << message
-            if messages.count == batches * messages_per_batch
-              channel.history do |page|
-                expect(page.items.map(&:id).sort).to eql(messages.map(&:id).sort)
-                stop_reactor
+            channel.subscribe('event') do |message|
+              messages << message
+              if messages.count == batches * messages_per_batch
+                channel.history do |page|
+                  expect(page.items.map(&:id).sort).to eql(messages.map(&:id).sort)
+                  stop_reactor
+                end
               end
             end
           end

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|