ably-pubsub-core 0.0.1.pre

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

@@ -0,0 +1,144 @@
+require 'ably/modules/state_machine'
+
+module Ably::Realtime
+  class Connection
+    # Internal class to manage connection state, recovery and state transitions for {Ably::Realtime::Connection}
+    class ConnectionStateMachine
+      include Ably::Modules::StateMachine
+
+      # States supported by this StateMachine match #{Connection::STATE}s
+      #   :initialized
+      #   :connecting
+      #   :connected
+      #   :disconnected
+      #   :suspended
+      #   :closing
+      #   :closed
+      #   :failed
+      Connection::STATE.each_with_index do |state_enum, index|
+        state state_enum.to_sym, initial: index == 0
+      end
+
+      transition :from => :initialized,  :to => [:connecting, :closing]
+      transition :from => :connecting,   :to => [:connected, :failed, :closing, :disconnected, :suspended]
+      transition :from => :connected,    :to => [:disconnected, :suspended, :closing, :failed]
+      transition :from => :disconnected, :to => [:connecting, :closing, :suspended, :failed]
+      transition :from => :suspended,    :to => [:connecting, :closing, :failed]
+      transition :from => :closing,      :to => [:closed]
+      transition :from => :closed,       :to => [:connecting]
+      transition :from => :failed,       :to => [:connecting]
+
+      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: [:failed]) do |connection|
+        connection.manager.reintialize_failed_chanels
+      end
+
+      after_transition(to: [:connecting], from: [:disconnected, :suspended]) do |connection|
+        connection.manager.reconnect_transport
+      end
+
+      before_transition(to: [:connected]) do |connection, current_transition|
+        connection.manager.connected current_transition.metadata.protocol_message
+      end
+
+      after_transition(to: [:connected]) do |connection, current_transition|
+        error = current_transition.metadata.reason
+        if is_error_type?(error)
+          connection.logger.warn { "ConnectionManager: Connected with error - #{error.message}" }
+        end
+      end
+
+      after_transition(to: [:disconnected, :suspended], from: [:connecting]) do |connection, current_transition|
+        err = error_from_state_change(current_transition)
+        connection.manager.respond_to_transport_disconnected_when_connecting err
+      end
+
+      after_transition(to: [:disconnected, :suspended], from: [:connected]) do |connection, current_transition|
+        err = error_from_state_change(current_transition)
+        connection.manager.respond_to_transport_disconnected_whilst_connected err
+      end
+
+      after_transition(to: [:suspended]) do |connection, current_transition|
+        err = error_from_state_change(current_transition)
+        connection.manager.suspend_active_channels err
+      end
+
+      after_transition(to: [:disconnected, :suspended]) do |connection|
+        connection.manager.destroy_transport # never reuse a transport if the connection has failed
+      end
+
+      before_transition(to: [:failed]) do |connection, current_transition|
+        err = error_from_state_change(current_transition)
+        connection.manager.fail err
+      end
+
+      after_transition(to: [:failed]) do |connection, current_transition|
+        err = error_from_state_change(current_transition)
+        connection.manager.fail_active_channels err
+      end
+
+      # RTN7C - If a connection enters the SUSPENDED, CLOSED or FAILED state...
+      #   the client should consider the delivery of those messages as failed
+      after_transition(to: [:suspended, :closed, :failed]) do |connection, current_transition|
+        err = error_from_state_change(current_transition)
+        connection.manager.nack_messages_on_all_channels err
+      end
+
+      after_transition(to: [:closing], from: [:initialized, :disconnected, :suspended]) do |connection|
+        connection.manager.force_close_connection
+      end
+
+      after_transition(to: [:closing], from: [:connecting, :connected]) do |connection|
+        connection.manager.close_connection
+      end
+
+      before_transition(to: [:closed], from: [:closing]) do |connection|
+        connection.manager.destroy_transport
+      end
+
+      after_transition(to: [:closed]) do |connection|
+        connection.manager.detach_active_channels
+      end
+
+      # Transitions responsible for updating connection#error_reason
+      before_transition(to: [:disconnected, :suspended, :failed]) do |connection, current_transition|
+        err = error_from_state_change(current_transition)
+        connection.set_failed_connection_error_reason err
+      end
+
+      before_transition(to: [:connected, :closed]) do |connection, current_transition|
+        err = error_from_state_change(current_transition)
+        if err
+          connection.set_failed_connection_error_reason err
+        else
+          # Connected & Closed are "healthy" final states so reset the error reason
+          connection.clear_error_reason
+        end
+      end
+
+      def self.error_from_state_change(current_transition)
+        # ConnectionStateChange object is always passed in current_transition metadata object
+        connection_state_change = current_transition.metadata
+        # Reason attribute contains errors
+        err = connection_state_change && connection_state_change.reason
+        err if is_error_type?(err)
+      end
+
+      private
+      def connection
+        object
+      end
+
+      def logger
+        connection.logger
+      end
+    end
+  end
+end

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

