ably 0.1.5 → 0.1.6

data/lib/ably/realtime/channels.rb

@@ -0,0 +1,47 @@
+module Ably
+  module Realtime
+    # Class that maintains a map of Channels ensuring Channels are reused
+    class Channels
+      include Ably::Modules::ChannelsCollection
+
+      # @return [Ably::Realtime::Channels]
+      def initialize(client)
+        super client, Ably::Realtime::Channel
+      end
+
+      # @!method get(name, channel_options = {})
+      # Return a {Ably::Realtime::Channel} for the given name
+      #
+      # @param name [String] The name of the channel
+      # @param channel_options [Hash] Channel options, currently reserved for Encryption options
+      # @return [Ably::Realtime::Channel}
+      def get(*args)
+        super
+      end
+
+      # @!method fetch(name, &missing_block)
+      # Return a {Ably::Realtime::Channel} for the given name if it exists, else the block will be called.
+      # This method is intentionally similar to {http://ruby-doc.org/core-2.1.3/Hash.html#method-i-fetch Hash#fetch} providing a simple way to check if a channel exists or not without creating one
+      #
+      # @param name [String] The name of the channel
+      # @yield [options] (optional) if a missing_block is passed to this method and no channel exists matching the name, this block is called
+      # @yieldparam [String] name of the missing channel
+      # @return [Ably::Realtime::Channel]
+      def fetch(*args)
+        super
+      end
+
+      # Detaches the {Ably::Realtime::Channel Realtime Channel} and releases all associated resources.
+      #
+      # Releasing a Realtime Channel is not typically necessary as a channel, once detached, consumes no resources other than
+      # the memory footprint of the {Ably::Realtime::Channel Realtime Channel object}. Release channels to free up resources if required
+      #
+      # @return [void]
+      def release(channel)
+        get(channel).detach do
+          @channels.delete(channel)
+        end if @channels.has_key?(channel)
+      end
+    end
+  end
+end

data/lib/ably/realtime/client.rb

@@ -8,18 +8,24 @@ module Ably
     #   (see Ably::Rest::Client#client_id)
     # @!attribute [r] auth_options
     #   (see Ably::Rest::Client#auth_options)
-    # @!attribute [r] tls
-    #   (see Ably::Rest::Client#tls)
     # @!attribute [r] environment
     #   (see Ably::Rest::Client#environment)
+    # @!attribute [r] channels
+    #   @return [Aby::Realtime::Channels] The collection of {Ably::Realtime::Channel}s that have been created
+    # @!attribute [r] rest_client
+    #   @return [Ably::Rest::Client] The {Ably::Rest::Client REST client} instantiated with the same credentials and configuration that is used for all REST operations such as authentication
+    # @!attribute [r] echo_messages
+    #   @return [Boolean] If false, suppresses messages originating from this connection being echoed back on the same connection.  Defaults to true
     class Client
       extend Forwardable
 
       DOMAIN = 'realtime.ably.io'
 
-      attr_reader :channels, :auth
+      attr_reader :channels, :auth, :rest_client, :echo_messages
       def_delegators :auth, :client_id, :auth_options
-      def_delegators :@rest_client, :tls, :environment, :use_tls?, :logger, :log_level
+      def_delegators :@rest_client, :environment, :use_tls?, :protocol
+      def_delegators :@rest_client, :logger, :log_level
+      def_delegators :@rest_client, :time, :stats
 
       # Creates a {Ably::Realtime::Client Realtime Client} and configures the {Ably::Auth} object for the connection.
       #
@@ -42,28 +48,39 @@ module Ably
       #    # create a new client and configure a client ID used for presence
       #    client = Ably::Realtime::Client.new(api_key: 'key.id:secret', client_id: 'john')
       #
-      def initialize(options)
-        @rest_client    = Ably::Rest::Client.new(options)
+      def initialize(options, &auth_block)
+        @rest_client    = Ably::Rest::Client.new(options, &auth_block)
         @auth           = @rest_client.auth
-        @message_serial = 0
+        @channels       = Ably::Realtime::Channels.new(self)
+        @echo_messages  = @rest_client.options.fetch(:echo_messages, true) == false ? false : true
       end
 
-      def token
-        @token ||= rest_client.request_token
+      # Return a {Ably::Realtime::Channel Realtime Channel} for the given name
+      #
+      # @param (see Ably::Realtime::Channels#get)
+      #
+      # @return (see Ably::Realtime::Channels#get)
+      def channel(name, channel_options = {})
+        channels.get(name, channel_options)
       end
 
