ably 0.1.6 → 0.2.0

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

@@ -5,13 +5,28 @@ module Ably::Realtime
     module StatesmanMonkeyPatch
       # Override Statesman's #before_transition to support :from arrays
       # This can be removed once https://github.com/gocardless/statesman/issues/95 is solved
-      def before_transition(options, &block)
-        if options.fetch(:from, nil).kind_of?(Array)
+      def before_transition(options = nil, &block)
+        arrayify_transition(options) do |options_without_from_array|
+          super *options_without_from_array, &block
+        end
+      end
+
+      def after_transition(options = nil, &block)
+        arrayify_transition(options) do |options_without_from_array|
+          super *options_without_from_array, &block
+        end
+      end
+
+      private
+      def arrayify_transition(options, &block)
+        if options.nil?
+          yield []
+        elsif options.fetch(:from, nil).kind_of?(Array)
           options[:from].each do |from_state|
-            super(options.merge(from: from_state), &block)
+            yield [options.merge(from: from_state)]
           end
         else
-          super
+          yield [options]
         end
       end
     end
@@ -34,59 +49,63 @@ module Ably::Realtime
       end
 
       transition :from => :initialized,  :to => [:connecting, :closed]
-      transition :from => :connecting,   :to => [:connected, :failed, :closed]
+      transition :from => :connecting,   :to => [:connected, :failed, :closed, :disconnected]
       transition :from => :connected,    :to => [:disconnected, :suspended, :closed, :failed]
-      transition :from => :disconnected, :to => [:connecting, :closed]
-      transition :from => :suspended,    :to => [:connecting, :closed]
+      transition :from => :disconnected, :to => [:connecting, :closed, :failed]
+      transition :from => :suspended,    :to => [:connecting, :closed, :failed]
       transition :from => :closed,       :to => [:connecting]
       transition :from => :failed,       :to => [:connecting]
 
-      before_transition(to: [:connecting], from: [:initialized, :closed, :failed]) do |connection|
-        connection.setup_transport do |transport|
-          # Transition this StateMachine once the transport is connected or disconnected
-          # Invalid state changes are simply ignored and logged
-          transport.on(:disconnected) do
-            connection.transition_state_machine :disconnected
-          end
-        end
+      after_transition do |connection, transition|
+        connection.synchronize_state_with_statemachine
+      end
+
+      after_transition(to: [:connecting], from: [:initialized, :closed, :failed]) do |connection|
+        connection.manager.setup_transport
+      end
+
+      after_transition(to: [:connecting], from: [:disconnected, :suspended]) do |connection|
+        connection.manager.reconnect_transport
       end
 
-      before_transition(to: [:connecting], from: [:disconnected, :suspended]) do |connection|
-        connection.reconnect_transport
+      before_transition(to: [:connected]) do |connection|
+        connection.manager.cancel_connection_retry_timers
+      end
+
+      after_transition(to: [:disconnected], from: [:connecting]) do |connection, current_transition|
+        connection.manager.respond_to_transport_disconnected current_transition
       end
 
       after_transition(to: [:failed]) do |connection|
-        connection.transport.disconnect
+        connection.manager.destroy_transport
       end
 
       before_transition(to: [:closed], from: [:initialized]) do |connection|
-        connection.timers.fetch(:initializer, []).each(&:cancel)
+        connection.manager.cancel_initialized_timers
       end
 
       before_transition(to: [:closed], from: [:connecting, :connected, :disconnected, :suspended]) do |connection|
-        connection.send_protocol_message action: Ably::Models::ProtocolMessage::ACTION.Close
-        connection.transport.disconnect
+        connection.manager.close_connection
       end
 
-      after_transition do |connection, transition|
-        connection.change_state transition.to_state
+      # Override Statesman's #transition_to so that:
+      # * log state change failures to {Logger}
+      def transition_to(state, *args)
+        unless result = super(state, *args)
+          logger.fatal "ConnectionStateMachine: Unable to transition from #{current_state} => #{state}"
+        end
+        result
       end
 
-      def initialize(connection)
-        @connection = connection
-        super(connection)
+      def previous_transition
+        history[-2]
       end
 
-      # Override Statesman's #transition_to to simply log state change failures
-      def transition_to(*args)
-        unless super(*args)
-          logger.debug "Unable to transition to #{args[0]} from #{current_state}"
-        end
+      def previous_state
+        previous_transition.to_state if previous_transition
       end
 
       private