@@ -0,0 +1,287 @@
+require 'openssl'
+
+module Ably::Realtime
+  class Connection
+    # EventMachine WebSocket transport
+    # @api private
+    class WebsocketTransport < EventMachine::Connection
+      include Ably::Modules::EventEmitter
+      extend Ably::Modules::Enum
+
+      # Valid WebSocket connection states
+      STATE = ruby_enum('STATE',
+        :initialized,
+        :connecting,
+        :connected,
+        :disconnecting,
+        :disconnected
+      )
+      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
+
+      # Disconnect the socket transport connection and write all pending text.
+      # If Disconnected state is not automatically emitted, it will be emitted automatically
+      #
+      # @return [void]
+      #
+      # @api public
+      def disconnect
+        close_connection_after_writing
+        change_state STATE.Disconnecting
+        create_timer(2) do
+          # if connection is not disconnected within 2s, set state as disconnected
+          change_state STATE.Disconnected unless disconnected?
+        end
+      end
+
+      # Network connection has been established
+      # Required {http://www.rubydoc.info/github/eventmachine/eventmachine/EventMachine/Connection EventMachine::Connection} interface
+      def post_init
+        clear_timer
+        change_state STATE.Connecting
+        setup_driver
+      end
+
+      # Remote TCP connection attempt completes successfully
+      # Required {http://www.rubydoc.info/github/eventmachine/eventmachine/EventMachine/Connection EventMachine::Connection} interface
+      def connection_completed
+        change_state STATE.Connected
+        start_tls(tls_opts) if client.use_tls?
+        driver.start
+      end
+
+      # Called by the event loop whenever data has been received by the network connection.
+      # Simply pass onto the WebSocket driver to process and determine content boundaries.
+      # Required {http://www.rubydoc.info/github/eventmachine/eventmachine/EventMachine/Connection EventMachine::Connection} interface
+      def receive_data(data)
+        driver.parse(data)
+      end
+
+      # Called whenever a connection (either a server or client connection) is closed
+      # Required {http://www.rubydoc.info/github/eventmachine/eventmachine/EventMachine/Connection EventMachine::Connection} interface
+      def unbind
+        change_state STATE.Disconnected, reason_closed || 'Websocket connection closed unexpectedly'
+      end
+
+      # URL end point including initialization configuration
+      # {http://www.rubydoc.info/gems/websocket-driver/0.3.5/WebSocket/Driver WebSocket::Driver} interface
+      def url
+        @url
+      end
+
+      # {http://www.rubydoc.info/gems/websocket-driver/0.3.5/WebSocket/Driver WebSocket::Driver} interface
+      def write(data)
+        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?
+        !connecting? && !connected?
+      end
+
+      # @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
+
+      # @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
+      def driver
+        @driver
+      end
+
+      def connection
+        @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
+
+      # 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
+      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 defined?(@timer) && @timer
+          @timer.cancel
+          @timer = nil
+        end
+      end
+
+      def create_timer(period)
+        @timer = EventMachine::Timer.new(period) do
+          yield
+        end
+      end
+
+      def setup_driver
+        @driver = WebSocket::Driver.client(self)
+
+        driver.on("open") do
+          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: logger)
+          action_name = Ably::Models::ProtocolMessage::ACTION[event_data['action']] rescue event_data['action']
+          logger.debug { "WebsocketTransport: Prot msg recv <=: #{action_name} - #{event_data}" }
+
+          if protocol_message.invalid?
+            error = Ably::Exceptions::ProtocolError.new("Invalid Protocol Message received: #{event_data}\nConnection moving to the failed state as the protocol is invalid and unsupported", 400, Ably::Exceptions::Codes::PROTOCOL_ERROR)
+            logger.fatal { "WebsocketTransport: #{error.message}" }
+            failed_protocol_message = Ably::Models::ProtocolMessage.new(
+              action: Ably::Models::ProtocolMessage::ACTION.Error,
+              error: error.as_json,
+              logger: logger
+            )
+            __incoming_protocol_msgbus__.publish :protocol_message, failed_protocol_message
+          else
+            __incoming_protocol_msgbus__.publish :protocol_message, protocol_message
+          end
+        end
+
+        driver.on("ping") do
+          __incoming_protocol_msgbus__.publish :protocol_message, Ably::Models::ProtocolMessage.new(action: Ably::Models::ProtocolMessage::ACTION.Heartbeat, source: :websocket)
+        end
+
+        driver.on("error") do |error|
+          logger.error { "WebsocketTransport: Protocol Error on transports - #{error.message}" }
+        end
+
+        @reason_closed = nil
+        driver.on("closed") do |event|
+          @reason_closed = "#{event.code}: #{event.reason}"
+          logger.warn { "WebsocketTransport: Driver reported transport as closed - #{reason_closed}" }
+        end
+      end
+
+      def client
+        connection.client
+      end
+
+      # Used to log transport messages
+      def logger
+        connection.logger
+      end
+
+      def parse_event_data(data)
+        case client.protocol
+        when :json
+          JSON.parse(data)
+        when :msgpack
+          MessagePack.unpack(data)
+        else
+          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: lambda do |event|
+            raise KeyError, "Expected :protocol_message, :#{event} is disallowed" unless event == :protocol_message
+            :protocol_message
+          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