-      # Return a Realtime Channel for the given name
-      #
-      # @param name [String] The name of the channel
-      # @return [Ably::Realtime::Channel]
-      def channel(name)
-        @channels ||= {}
-        @channels[name] ||= Ably::Realtime::Channel.new(self, name)
+      # (see Ably::Rest::Client#time)
+      def time
+        rest_client.time
       end
 
-      # Default Ably Realtime endpoint used for all requests
-      #
-      # @return [URI::Generic]
+      # (see Ably::Rest::Client#stats)
+      def stats(params = {})
+        rest_client.stats(params)
+      end
+
+      # (see Ably::Realtime::Connection#close)
+      def close(&block)
+        connection.close(&block)
+      end
+
+      # @!attribute [r] endpoint
+      # @return [URI::Generic] Default Ably Realtime endpoint used for all requests
       def endpoint
         URI::Generic.build(
           scheme: use_tls? ? "wss" : "ws",
@@ -71,22 +88,11 @@ module Ably
         )
       end
 
+      # @!attribute [r] connection
+      # @return [Aby::Realtime::Connection] The underlying connection for this client
       def connection
-        @connection ||= begin
-          host = endpoint.host
-          port = use_tls? ? 443 : 80
-
-          EventMachine.connect(host, port, Connection, self).tap do |connection|
-            connection.on(:connected) do
-              IncomingMessageDispatcher.new(self)
-              OutgoingMessageDispatcher.new(self)
-            end
-          end
-        end
+        @connection ||= Connection.new(self)
       end
-
-      private
-      attr_reader :rest_client
     end
   end
 end

data/lib/ably/realtime/client/incoming_message_dispatcher.rb

@@ -1,21 +1,18 @@
 module Ably::Realtime
   class Client
-    # IncomingMessageDispatcher is a (private) class that is used to dispatch {Ably::Realtime::Models::ProtocolMessage} that are
+    # IncomingMessageDispatcher is a (private) class that is used to dispatch {Ably::Models::ProtocolMessage} that are
     # received from Ably via the {Ably::Realtime::Connection}
     class IncomingMessageDispatcher
-      ACTION = Models::ProtocolMessage::ACTION
+      ACTION = Ably::Models::ProtocolMessage::ACTION
 
-      def initialize(client)
-        @client = client
+      def initialize(client, connection)
+        @client     = client
+        @connection = connection
         subscribe_to_incoming_protocol_messages
       end
 
       private
-      attr_reader :client
-
-      def connection
-        client.connection
-      end
+      attr_reader :client, :connection
 
       def channels
         client.channels
@@ -24,7 +21,7 @@ module Ably::Realtime
       def get_channel(channel_name)
         channels.fetch(channel_name) do
           logger.warn "Received channel message for non-existent channel"
-          Models::NilChannel.new
+          Ably::Models::NilChannel.new
         end
       end
 
@@ -35,7 +32,7 @@ module Ably::Realtime
       def dispatch_protocol_message(*args)
         protocol_message = args.first
 
-        unless protocol_message.kind_of?(Models::ProtocolMessage)
+        unless protocol_message.kind_of?(Ably::Models::ProtocolMessage)
           raise ArgumentError, "Expected a ProtocolMessage. Received #{protocol_message}"
         end
 
@@ -43,6 +40,8 @@ module Ably::Realtime
           logger.debug "#{protocol_message.action} received: #{protocol_message}"
         end
 
+        update_connection_id protocol_message
+
         case protocol_message.action
           when ACTION.Heartbeat
           when ACTION.Ack
@@ -52,12 +51,21 @@ module Ably::Realtime
             logger.warn "NACK received: #{protocol_message}"
             nack_pending_queue_for_message_serial(protocol_message) if protocol_message.has_message_serial?
 
-          when ACTION.Connect, ACTION.Connected
+          when ACTION.Connect
+          when ACTION.Connected
+            connection.transition_state_machine :connected
+
           when ACTION.Disconnect, ACTION.Disconnected
+
           when ACTION.Close
           when ACTION.Closed
+            connection.transition_state_machine :closed
+
           when ACTION.Error
             logger.error "Error received: #{protocol_message.error}"
+            if protocol_message.channel && !protocol_message.has_message_serial?
+              get_channel(protocol_message.channel).change_state Ably::Realtime::Channel::STATE.Failed, protocol_message.error
+            end
 
           when ACTION.Attach
           when ACTION.Attached
@@ -68,9 +76,13 @@ module Ably::Realtime
             get_channel(protocol_message.channel).change_state Ably::Realtime::Channel::STATE.Detached
 
           when ACTION.Presence