-      attr_reader :connection
-
       # TODO: Implement once CLOSED ProtocolMessage is sent back from Ably in response to a CLOSE message
       #
       # FORCE_CONNECTION_CLOSED_TIMEOUT = 5
@@ -103,6 +122,10 @@ module Ably::Realtime
       #   end.clear
       # end
 
+      def connection
+        object
+      end
+
       def logger
         connection.logger
       end

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

@@ -4,7 +4,6 @@ module Ably::Realtime
     # @api private
     class WebsocketTransport < EventMachine::Connection
       include Ably::Modules::EventEmitter
-      include Ably::Modules::Conversions
       extend Ably::Modules::Enum
 
       # Valid WebSocket connection states
@@ -17,28 +16,17 @@ module Ably::Realtime
       )
       include Ably::Modules::StateEmitter
 
-      def initialize(connection)
+      def initialize(connection, url)
         @connection = connection
         @state      = STATE.Initialized
-      end
+        @url        = url
 
-      # Send object down the WebSocket driver connection as a serialized string/byte array based on protocol
-      # @param [Object] object to serialize and send to the WebSocket driver
-      # @api public
-      def send_object(object)
-        case client.protocol
-        when :json
-          driver.text(object.to_json)
-        when :msgpack
-          driver.binary(object.to_msgpack.unpack('c*'))
-        else
-          client.logger.error "Unsupported protocol '#{client.protocol}' for serialization, object cannot be serialized and sent to Ably over this WebSocket"
-        end
+        setup_event_handlers
       end
 
       # Disconnect the socket transport connection and write all pending text.
       # If Disconnected state is not automatically triggered, it will be triggered automatically
-      # @return <void>
+      # @return [void]
       # @api public
       def disconnect
         close_connection_after_writing
@@ -81,13 +69,7 @@ module Ably::Realtime
       # URL end point including initialization configuration
       # {http://www.rubydoc.info/gems/websocket-driver/0.3.5/WebSocket/Driver WebSocket::Driver} interface
       def url
-        URI(client.endpoint).tap do |endpoint|
-          endpoint.query = URI.encode_www_form(client.auth.auth_params.merge(
-            timestamp: as_since_epoch(Time.now),
-            format:    client.protocol,
-            echo:      client.echo_messages
-          ))
-        end.to_s
+        @url
       end
 
       # {http://www.rubydoc.info/gems/websocket-driver/0.3.5/WebSocket/Driver WebSocket::Driver} interface
@@ -101,9 +83,44 @@ module Ably::Realtime
         !connecting? && !connected?
       end
 
+      # @!attribute [r] __incoming_protocol_msgbus__
+      # @return [Ably::Util::PubSub] Websocket Transport internal incoming protocol message bus
+      # @api private
+      def __incoming_protocol_msgbus__
+        @__incoming_protocol_msgbus__ ||= create_pub_sub_message_bus
+      end
+
+      # @!attribute [r] __outgoing_protocol_msgbus__
+      # @return [Ably::Util::PubSub] Websocket Transport internal outgoing protocol message bus
+      # @api private
+      def __outgoing_protocol_msgbus__
+        @__outgoing_protocol_msgbus__ ||= create_pub_sub_message_bus
+      end
+
       private
       attr_reader :connection, :driver
 
+      # Send object down the WebSocket driver connection as a serialized string/byte array based on protocol
+      # @param [Object] object to serialize and send to the WebSocket driver
+      # @api public
+      def send_object(object)
+        case client.protocol
+        when :json
+          driver.text(object.to_json)
+        when :msgpack
+          driver.binary(object.to_msgpack.unpack('C*'))
+        else
+          client.logger.fatal "WebsocketTransport: Unsupported protocol '#{client.protocol}' for serialization, object cannot be serialized and sent to Ably over this WebSocket"
+        end
+      end
+
+      def setup_event_handlers
+        __outgoing_protocol_msgbus__.subscribe(:protocol_message) do |protocol_message|
+          send_object protocol_message
+          client.logger.debug "WebsocketTransport: Prot msg sent =>: #{protocol_message.action} #{protocol_message}"
+        end
+      end
+
       def clear_timer
         if @timer
           @timer.cancel
@@ -121,17 +138,18 @@ module Ably::Realtime
         @driver = WebSocket::Driver.client(self)
 
         driver.on("open") do
