actioncable-next 0.1.0

data/lib/action_cable/server/socket/web_socket.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "websocket/driver"
+
+module ActionCable
+  module Server
+    class Socket
+      # # Action Cable Connection WebSocket
+      #
+      # Wrap the real socket to minimize the externally-presented API
+      class WebSocket # :nodoc:
+        def initialize(env, event_target, event_loop, protocols: ActionCable::INTERNAL[:protocols])
+          @websocket = ::WebSocket::Driver.websocket?(env) ? ClientSocket.new(env, event_target, event_loop, protocols) : nil
+        end
+
+        def possible?
+          websocket
+        end
+
+        def alive?
+          websocket&.alive?
+        end
+
+        def transmit(...)
+          websocket&.transmit(...)
+        end
+
+        def close(...)
+          websocket&.close(...)
+        end
+
+        def protocol
+          websocket&.protocol
+        end
+
+        def rack_response
+          websocket&.rack_response
+        end
+
+        private
+          attr_reader :websocket
+      end
+    end
+  end
+end

data/lib/action_cable/server/socket.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require "action_dispatch"
+
+module ActionCable
+  module Server
+    # This class encapsulates all the low-level logic of working with the underlying WebSocket conenctions
+    # and delegate all the business-logic to the user-level connection object (e.g., ApplicationCable::Connection).
+    # This connection object is also responsible for handling encoding and decoding of messages, so the user-level
+    # connection object shouldn't know about such details.
+    class Socket
+      attr_reader :server, :env, :protocol, :logger, :connection
+      private attr_reader :worker_pool
+
+      delegate :event_loop, :pubsub, :config, to: :server
+
+      def initialize(server, env, coder: ActiveSupport::JSON)
+        @server, @env, @coder = server, env, coder
+
+        @worker_pool = server.worker_pool
+        @logger = server.new_tagged_logger { request }
+
+        @websocket      = WebSocket.new(env, self, event_loop)
+        @message_buffer = MessageBuffer.new(self)
+
+        @protocol = nil
+        @connection = config.connection_class.call.new(server, self)
+      end
+
+      # Called by the server when a new WebSocket connection is established.
+      def process # :nodoc:
+        logger.info started_request_message
+
+        if websocket.possible? && server.allow_request_origin?(env)
+          respond_to_successful_request
+        else
+          respond_to_invalid_request
+        end
+      end
+
+      # Methods used by the delegate (i.e., an application connection)
+
+      # Send a non-serialized message over the WebSocket connection.
+      def transmit(cable_message)
+        return unless websocket.alive?
+
+        websocket.transmit encode(cable_message)
+      end
+
+      # Close the WebSocket connection.
+      def close(...)
+        websocket.close(...) if websocket.alive?
+      end
+
+      # Invoke a method on the connection asynchronously through the pool of thread workers.
+      def perform_work(receiver, method, *args)
+        worker_pool.async_invoke(receiver, method, *args, connection: self)
+      end
+
+      def send_async(method, *arguments)
+        worker_pool.async_invoke(self, method, *arguments)
+      end
+
+      # The request that initiated the WebSocket connection is available here. This gives access to the environment, cookies, etc.
+      def request
+        @request ||= begin
+          environment = Rails.application.env_config.merge(env) if defined?(Rails.application) && Rails.application
+          ActionDispatch::Request.new(environment || env)
+        end
+      end
+
+      # Decodes WebSocket messages and dispatches them to subscribed channels.
+      # WebSocket message transfer encoding is always JSON.
+      def receive(websocket_message) # :nodoc:
+        send_async :dispatch_websocket_message, websocket_message
+      end
+
+      def dispatch_websocket_message(websocket_message) # :nodoc:
+        if websocket.alive?
+          @connection.handle_incoming decode(websocket_message)
+        else
+          logger.error "Ignoring message processed after the WebSocket was closed: #{websocket_message.inspect})"
+        end
+      rescue Exception => e
+        logger.error "Could not handle incoming message: #{websocket_message.inspect} [#{e.class} - #{e.message}]: #{e.backtrace.first(5).join(" | ")}"
+      end
+
+      def on_open # :nodoc:
+        send_async :handle_open
+      end
+
+      def on_message(message) # :nodoc:
+        message_buffer.append message
+      end
+
+      def on_error(message) # :nodoc:
+        # log errors to make diagnosing socket errors easier
+        logger.error "WebSocket error occurred: #{message}"
+      end
+
+      def on_close(reason, code) # :nodoc:
+        send_async :handle_close
+      end
+
+      def inspect # :nodoc:
+        "#<#{self.class.name}:#{'%#016x' % (object_id << 1)}>"
+      end
+
+      private
+        attr_reader :websocket
+        attr_reader :message_buffer
+
+        def encode(cable_message)
+          @coder.encode cable_message
+        end
+
+        def decode(websocket_message)
+          @coder.decode websocket_message
+        end
+
+        def handle_open
+          @protocol = websocket.protocol
+
+          @connection.handle_open
+
+          message_buffer.process!
+          server.add_connection(@connection)
+        end
+
+        def handle_close
+          logger.info finished_request_message
+
+          server.remove_connection(@connection)
+          @connection.handle_close
+        end
+
+        def respond_to_successful_request
+          logger.info successful_request_message
+          websocket.rack_response
+        end
+
+        def respond_to_invalid_request
+          close if websocket.alive?
+
+          logger.error invalid_request_message
+          logger.info finished_request_message
+          [ 404, { Rack::CONTENT_TYPE => "text/plain; charset=utf-8" }, [ "Page not found" ] ]
+        end
+
+        def started_request_message
+          'Started %s "%s"%s for %s at %s' % [
+            request.request_method,
+            request.filtered_path,
+            websocket.possible? ? " [WebSocket]" : "[non-WebSocket]",
+            request.ip,
+            Time.now.to_s ]
+        end
+
+        def finished_request_message
+          'Finished "%s"%s for %s at %s' % [
+            request.filtered_path,
+            websocket.possible? ? " [WebSocket]" : "[non-WebSocket]",
+            request.ip,
+            Time.now.to_s ]
+        end
+
+        def invalid_request_message
+          "Failed to upgrade to WebSocket (REQUEST_METHOD: %s, HTTP_CONNECTION: %s, HTTP_UPGRADE: %s)" % [
+            env["REQUEST_METHOD"], env["HTTP_CONNECTION"], env["HTTP_UPGRADE"]
+          ]
+        end
+
+        def successful_request_message
+          "Successfully upgraded to WebSocket (REQUEST_METHOD: %s, HTTP_CONNECTION: %s, HTTP_UPGRADE: %s)" % [
+            env["REQUEST_METHOD"], env["HTTP_CONNECTION"], env["HTTP_UPGRADE"]
+          ]
+        end
+    end
+  end
+end