+            protocol_message.presence.each do |presence|
+              get_channel(protocol_message.channel).presence.__incoming_msgbus__.publish :presence, presence
+            end
+
           when ACTION.Message
             protocol_message.messages.each do |message|
-              get_channel(protocol_message.channel).__incoming_protocol_msgbus__.publish :message, message
+              get_channel(protocol_message.channel).__incoming_msgbus__.publish :message, message
             end
 
           else
@@ -78,21 +90,38 @@ module Ably::Realtime
         end
       end
 
+      def update_connection_id(protocol_message)
+        if protocol_message.connection_id && (protocol_message.connection_id != connection.id)
+          logger.debug "New connection ID set to #{protocol_message.connection_id}"
+          connection.update_connection_id protocol_message.connection_id
+        end
+      end
+
       def ack_pending_queue_for_message_serial(ack_protocol_message)
         drop_pending_queue_from_ack(ack_protocol_message) do |protocol_message|
-          protocol_message.messages.each do |message|
-            logger.debug "Calling ACK success callbacks for #{message.to_json}"
-            message.succeed message
-          end
+          ack_messages protocol_message.messages
+          ack_messages protocol_message.presence
         end
       end
 
       def nack_pending_queue_for_message_serial(nack_protocol_message)
         drop_pending_queue_from_ack(nack_protocol_message) do |protocol_message|
-          protocol_message.messages.each do |message|
-            logger.debug "Calling NACK failure callbacks for #{message.to_json}"
-            message.fail message, nack_protocol_message.error
-          end
+          nack_messages protocol_message.messages, nack_protocol_message
+          nack_messages protocol_message.presence, nack_protocol_message
+        end
+      end
+
+      def ack_messages(messages)
+        messages.each do |message|
+          logger.debug "Calling ACK success callbacks for #{message.class.name} - #{message.to_json}"
+          message.succeed message
+        end
+      end
+
+      def nack_messages(messages, protocol_message)
+        messages.each do |message|
+          logger.debug "Calling NACK failure callbacks for #{message.class.name} - #{message.to_json}, protocol message: #{protocol_message}"
+          message.fail message, protocol_message.error
         end
       end
 

data/lib/ably/realtime/client/outgoing_message_dispatcher.rb

@@ -1,25 +1,22 @@
 module Ably::Realtime
   class Client
     # OutgoingMessageDispatcher is a (private) class that is used to deliver
-    # outgoing {Ably::Realtime::Models::ProtocolMessage}s using the {Ably::Realtime::Connection}
+    # outgoing {Ably::Models::ProtocolMessage}s using the {Ably::Realtime::Connection}
     # when the connection state is capable of delivering messages
     class OutgoingMessageDispatcher
       include Ably::Modules::EventMachineHelpers
 
-      ACTION = Models::ProtocolMessage::ACTION
+      ACTION = Ably::Models::ProtocolMessage::ACTION
 
-      def initialize(client)
-        @client = client
+      def initialize(client, connection)
+        @client     = client
+        @connection = connection
         subscribe_to_outgoing_protocol_message_queue
         setup_event_handlers
       end
 
       private
-      attr_reader :client
-
-      def connection
-        client.connection
-      end
+      attr_reader :client, :connection
 
       def can_send_messages?
         connection.connected?
@@ -39,11 +36,12 @@ module Ably::Realtime
 
       def deliver_queued_protocol_messages
         condition = -> { can_send_messages? && messages_in_outgoing_queue? }
+
         non_blocking_loop_while(condition) do
           protocol_message = outgoing_queue.shift
           pending_queue << protocol_message if protocol_message.ack_required?
-          connection.send_text(protocol_message.to_json)
-          client.logger.debug("Prot msg sent =>: #{protocol_message.action} #{protocol_message}")
+          connection.transport.send_object protocol_message
+          client.logger.debug "Prot msg sent =>: #{protocol_message.action} #{protocol_message}"
         end
       end
 

data/lib/ably/realtime/connection.rb

@@ -25,18 +25,16 @@ module Ably
     #
     # @!attribute [r] state
     #   @return {Ably::Realtime::Connection::STATE} connection state
-    # @!attribute [r] __outgoing_message_queue__
-    #   @return [Array] An internal queue used to manage unsent outgoing messages.  You should never interface with this array directly.
-    # @!attribute [r] __pending_message_queue__
-    #   @return [Array] An internal queue used to manage sent messages.  You should never interface with this array directly.
-    #
-    class Connection < EventMachine::Connection
-      include Ably::Modules::Conversions
+    # @!attribute [r] id
+    #   @return {String} the assigned connection ID
+    # @!attribute [r] error_reason
+    #   @return {Ably::Models::ErrorInfo} error information associated with a connection failure
+    class Connection
       include Ably::Modules::EventEmitter
       extend Ably::Modules::Enum
 