-          logger.debug "WebSocket connection opened to #{url}, waiting for Connected protocol message"
+          logger.debug "WebsocketTransport: socket opened to #{url}, waiting for Connected protocol message"
         end
 
         driver.on("message") do |event|
           event_data = parse_event_data(event.data).freeze
           protocol_message = Ably::Models::ProtocolMessage.new(event_data)
-          logger.debug "Prot msg recv <=: #{protocol_message.action} #{event_data}"
+          logger.debug "WebsocketTransport: Prot msg recv <=: #{protocol_message.action} #{event_data}"
+
           if protocol_message.invalid?
-            logger.error "Invalid Protocol Message received: #{event_data}\nNo action taken"
+            logger.fatal "WebsocketTransport: Invalid Protocol Message received: #{event_data}\nNo action taken"
           else
-            connection.__incoming_protocol_msgbus__.publish :message, protocol_message
+            __incoming_protocol_msgbus__.publish :protocol_message, protocol_message
           end
         end
       end
@@ -150,12 +168,21 @@ module Ably::Realtime
         when :json
           JSON.parse(data)
         when :msgpack
-          MessagePack.unpack(data.pack('c*'))
+          MessagePack.unpack(data.pack('C*'))
         else
-          client.logger.error "Unsupported Protocol Message format #{client.protocol}"
+          client.logger.fatal "WebsocketTransport: Unsupported Protocol Message format #{client.protocol}"
           data
         end
       end
+
+      def create_pub_sub_message_bus
+        Ably::Util::PubSub.new(
+          coerce_into: Proc.new do |event|
+            raise KeyError, "Expected :protocol_message, :#{event} is disallowed" unless event == :protocol_message
+            :protocol_message
+          end
+        )
+      end
     end
   end
 end

data/lib/ably/{models → realtime/models}/nil_channel.rb

@@ -1,4 +1,4 @@
-module Ably::Models
+module Ably::Realtime::Models
   # Nil object for Channels, this object is only used within the internal API of this client library
   class NilChannel
     include Ably::Modules::EventEmitter

data/lib/ably/realtime/presence.rb

@@ -17,13 +17,19 @@ module Ably::Realtime
     # {Ably::Realtime::Channel} this Presence object is assoicated with
     attr_reader :channel
 
+    # A unique member identifier for this channel client, disambiguating situations where a given
+    # client_id is present on multiple connections simultaneously.
+    # TODO: This does not work at present as no ACK is sent from the server with a memberId
+    attr_reader :member_id
+
     def initialize(channel)
       @channel       = channel
       @state         = STATE.Initialized
       @members       = Hash.new
       @subscriptions = Hash.new { |hash, key| hash[key] = [] }
       @client_id     = client.client_id
-      @client_data   = nil
+      @data          = nil
+      @member_id     = nil
 
       setup_event_handlers
     end
@@ -31,17 +37,17 @@ module Ably::Realtime
     # Enter this client into this channel. This client will be added to the presence set
     # and presence subscribers will see an enter message for this client.
     # @param [Hash,String] options an options Hash to specify client data and/or client ID, or a String with the client data
-    # @option options [String] :client_data optional data (eg a status message) for this member
+    # @option options [String] :data      optional data (eg a status message) for this member
     # @option options [String] :client_id the optional id of the client.
     #                                     This option is provided to support connections from server instances that act on behalf of
     #                                     multiple client_ids. In order to be able to enter the channel with this method, the client
     #                                     library must have been instanced either with a key, or with a token bound to the wildcard clientId.
     # @yield [Ably::Realtime::Presence] On success, will call the block with the {Ably::Realtime::Presence}
-    # @return [Ably::Realtime::PresenceMessage] Deferrable {Ably::Realtime::PresenceMessage} that supports both success (callback) and failure (errback) callbacks
+    # @return [Ably::Models::PresenceMessage] Deferrable {Ably::Models::PresenceMessage} that supports both success (callback) and failure (errback) callbacks
     #
     def enter(options = {}, &blk)
-      @client_id    = options.fetch(:client_id, client_id)
-      @client_data  = options.fetch(:client_data, client_data)
+      @client_id = options.fetch(:client_id, client_id)
+      @data      = options.fetch(:data, data)
 
       raise Ably::Exceptions::Standard.new('Unable to enter presence channel without a client_id', 400, 91000) unless client_id
 
