ably 0.1.4 → 0.1.5

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

@@ -0,0 +1,63 @@
+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}
+    # when the connection state is capable of delivering messages
+    class OutgoingMessageDispatcher
+      include Ably::Modules::EventMachineHelpers
+
+      ACTION = Models::ProtocolMessage::ACTION
+
+      def initialize(client)
+        @client = client
+        subscribe_to_outgoing_protocol_message_queue
+        setup_event_handlers
+      end
+
+      private
+      attr_reader :client
+
+      def connection
+        client.connection
+      end
+
+      def can_send_messages?
+        connection.connected?
+      end
+
+      def messages_in_outgoing_queue?
+        !outgoing_queue.empty?
+      end
+
+      def outgoing_queue
+        connection.__outgoing_message_queue__
+      end
+
+      def pending_queue
+        connection.__pending_message_queue__
+      end
+
+      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}")
+        end
+      end
+
+      def subscribe_to_outgoing_protocol_message_queue
+        connection.__outgoing_protocol_msgbus__.subscribe(:message) do |*args|
+          deliver_queued_protocol_messages
+        end
+      end
+
+      def setup_event_handlers
+        connection.on(:connected) do
+          deliver_queued_protocol_messages
+        end
+      end
+    end
+  end
+end

data/lib/ably/realtime/connection.rb

@@ -1,31 +1,85 @@
 module Ably
   module Realtime
+    # The Connection class represents the connection associated with an Ably Realtime instance.
+    # The Connection object exposes the lifecycle and parameters of the realtime connection.
+    #
+    # Connections will always be in one of the following states:
+    #
+    #   initialized:  0
+    #   connecting:   1
+    #   connected:    2
+    #   disconnected: 3
+    #   suspended:    4
+    #   closed:       5
+    #   failed:       6
+    #
+    # Note that the states are available as Enum-like constants:
+    #
+    #   Connection::STATE.Initialized
+    #   Connection::STATE.Connecting
+    #   Connection::STATE.Connected
+    #   Connection::STATE.Disconnected
+    #   Connection::STATE.Suspended
+    #   Connection::STATE.Closed
+    #   Connection::STATE.Failed
+    #
+    # @!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
-      include Callbacks
+      include Ably::Modules::EventEmitter
+      extend Ably::Modules::Enum
+
+      STATE = ruby_enum('STATE',
+        :initializing,
+        :initialized,
+        :connecting,
+        :connected,
+        :disconnected,
+        :suspended,
+        :closed,
+        :failed
+      )
+      include Ably::Modules::State
+
+      attr_reader :__outgoing_message_queue__, :__pending_message_queue__
 
       def initialize(client)
-        @client         = client
-        @message_serial = 0
+        @client                     = client
+        @message_serial             = 0
+        @__outgoing_message_queue__ = []
+        @__pending_message_queue__  = []
+        @state                      = STATE.Initializing
       end
 
-      def send(protocol_message)
+      # Required for test /unit/realtime/connection_spec.rb
+      alias_method :orig_send, :send
+
+      # 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)
-          client.log_http("Prot msg sent =>: #{protocol_message.action_sym} #{protocol_message.to_json}")
-          driver.text(protocol_message.to_json)
+          __outgoing_message_queue__ << protocol_message
+          logger.debug("Prot msg queued =>: #{protocol_message.action} #{protocol_message}")
+          __outgoing_protocol_msgbus__.publish :message, protocol_message
         end
       end
 
       # EventMachine::Connection interface
       def post_init
-        trigger :initalised
+        change_state STATE.Initialized
 
         setup_driver
       end
 
       def connection_completed
-        trigger :connecting
+        change_state STATE.Connecting
 
         start_tls if client.use_tls?
         driver.start
@@ -36,7 +90,7 @@ module Ably
       end
 
       def unbind
-        trigger :disconnected
+        change_state STATE.Disconnected
       end
 
       # WebSocket::Driver interface
@@ -50,9 +104,29 @@ module Ably
         send_data(data)
       end
 
+      def send_text(text)
+        driver.text(text)
+      end
+
+      # Client library internal outgoing message bus
+      def __outgoing_protocol_msgbus__
+        @__outgoing_protocol_msgbus__ ||= pub_sub_message_bus
+      end
+
+      # Client library internal incoming message bus
+      def __incoming_protocol_msgbus__
+        @__incoming_protocol_msgbus__ ||= pub_sub_message_bus
+      end
+
       private
       attr_reader :client, :driver, :message_serial
 