+      # Valid Connection states
       STATE = ruby_enum('STATE',
-        :initializing,
         :initialized,
         :connecting,
         :connected,
@@ -45,83 +43,178 @@ module Ably
         :closed,
         :failed
       )
-      include Ably::Modules::State
+      include Ably::Modules::StateEmitter
+
+      attr_reader :id, :error_reason, :client
+
+      # @api private
+      # Underlying socket transport used for this connection, for internal use by the client library
+      # @return {Ably::Realtime::Connection::WebsocketTransport}
+      attr_reader :transport
+
+      # @api private
+      # An internal queue used to manage unsent outgoing messages.  You should never interface with this array directly
+      # @return [Array]
+      attr_reader :__outgoing_message_queue__
 
-      attr_reader :__outgoing_message_queue__, :__pending_message_queue__
+      # @api private
+      # An internal queue used to manage sent messages.  You should never interface with this array directly
+      # @return [Array]
+      attr_reader :__pending_message_queue__
 
+      # @api private
+      # Timers used to manage connection state, for internal use by the client library
+      # @return [Hash]
+      attr_reader :timers
+
+      # @api public
       def initialize(client)
         @client                     = client
-        @message_serial             = 0
+
+        @serial                     = -1
         @__outgoing_message_queue__ = []
         @__pending_message_queue__  = []
-        @state                      = STATE.Initializing
-      end
 
-      # Required for test /unit/realtime/connection_spec.rb
-      alias_method :orig_send, :send
+        @timers                     = Hash.new { |hash, key| hash[key] = [] }
+        @timers[:initializer]       << EventMachine::Timer.new(0.001) { connect }
 
-      # Add protocol message to the outgoing message queue and notify the dispatcher that a message is
-      # ready to be sent
-      def send_protocol_message(protocol_message)
-        add_message_serial_if_ack_required_to(protocol_message) do
-          protocol_message = Models::ProtocolMessage.new(protocol_message)
-          __outgoing_message_queue__ << protocol_message
-          logger.debug("Prot msg queued =>: #{protocol_message.action} #{protocol_message}")
-          __outgoing_protocol_msgbus__.publish :message, protocol_message
+        Client::IncomingMessageDispatcher.new client, self
+        Client::OutgoingMessageDispatcher.new client, self
+
+        EventMachine.next_tick do
+          trigger STATE.Initialized
         end
+
+        @state_machine              = ConnectionStateMachine.new(self)
+        @state                      = STATE(state_machine.current_state)
       end
 
-      # EventMachine::Connection interface
-      def post_init
-        change_state STATE.Initialized
+      # Causes the connection to close, entering the closed state, from any state except
+      # the failed state. Once closed, the library will not attempt to re-establish the
+      # connection without a call to {Connection#connect}.
+      #
+      # @yield [Ably::Realtime::Connection] block is called as soon as this connection is in the Closed state
+      #
+      # @return <void>
+      def close(&block)
+        if closed?
+          block.call self
+        else
+          EventMachine.next_tick do
+            state_machine.transition_to(:closed)
+          end
+          once(STATE.Closed) { block.call self } if block_given?
+        end
+      end
 
-        setup_driver
+      # Causes the library to re-attempt connection, if it was previously explicitly
+      # closed by the user, or was closed as a result of an unrecoverable error.
+      #
+      # @yield [Ably::Realtime::Connection] block is called as soon as this connection is in the Connected state
+      #
+      # @return <void>
+      def connect(&block)
+        if connected?
+          block.call self
+        else
+          state_machine.transition_to(:connecting)
+          once(STATE.Connected) { block.call self } if block_given?
+        end
       end
 
-      def connection_completed
-        change_state STATE.Connecting
+      # Reconfigure the current connection ID
+      # @return <void>
+      # @api private
+      def update_connection_id(connection_id)
+        @id = connection_id
+      end
 
-        start_tls if client.use_tls?
-        driver.start
+      # Send #transition_to to connection state machine
+      # @return [Boolean] true if new_state can be transitioned_to by state machine
+      # @api private
+      def transition_state_machine(new_state)
+        state_machine.transition_to(new_state)
       end
 
-      def receive_data(data)
-        driver.parse(data)
+      # @!attribute [r] __outgoing_protocol_msgbus__
+      # @return [Ably::Util::PubSub] Client library internal outgoing message bus
+      # @api private
+      def __outgoing_protocol_msgbus__
+        @__outgoing_protocol_msgbus__ ||= create_pub_sub_message_bus
       end
 