data/lib/action_cable/server/stream_event_loop.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "nio"
+
+module ActionCable
+  module Server
+    class StreamEventLoop
+      def initialize
+        @nio = @thread = nil
+        @map = {}
+        @stopping = false
+        @todo = Queue.new
+
+        @spawn_mutex = Mutex.new
+      end
+
+      def attach(io, stream)
+        @todo << lambda do
+          @map[io] = @nio.register(io, :r)
+          @map[io].value = stream
+        end
+        wakeup
+      end
+
+      def detach(io, stream)
+        @todo << lambda do
+          @nio.deregister io
+          @map.delete io
+          io.close
+        end
+        wakeup
+      end
+
+      def writes_pending(io)
+        @todo << lambda do
+          if monitor = @map[io]
+            monitor.interests = :rw
+          end
+        end
+        wakeup
+      end
+
+      def stop
+        @stopping = true
+        wakeup if @nio
+      end
+
+      private
+        def spawn
+          return if @thread && @thread.status
+
+          @spawn_mutex.synchronize do
+            return if @thread && @thread.status
+
+            @nio ||= NIO::Selector.new
+
+            @thread = Thread.new { run }
+
+            return true
+          end
+        end
+
+        def wakeup
+          spawn || @nio.wakeup
+        end
+
+        def run
+          loop do
+            if @stopping
+              @nio.close
+              break
+            end
+
+            until @todo.empty?
+              @todo.pop(true).call
+            end
+
+            next unless monitors = @nio.select
+
+            monitors.each do |monitor|
+              io = monitor.io
+              stream = monitor.value
+
+              begin
+                if monitor.writable?
+                  if stream.flush_write_buffer
+                    monitor.interests = :r
+                  end
+                  next unless monitor.readable?
+                end
+
+                incoming = io.read_nonblock(4096, exception: false)
+                case incoming
+                when :wait_readable
+                  next
+                when nil
+                  stream.close
+                else
+                  stream.receive incoming
+                end
+              rescue
+                # We expect one of EOFError or Errno::ECONNRESET in normal operation (when the
+                # client goes away). But if anything else goes wrong, this is still the best way
+                # to handle it.
+                begin
+                  stream.close
+                rescue
+                  @nio.deregister io
+                  @map.delete io
+                end
+              end
+            end
+          end
+        end
+    end
+  end
+end