+      def pub_sub_message_bus
+        Ably::Util::PubSub.new(
+          coerce_into: Proc.new { |event| Models::ProtocolMessage::ACTION(event) }
+        )
+      end
+
       def add_message_serial_if_ack_required_to(protocol_message)
         if Models::ProtocolMessage.ack_required?(protocol_message[:action])
           add_message_serial_to(protocol_message) { yield }
@@ -74,16 +148,25 @@ module Ably
         @driver = WebSocket::Driver.client(self)
 
         driver.on("open") do
-          client.log_http("WebSocket connection opened to #{url}")
-          trigger :connected
+          logger.debug("WebSocket connection opened to #{url}")
+          change_state STATE.Connected
         end
 
         driver.on("message") do |event|
-          message = Models::ProtocolMessage.new(JSON.parse(event.data))
-          client.log_http("Prot msg recv <=: #{message.action_sym} #{message.to_json}")
-          client.trigger message.action_sym, message
+          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

data/lib/ably/realtime/models/error_info.rb

@@ -20,11 +20,12 @@ module Ably::Realtime::Models
       @json_object     = IdiomaticRubyWrapper(@raw_json_object.clone.freeze)
     end
 
-    %w( message code status ).each do |attribute|
+    %w( message code status_code ).each do |attribute|
       define_method attribute do
         json[attribute.to_sym]
       end
     end
+    alias_method :status, :status_code
 
     def json
       @json_object
@@ -32,7 +33,7 @@ module Ably::Realtime::Models
     alias_method :to_json, :json
 
     def to_s
-      "Error: #{message} (code: #{code}, status: #{status})"
+      "Error: #{message} (code: #{code}, status_code: #{status_code})"
     end
   end
 end

data/lib/ably/realtime/models/message.rb

@@ -1,4 +1,15 @@
 module Ably::Realtime::Models
+  def self.Message(message, protocol_message = nil)
+    case message
+    when Ably::Realtime::Models::Message
+      message.tap do
+        message.assign_to_protocol_message protocol_message
+      end
+    else
+      Message.new(message, protocol_message)
+    end
+  end
+
   # A class representing an individual message to be sent or received
   # via the Ably Realtime service.
   #
@@ -20,11 +31,17 @@ module Ably::Realtime::Models
   class Message
     include Shared
     include Ably::Modules::Conversions
+    include EventMachine::Deferrable
 
-    def initialize(json_object, protocol_message)
+    # {Message} initializer
+    #
+    # @param json_object [Hash] JSON like object with the underlying message details
+    # @param protocol_message [ProtocolMessage] if this message has been published, then it is associated with a {ProtocolMessage}
+    #
+    def initialize(json_object, protocol_message = nil)
       @protocol_message = protocol_message
       @raw_json_object  = json_object
-      @json_object      = IdiomaticRubyWrapper(@raw_json_object.clone.freeze, stop_at: [:data])
+      @json_object      = IdiomaticRubyWrapper(json_object.clone.freeze, stop_at: [:data])
     end
 
     %w( name client_id ).each do |attribute|
@@ -65,8 +82,16 @@ module Ably::Realtime::Models
       to_json_object.to_json
     end
 
+    def assign_to_protocol_message(protocol_message)
+      @protocol_message = protocol_message
+    end
+
     private
-    attr_reader :protocol_message
+
+    def protocol_message
+      raise RuntimeError, "Message is not yet published with a ProtocolMessage.  ProtocolMessage is nil" if @protocol_message.nil?
+      @protocol_message
+    end
 
     def protocol_message_index
       protocol_message.messages.index(self)

data/lib/ably/realtime/models/nil_channel.rb

@@ -0,0 +1,21 @@
+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
+    extend Ably::Modules::Enum
+    STATE = ruby_enum('STATE', Ably::Realtime::Channel::STATE)
+    include Ably::Modules::State
+
+    def initialize
+      @state = STATE.Initialized
+    end
+
+    def name
+      'Nil channel'
+    end
+
+    def __incoming_protocol_msgbus__
+      @__incoming_protocol_msgbus__ ||= Ably::Util::PubSub.new
+    end
+  end
+end

data/lib/ably/realtime/models/protocol_message.rb

@@ -7,9 +7,7 @@ module Ably::Realtime::Models
   # for further details on the members of a ProtocolMessage
   #
   # @!attribute [r] action