-      def unbind
-        change_state STATE.Disconnected
+      # @!attribute [r] __incoming_protocol_msgbus__
+      # @return [Ably::Util::PubSub] Client library internal incoming message bus
+      # @api private
+      def __incoming_protocol_msgbus__
+        @__incoming_protocol_msgbus__ ||= create_pub_sub_message_bus
       end
 
-      # 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), binary: false))
-        end.to_s
+      # @!attribute [r] logger
+      # @return [Logger] The Logger configured for this client when the client was instantiated.
+      #                  Configure the log_level with the `:log_level` option, refer to {Ably::Realtime::Client#initialize}
+      def logger
+        client.logger
       end
 
-      def write(data)
-        send_data(data)
+      # Add protocol message to the outgoing message queue and notify the dispatcher that a message is
+      # ready to be sent
+      #
+      # @param [Ably::Models::ProtocolMessage] protocol_message
+      # @return <void>
+      # @api private
+      def send_protocol_message(protocol_message)
+        add_message_serial_if_ack_required_to(protocol_message) do
+          Models::ProtocolMessage.new(protocol_message).tap do |protocol_message|
+            add_message_to_outgoing_queue protocol_message
+            notify_message_dispatcher_of_new_message protocol_message
+            logger.debug("Prot msg queued =>: #{protocol_message.action} #{protocol_message}")
+          end
+        end
       end
 
-      def send_text(text)
-        driver.text(text)
+      def add_message_to_outgoing_queue(protocol_message)
+        __outgoing_message_queue__ << protocol_message
       end
 
-      # Client library internal outgoing message bus
-      def __outgoing_protocol_msgbus__
-        @__outgoing_protocol_msgbus__ ||= pub_sub_message_bus
+      def notify_message_dispatcher_of_new_message(protocol_message)
+        __outgoing_protocol_msgbus__.publish :message, protocol_message
       end
 
-      # Client library internal incoming message bus
-      def __incoming_protocol_msgbus__
-        @__incoming_protocol_msgbus__ ||= pub_sub_message_bus
+      # Creates and sets up a new {WebSocketTransport} available on attribute #transport
+      # @yield [Ably::Realtime::Connection::WebsocketTransport] block is called with new websocket transport
+      # @api private
+      def setup_transport(&block)
+        if transport && !transport.ready_for_release?
+          raise RuntimeError, "Existing WebsocketTransport is connected, and must be closed first"
+        end
+
+        @transport = EventMachine.connect(connection_host, connection_port, WebsocketTransport, self) do |websocket|
+          yield websocket
+        end
+      end
+
+      # Reconnect the {Ably::Realtime::Connection::WebsocketTransport} following a disconnection
+      # @api private
+      def reconnect_transport
+        raise RuntimeError, "WebsocketTransport is not set up" if !transport
+        raise RuntimeError, "WebsocketTransport is not disconnected so cannot be reconnected" if !transport.disconnected?
+
+        transport.reconnect(connection_host, connection_port)
       end
 
       private
-      attr_reader :client, :driver, :message_serial
+      attr_reader :manager, :serial, :state_machine
+
+      def connection_host
+        client.endpoint.host
+      end
 
-      def pub_sub_message_bus
+      def connection_port
+        client.use_tls? ? 443 : 80
+      end
+
+      def create_pub_sub_message_bus
         Ably::Util::PubSub.new(
           coerce_into: Proc.new { |event| Models::ProtocolMessage::ACTION(event) }
         )
@@ -136,37 +229,13 @@ module Ably
       end
 
       def add_message_serial_to(protocol_message)
-        @message_serial += 1
-        protocol_message[:msgSerial] = @message_serial
+        @serial += 1
+        protocol_message[:msgSerial] = serial
         yield
       rescue StandardError => e
-        @message_serial -= 1
+        @serial -= 1
         raise e
       end
-
-      def setup_driver
-        @driver = WebSocket::Driver.client(self)
-
-        driver.on("open") do
-          logger.debug("WebSocket connection opened to #{url}")
-          change_state STATE.Connected
-        end
-
-        driver.on("message") do |event|
-          begin
-            message = Models::ProtocolMessage.new(JSON.parse(event.data).freeze)
-            logger.debug("Prot msg recv <=: #{message.action} #{event.data}")
-            __incoming_protocol_msgbus__.publish :message, message
-          rescue KeyError
-            client.logger.error("Unsupported Protocol Message received, unrecognised 'action': #{event.data}\nNo action taken")
-          end
-        end
-      end
-
-      # Used by {Ably::Modules::State} to debug state changes
-      def logger
-        client.logger
-      end
     end
   end
 end