data/lib/action_cable/server/tagged_logger_proxy.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionCable
+  module Server
+    # # Action Cable Connection TaggedLoggerProxy
+    #
+    # Allows the use of per-connection tags against the server logger. This wouldn't work using the traditional
+    # ActiveSupport::TaggedLogging enhanced Rails.logger, as that logger will reset the tags between requests.
+    # The connection is long-lived, so it needs its own set of tags for its independent duration.
+    class TaggedLoggerProxy
+      attr_reader :tags
+
+      def initialize(logger, tags:)
+        @logger = logger
+        @tags = tags.flatten
+      end
+
+      def add_tags(*tags)
+        @tags += tags.flatten
+        @tags = @tags.uniq
+      end
+
+      def tag(logger, &block)
+        if logger.respond_to?(:tagged)
+          current_tags = tags - logger.formatter.current_tags
+          logger.tagged(*current_tags, &block)
+        else
+          yield
+        end
+      end
+
+      %i( debug info warn error fatal unknown ).each do |severity|
+        define_method(severity) do |message = nil, &block|
+          log severity, message, &block
+        end
+      end
+
+      private
+        def log(type, message, &block) # :doc:
+          tag(@logger) { @logger.send type, message, &block }
+        end
+    end
+  end
+end

data/lib/action_cable/server/worker/active_record_connection_management.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionCable
+  module Server
+    class Worker
+      module ActiveRecordConnectionManagement
+        extend ActiveSupport::Concern
+
+        included do
+          if defined?(ActiveRecord::Base)
+            set_callback :work, :around, :with_database_connections
+          end
+        end
+
+        def with_database_connections(&block)
+          connection.logger.tag(ActiveRecord::Base.logger, &block)
+        end
+      end
+    end
+  end
+end