@@ -57,7 +63,7 @@ module Ably::Realtime
           change_state STATE.Entering
           send_presence_protocol_message(Ably::Models::PresenceMessage::ACTION.Enter).tap do |deferrable|
             deferrable.errback  { |message, error| change_state STATE.Failed, error }
-            deferrable.callback { |message| change_state STATE.Entered }
+            deferrable.callback { |message| change_state STATE.Entered, message }
           end
         end
       end
@@ -72,7 +78,7 @@ module Ably::Realtime
     def leave(options = {}, &blk)
       raise Ably::Exceptions::Standard.new('Unable to leave presence channel that is not entered', 400, 91002) unless ably_to_leave?
 
-      @client_data = options.fetch(:client_data, client_data)
+      @data = options.fetch(:data, data)
 
       if state == STATE.Left
         blk.call self if block_given?
@@ -100,12 +106,12 @@ module Ably::Realtime
     # @return (see Presence#enter)
     #
     def update(options = {}, &blk)
-      @client_data = options.fetch(:client_data, client_data)
+      @data = options.fetch(:data, data)
 
       ensure_channel_attached do
         send_presence_protocol_message(Ably::Models::PresenceMessage::ACTION.Update).tap do |deferrable|
           deferrable.callback do |message|
-            change_state STATE.Entered unless entered?
+            change_state STATE.Entered, message unless entered?
             blk.call self if block_given?
           end
         end
@@ -148,6 +154,14 @@ module Ably::Realtime
       end
     end
 
+    # Return the presence messages history for the channel
+    #
+    # @param (see Ably::Rest::Presence#history)
+    # @option options (see Ably::Rest::Presence#history)
+    def history(options = {})
+      rest_presence.history(options)
+    end
+
     # @!attribute [r] __incoming_msgbus__
     # @return [Ably::Util::PubSub] Client library internal channel incoming message bus
     # @api private
@@ -158,7 +172,7 @@ module Ably::Realtime
     end
 
     private
-    attr_reader :members, :subscriptions, :client_id, :client_data
+    attr_reader :members, :subscriptions, :client_id, :data
 
     def ably_to_leave?
       entering? || entered?
@@ -166,7 +180,9 @@ module Ably::Realtime
 
     def setup_event_handlers
       __incoming_msgbus__.subscribe(:presence) do |presence|
+        presence.decode self.channel
         update_members_from_presence_message presence
+
         subscriptions[:all].each            { |cb| cb.call(presence) }
         subscriptions[presence.action].each { |cb| cb.call(presence) }
       end
@@ -182,6 +198,10 @@ module Ably::Realtime
       channel.on(Channel::STATE.Failed) do
         change_state STATE.Failed unless left? || initialized?
       end
+
+      on(STATE.Entered) do |message|
+        @member_id = message.member_id
+      end
     end
 
     # @return [Ably::Models::PresenceMessage] presence message is returned allowing callbacks to be added
@@ -207,9 +227,11 @@ module Ably::Realtime
         action:   Ably::Models::PresenceMessage.ACTION(action).to_i,
         clientId: client_id,
       }
-      model.merge!(clientData: client_data) if client_data
+      model.merge!(data: data) if data
 
-      Ably::Models::PresenceMessage.new(model, nil)
+      Ably::Models::PresenceMessage.new(model, nil).tap do |presence_message|
+        presence_message.encode self.channel
+      end
     end
 
     def update_members_from_presence_message(presence_message)
@@ -253,7 +275,10 @@ module Ably::Realtime
       channel.client
     end
 
-    # Used by {Ably::Modules::StateEmitter} to debug state changes
+    def rest_presence
+      client.rest_client.channel(channel.name).presence
+    end
+
     # Used by {Ably::Modules::StateEmitter} to debug action changes
     def logger
       client.logger

data/lib/ably/rest.rb

@@ -1,12 +1,14 @@
-require "ably/rest/channel"
-require "ably/rest/channels"
-require "ably/rest/client"
-require "ably/rest/presence"
+require 'ably/rest/channel'
+require 'ably/rest/channels'
+require 'ably/rest/client'
+require 'ably/rest/presence'
 
-Dir.glob(File.expand_path("ably/models/*.rb", File.dirname(__FILE__))).each do |file|
+Dir.glob(File.expand_path("models/*.rb", File.dirname(__FILE__))).each do |file|
   require file
 end
 
+require 'ably/models/message_encoders/base'
+
 module Ably
   # Rest provides the top-level class to be instanced for the Ably Rest library
   #