-  #   @return [Integer] Protocol Message action from list of {ACTIONS}
-  # @!attribute [r] action_sym
-  #   @return [Symbol] Protocol Message action as a symbol
+  #   @return [ACTION] Protocol Message action {Ably::Modules::Enum} from list of {ACTION}. Returns nil if action is unsupported by protocol.
   # @!attribute [r] count
   #   @return [Integer] The count field is used for ACK and NACK actions. See {http://docs.ably.io/client-lib-development-guide/protocol/#message-acknowledgement message acknowledgement protocol}
   # @!attribute [r] error_info
@@ -35,13 +33,14 @@ module Ably::Realtime::Models
   #
   class ProtocolMessage
     include Shared
+    extend Ably::Modules::Enum
     include Ably::Modules::Conversions
 
     # Actions which are sent by the Ably Realtime API
     #
     # The values correspond to the ints which the API
     # understands.
-    ACTIONS = {
+    ACTION = ruby_enum('ACTION',
       heartbeat:    0,
       ack:          1,
       nack:         2,
@@ -58,23 +57,11 @@ module Ably::Realtime::Models
       detached:     13,
       presence:     14,
       message:      15
-    }.freeze
-
-    # Retrieve an action symbol by the integer value
-    def self.action_sym_for(action_int)
-      @actions_index_by_int ||= ACTIONS.invert.freeze
-      @actions_index_by_int[action_int]
-    end
-
-    # Retrive an action integer value from a symbol and raise an exception if invalid
-    def self.action!(action_sym)
-      ACTIONS.fetch(action_sym)
-    end
+    )
 
     # Indicates this protocol message action will generate an ACK response such as :message or :presence
     def self.ack_required?(for_action)
-      for_action = ACTIONS.fetch(for_action) if for_action.kind_of?(Symbol)
-      [action!(:presence), action!(:message)].include?(for_action)
+      [ACTION.Presence, ACTION.Message].include?(ACTION(for_action))
     end
 
     def initialize(json_object)
@@ -82,16 +69,17 @@ module Ably::Realtime::Models
       @json_object     = IdiomaticRubyWrapper(@raw_json_object.clone.freeze)
     end
 
-    %w( action count
-        channel channel_serial
+    %w( channel channel_serial
         connection_id connection_serial ).each do |attribute|
       define_method attribute do
         json[attribute.to_sym]
       end
     end
 
-    def action_sym
-      self.class.action_sym_for(action)
+    def action
+      ACTION(json[:action])
+    rescue KeyError
+      raise KeyError, "Action '#{json[:action]}' is not supported by ProtocolMessage"
     end
 
     def error
@@ -103,20 +91,36 @@ module Ably::Realtime::Models
     end
 
     def message_serial
-      json[:msg_serial]
+      Integer(json[:msg_serial])
+    rescue TypeError
+      raise TypeError, "msg_serial '#{json[:msg_serial]}' is invalid, a positive Integer is expected for a ProtocolMessage"
+    end
+
+    def count
+      [1, json[:count].to_i].max
+    end
+
+    def has_message_serial?
+      message_serial && true
+    rescue TypeError
+      false
     end
 
     def messages
       @messages ||=
         Array(json[:messages]).map do |message|
-          Message.new(message, self)
+          Ably::Realtime::Models.Message(message, self)
         end
     end
 
+    def add_message(message)
+      messages << message
+    end
+
     def presence
       @presence ||=
         Array(json[:presence]).map do |message|
-          PresenceMessage.new(message, self)
+          PresenceMessage(message, self)
         end
     end
 
@@ -131,8 +135,8 @@ module Ably::Realtime::Models
     end
 
     def to_json_object
-      raise RuntimeError, ":action is missing, cannot generate valid JSON for ProtocolMessage" unless action_sym
-      raise RuntimeError, ":msg_serial is missing, cannot generate valid JSON for ProtocolMessage" if ack_required? && !message_serial
+      raise TypeError, ":action is missing, cannot generate valid JSON for ProtocolMessage" unless action
+      raise TypeError, ":msg_serial is missing, cannot generate valid JSON for ProtocolMessage" if ack_required? && !has_message_serial?
 
       json.dup.tap do |json_object|
         json_object[:messages] = messages.map(&:to_json_object) unless messages.empty?
@@ -143,5 +147,9 @@ module Ably::Realtime::Models
     def to_json(*args)
       to_json_object.to_json
     end
+
+    def to_s
+      to_json
+    end
   end
 end