data/lib/action_cable/server/worker.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/callbacks"
+require "active_support/core_ext/module/attribute_accessors_per_thread"
+require "concurrent"
+
+module ActionCable
+  module Server
+    # Worker used by Server.send_async to do connection work in threads.
+    class Worker # :nodoc:
+      include ActiveSupport::Callbacks
+
+      thread_mattr_accessor :connection
+      define_callbacks :work
+      include ActiveRecordConnectionManagement
+
+      attr_reader :executor
+
+      def initialize(max_size: 5)
+        @executor = Concurrent::ThreadPoolExecutor.new(
+          name: "ActionCable worker",
+          min_threads: 1,
+          max_threads: max_size,
+          max_queue: 0,
+        )
+      end
+
+      # Stop processing work: any work that has not already started running will be
+      # discarded from the queue
+      def halt
+        @executor.shutdown
+      end
+
+      def stopping?
+        @executor.shuttingdown?
+      end
+
+      def work(connection, &block)
+        self.connection = connection
+
+        run_callbacks :work, &block
+      ensure
+        self.connection = nil
+      end
+
+      def async_exec(receiver, *args, connection:, &block)
+        async_invoke receiver, :instance_exec, *args, connection: connection, &block
+      end
+
+      def async_invoke(receiver, method, *args, connection: receiver, &block)
+        @executor.post do
+          invoke(receiver, method, *args, connection: connection, &block)
+        end
+      end
+
+      def invoke(receiver, method, *args, connection:, &block)
+        work(connection) do
+          receiver.send method, *args, &block
+        rescue Exception => e
+          logger.error "There was an exception - #{e.class}(#{e.message})"
+          logger.error e.backtrace.join("\n")
+
+          receiver.handle_exception if receiver.respond_to?(:handle_exception)
+        end
+      end
+
+      private
+        def logger
+          ActionCable.server.logger
+        end
+    end
+  end
+end

data/lib/action_cable/subscription_adapter/async.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionCable
+  module SubscriptionAdapter
+    class Async < Inline # :nodoc:
+      private
+        def new_subscriber_map
+          SubscriberMap::Async.new(executor)
+        end
+    end
+  end
+end

data/lib/action_cable/subscription_adapter/base.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionCable
+  module SubscriptionAdapter
+    class Base
+      private attr_reader :executor
+      private attr_reader :config
+
+      delegate :logger, to: :config
+
+      def initialize(server)
+        @executor = server.executor
+        @config = server.config
+      end
+
+      def broadcast(channel, payload)
+        raise NotImplementedError
+      end
+
+      def subscribe(channel, message_callback, success_callback = nil)
+        raise NotImplementedError
+      end
+
+      def unsubscribe(channel, message_callback)
+        raise NotImplementedError
+      end
+
+      def shutdown
+        raise NotImplementedError
+      end
+
+      def identifier
+        config.cable[:id] ||= "ActionCable-PID-#{$$}"
+      end
+    end
+  end
+end

data/lib/action_cable/subscription_adapter/channel_prefix.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionCable
+  module SubscriptionAdapter
+    module ChannelPrefix # :nodoc:
+      def broadcast(channel, payload)
+        channel = channel_with_prefix(channel)
+        super
+      end
+
+      def subscribe(channel, callback, success_callback = nil)
+        channel = channel_with_prefix(channel)
+        super
+      end
+
+      def unsubscribe(channel, callback)
+        channel = channel_with_prefix(channel)
+        super
+      end
+
+      private
+        # Returns the channel name, including channel_prefix specified in cable.yml
+        def channel_with_prefix(channel)
+          [config.cable[:channel_prefix], channel].compact.join(":")
+        end
+    end
+  end
+end

data/lib/action_cable/subscription_adapter/inline.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionCable
+  module SubscriptionAdapter
+    class Inline < Base # :nodoc:
+      def initialize(*)
+        super
+        @mutex = Mutex.new
+        @subscriber_map = nil
+      end
+
+      def broadcast(channel, payload)
+        subscriber_map.broadcast(channel, payload)
+      end
+
+      def subscribe(channel, callback, success_callback = nil)
+        subscriber_map.add_subscriber(channel, callback, success_callback)
+      end
+
+      def unsubscribe(channel, callback)
+        subscriber_map.remove_subscriber(channel, callback)
+      end
+
+      def shutdown
+        # nothing to do
+      end
+
+      private
+        def subscriber_map
+          @subscriber_map || @mutex.synchronize { @subscriber_map ||= new_subscriber_map }
+        end
+
+        def new_subscriber_map
+          SubscriberMap.new
+        end
+    end
+  end
+end