actioncable-next 0.1.0

data/lib/action_cable/server/base.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "monitor"
+
+module ActionCable
+  module Server
+    # A wrapper over ConcurrentRuby::ThreadPoolExecutor and Concurrent::TimerTask
+    class ThreadedExecutor # :nodoc:
+      def initialize(max_size: 10)
+        @executor = Concurrent::ThreadPoolExecutor.new(
+          name: "ActionCable server",
+          min_threads: 1,
+          max_threads: max_size,
+          max_queue: 0,
+        )
+      end
+
+      def post(task = nil, &block)
+        task ||= block
+        @executor << task
+      end
+
+      def timer(interval, &block)
+        Concurrent::TimerTask.new(execution_interval: interval, &block).tap(&:execute)
+      end
+
+      def shutdown = @executor.shutdown
+    end
+
+    # # Action Cable Server Base
+    #
+    # A singleton ActionCable::Server instance is available via ActionCable.server.
+    # It's used by the Rack process that starts the Action Cable server, but is also
+    # used by the user to reach the RemoteConnections object, which is used for
+    # finding and disconnecting connections across all servers.
+    #
+    # Also, this is the server instance used for broadcasting. See Broadcasting for
+    # more information.
+    class Base
+      include ActionCable::Server::Broadcasting
+      include ActionCable::Server::Connections
+
+      cattr_accessor :config, instance_accessor: false, default: ActionCable::Server::Configuration.new
+
+      attr_reader :config
+
+      def self.logger; config.logger; end
+      delegate :logger, to: :config
+
+      attr_reader :mutex
+
+      def initialize(config: self.class.config)
+        @config = config
+        @mutex = Monitor.new
+        @remote_connections = @event_loop = @worker_pool = @executor = @pubsub = nil
+      end
+
+      # Called by Rack to set up the server.
+      def call(env)
+        return config.health_check_application.call(env) if env["PATH_INFO"] == config.health_check_path
+        setup_heartbeat_timer
+        Socket.new(self, env).process
+      end
+
+      # Disconnect all the connections identified by `identifiers` on this server or
+      # any others via RemoteConnections.
+      def disconnect(identifiers)
+        remote_connections.where(identifiers).disconnect
+      end
+
+      def restart
+        connections.each do |connection|
+          connection.close(reason: ActionCable::INTERNAL[:disconnect_reasons][:server_restart])
+        end
+
+        @mutex.synchronize do
+          # Shutdown the worker pool
+          @worker_pool.halt if @worker_pool
+          @worker_pool = nil
+
+          # Shutdown the executor
+          @executor.shutdown if @executor
+          @executor = nil
+
+          # Shutdown the pub/sub adapter
+          @pubsub.shutdown if @pubsub
+          @pubsub = nil
+        end
+      end
+
+      # Gateway to RemoteConnections. See that class for details.
+      def remote_connections
+        @remote_connections || @mutex.synchronize { @remote_connections ||= RemoteConnections.new(self) }
+      end
+
+      def event_loop
+        @event_loop || @mutex.synchronize { @event_loop ||= StreamEventLoop.new }
+      end
+
+      # The worker pool is where we run connection callbacks and channel actions. We
+      # do as little as possible on the server's main thread. The worker pool is an
+      # executor service that's backed by a pool of threads working from a task queue.
+      # The thread pool size maxes out at 4 worker threads by default. Tune the size
+      # yourself with `config.action_cable.worker_pool_size`.
+      #
+      # Using Active Record, Redis, etc within your channel actions means you'll get a
+      # separate connection from each thread in the worker pool. Plan your deployment
+      # accordingly: 5 servers each running 5 Puma workers each running an 8-thread
+      # worker pool means at least 200 database connections.
+      #
+      # Also, ensure that your database connection pool size is as least as large as
+      # your worker pool size. Otherwise, workers may oversubscribe the database
+      # connection pool and block while they wait for other workers to release their
+      # connections. Use a smaller worker pool or a larger database connection pool
+      # instead.
+      def worker_pool
+        @worker_pool || @mutex.synchronize { @worker_pool ||= ActionCable::Server::Worker.new(max_size: config.worker_pool_size) }
+      end
+
+      # Executor is used by various actions within Action Cable (e.g., pub/sub operations) to run code asynchronously.
+      def executor
+        @executor || @mutex.synchronize { @executor ||= ThreadedExecutor.new(max_size: config.executor_pool_size) }
+      end
+
+      # Adapter used for all streams/broadcasting.
+      def pubsub
+        @pubsub || (executor && @mutex.synchronize { @pubsub ||= config.pubsub_adapter.new(self) })
+      end
+
+      # All of the identifiers applied to the connection class associated with this
+      # server.
+      def connection_identifiers
+        config.connection_class.call.identifiers
+      end
+
+      # Tags are declared in the server but computed in the connection. This allows us per-connection tailored tags.
+      # You can pass request object either directly or via block to lazily evaluate it.
+      def new_tagged_logger(request = nil, &block)
+        TaggedLoggerProxy.new logger,
+          tags: config.log_tags.map { |tag| tag.respond_to?(:call) ? tag.call(request ||= block.call) : tag.to_s.camelize }
+      end
+
+      # Check if the request origin is allowed to connect to the Action Cable server.
+      def allow_request_origin?(env)
+        return true if config.disable_request_forgery_protection
+
+        proto = Rack::Request.new(env).ssl? ? "https" : "http"
+        if config.allow_same_origin_as_host && env["HTTP_ORIGIN"] == "#{proto}://#{env['HTTP_HOST']}"
+          true
+        elsif Array(config.allowed_request_origins).any? { |allowed_origin|  allowed_origin === env["HTTP_ORIGIN"] }
+          true
+        else
+          logger.error("Request origin not allowed: #{env['HTTP_ORIGIN']}")
+          false
+        end
+      end
+    end
+
+    ActiveSupport.run_load_hooks(:action_cable, Base.config)
+  end
+end

data/lib/action_cable/server/broadcasting.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionCable
+  module Server
+    # # Action Cable Server Broadcasting
+    #
+    # Broadcasting is how other parts of your application can send messages to a
+    # channel's subscribers. As explained in Channel, most of the time, these
+    # broadcastings are streamed directly to the clients subscribed to the named
+    # broadcasting. Let's explain with a full-stack example:
+    #
+    #     class WebNotificationsChannel < ApplicationCable::Channel
+    #       def subscribed
+    #         stream_from "web_notifications_#{current_user.id}"
+    #       end
+    #     end
+    #
+    #     # Somewhere in your app this is called, perhaps from a NewCommentJob:
+    #     ActionCable.server.broadcast \
+    #       "web_notifications_1", { title: "New things!", body: "All that's fit for print" }
+    #
+    #     # Client-side CoffeeScript, which assumes you've already requested the right to send web notifications:
+    #     App.cable.subscriptions.create "WebNotificationsChannel",
+    #       received: (data) ->
+    #         new Notification data['title'], body: data['body']
+    module Broadcasting
+      # Broadcast a hash directly to a named `broadcasting`. This will later be JSON
+      # encoded.
+      def broadcast(broadcasting, message, coder: ActiveSupport::JSON)
+        broadcaster_for(broadcasting, coder: coder).broadcast(message)
+      end
+
+      # Returns a broadcaster for a named `broadcasting` that can be reused. Useful
+      # when you have an object that may need multiple spots to transmit to a specific
+      # broadcasting over and over.
+      def broadcaster_for(broadcasting, coder: ActiveSupport::JSON)
+        Broadcaster.new(self, String(broadcasting), coder: coder)
+      end
+
+      private
+        class Broadcaster
+          attr_reader :server, :broadcasting, :coder
+
+          def initialize(server, broadcasting, coder:)
+            @server, @broadcasting, @coder = server, broadcasting, coder
+          end
+
+          def broadcast(message)
+            server.logger.debug { "[ActionCable] Broadcasting to #{broadcasting}: #{message.inspect.truncate(300)}" }
+
+            payload = { broadcasting: broadcasting, message: message, coder: coder }
+            ActiveSupport::Notifications.instrument("broadcast.action_cable", payload) do
+              encoded = coder ? coder.encode(message) : message
+              server.pubsub.broadcast broadcasting, encoded
+            end
+          end
+        end
+    end
+  end
+end

data/lib/action_cable/server/configuration.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "rack"
+
+module ActionCable
+  module Server
+    # # Action Cable Server Configuration
+    #
+    # An instance of this configuration object is available via
+    # ActionCable.server.config, which allows you to tweak Action Cable
+    # configuration in a Rails config initializer.
+    class Configuration
+      attr_accessor :logger, :log_tags
+      attr_accessor :connection_class, :worker_pool_size, :executor_pool_size
+      attr_accessor :disable_request_forgery_protection, :allowed_request_origins, :allow_same_origin_as_host, :filter_parameters
+      attr_accessor :cable, :url, :mount_path
+      attr_accessor :precompile_assets
+      attr_accessor :health_check_path, :health_check_application
+      attr_writer :pubsub_adapter
+
+      def initialize
+        @log_tags = []
+
+        @connection_class = -> { ActionCable::Connection::Base }
+        @worker_pool_size = 4
+        @executor_pool_size = 10
+
+        @disable_request_forgery_protection = false
+        @allow_same_origin_as_host = true
+        @filter_parameters = []
+
+        @health_check_application = ->(env) {
+          [200, { Rack::CONTENT_TYPE => "text/html", "date" => Time.now.httpdate }, []]
+        }
+      end
+
+      # Returns constant of subscription adapter specified in config/cable.yml or directly in the configuration.
+      # If the adapter cannot be found, this will default to the Redis adapter. Also makes
+      # sure proper dependencies are required.
+      def pubsub_adapter
+        # Provided explicitly in the configuration
+        return @pubsub_adapter.constantize if @pubsub_adapter
+
+        adapter = (cable.fetch("adapter") { "redis" })
+
+        # Require the adapter itself and give useful feedback about
+        #     1. Missing adapter gems and
+        #     2. Adapter gems' missing dependencies.
+        path_to_adapter = "action_cable/subscription_adapter/#{adapter}"
+        begin
+          require path_to_adapter
+        rescue LoadError => e
+          # We couldn't require the adapter itself. Raise an exception that points out
+          # config typos and missing gems.
+          if e.path == path_to_adapter
+            # We can assume that a non-builtin adapter was specified, so it's either
+            # misspelled or missing from Gemfile.
+            raise e.class, "Could not load the '#{adapter}' Action Cable pubsub adapter. Ensure that the adapter is spelled correctly in config/cable.yml and that you've added the necessary adapter gem to your Gemfile.", e.backtrace
+
+          # Bubbled up from the adapter require. Prefix the exception message with some
+          # guidance about how to address it and reraise.
+          else
+            raise e.class, "Error loading the '#{adapter}' Action Cable pubsub adapter. Missing a gem it depends on? #{e.message}", e.backtrace
+          end
+        end
+
+        adapter = adapter.camelize
+        adapter = "PostgreSQL" if adapter == "Postgresql"
+        "ActionCable::SubscriptionAdapter::#{adapter}".constantize
+      end
+    end
+  end
+end

data/lib/action_cable/server/connections.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionCable
+  module Server
+    # # Action Cable Server Connections
+    #
+    # Collection class for all the connections that have been established on this
+    # specific server. Remember, usually you'll run many Action Cable servers, so
+    # you can't use this collection as a full list of all of the connections
+    # established against your application. Instead, use RemoteConnections for that.
+    module Connections # :nodoc:
+      BEAT_INTERVAL = 3
+
+      def connections
+        @connections ||= []
+      end
+
+      def add_connection(connection)
+        connections << connection
+      end
+
+      def remove_connection(connection)
+        connections.delete connection
+      end
+
+      # WebSocket connection implementations differ on when they'll mark a connection
+      # as stale. We basically never want a connection to go stale, as you then can't
+      # rely on being able to communicate with the connection. To solve this, a 3
+      # second heartbeat runs on all connections. If the beat fails, we automatically
+      # disconnect.
+      def setup_heartbeat_timer
+        @heartbeat_timer ||= executor.timer(BEAT_INTERVAL) do
+          executor.post { connections.each(&:beat) }
+        end
+      end
+
+      def open_connections_statistics
+        connections.map(&:statistics)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "websocket/driver"
+
+module ActionCable
+  module Server
+    class Socket
+      #--
+      # This class is heavily based on faye-websocket-ruby
+      #
+      # Copyright (c) 2010-2015 James Coglan
+      class ClientSocket # :nodoc:
+        def self.determine_url(env)
+          scheme = secure_request?(env) ? "wss:" : "ws:"
+          "#{ scheme }//#{ env['HTTP_HOST'] }#{ env['REQUEST_URI'] }"
+        end
+
+        def self.secure_request?(env)
+          return true if env["HTTPS"] == "on"
+          return true if env["HTTP_X_FORWARDED_SSL"] == "on"
+          return true if env["HTTP_X_FORWARDED_SCHEME"] == "https"
+          return true if env["HTTP_X_FORWARDED_PROTO"] == "https"
+          return true if env["rack.url_scheme"] == "https"
+
+          false
+        end
+
+        CONNECTING = 0
+        OPEN       = 1
+        CLOSING    = 2
+        CLOSED     = 3
+
+        attr_reader :env, :url
+
+        def initialize(env, event_target, event_loop, protocols)
+          @env          = env
+          @event_target = event_target
+          @event_loop   = event_loop
+
+          @url = ClientSocket.determine_url(@env)
+
+          @driver = @driver_started = nil
+          @close_params = ["", 1006]
+
+          @ready_state = CONNECTING
+
+          # The driver calls +env+, +url+, and +write+
+          @driver = ::WebSocket::Driver.rack(self, protocols: protocols)
+
+          @driver.on(:open)    { |e| open }
+          @driver.on(:message) { |e| receive_message(e.data) }
+          @driver.on(:close)   { |e| begin_close(e.reason, e.code) }
+          @driver.on(:error)   { |e| emit_error(e.message) }
+
+          @stream = Stream.new(@event_loop, self)
+        end
+
+        def start_driver
+          return if @driver.nil? || @driver_started
+          @stream.hijack_rack_socket
+
+          if callback = @env["async.callback"]
+            callback.call([101, {}, @stream])
+          end
+
+          @driver_started = true
+          @driver.start
+        end
+
+        def rack_response
+          start_driver
+          [ -1, {}, [] ]
+        end
+
+        def write(data)
+          @stream.write(data)
+        rescue => e
+          emit_error e.message
+        end
+
+        def transmit(message)
+          return false if @ready_state > OPEN
+          case message
+          when Numeric then @driver.text(message.to_s)
+          when String  then @driver.text(message)
+          when Array   then @driver.binary(message)
+          else false
+          end
+        end
+
+        def close(code = nil, reason = nil)
+          code   ||= 1000
+          reason ||= ""
+
+          unless code == 1000 || (code >= 3000 && code <= 4999)
+            raise ArgumentError, "Failed to execute 'close' on WebSocket: " \
+                                "The code must be either 1000, or between 3000 and 4999. " \
+                                "#{code} is neither."
+          end
+
+          @ready_state = CLOSING unless @ready_state == CLOSED
+          @driver.close(reason, code)
+        end
+
+        def parse(data)
+          @driver.parse(data)
+        end
+
+        def client_gone
+          finalize_close
+        end
+
+        def alive?
+          @ready_state == OPEN
+        end
+
+        def protocol
+          @driver.protocol
+        end
+
+        private
+          def open
+            return unless @ready_state == CONNECTING
+            @ready_state = OPEN
+
+            @event_target.on_open
+          end
+
+          def receive_message(data)
+            return unless @ready_state == OPEN
+
+            @event_target.on_message(data)
+          end
+
+          def emit_error(message)
+            return if @ready_state >= CLOSING
+
+            @event_target.on_error(message)
+          end
+
+          def begin_close(reason, code)
+            return if @ready_state == CLOSED
+            @ready_state = CLOSING
+            @close_params = [reason, code]
+
+            @stream.shutdown if @stream
+            finalize_close
+          end
+
+          def finalize_close
+            return if @ready_state == CLOSED
+            @ready_state = CLOSED
+
+            @event_target.on_close(*@close_params)
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ActionCable
+  module Server
+    class Socket
+      # Allows us to buffer messages received from the WebSocket before the Connection has been fully initialized, and is ready to receive them.
+      class MessageBuffer # :nodoc:
+        def initialize(connection)
+          @connection = connection
+          @buffered_messages = []
+        end
+
+        def append(message)
+          if valid? message
+            if processing?
+              receive message
+            else
+              buffer message
+            end
+          else
+            connection.logger.error "Couldn't handle non-string message: #{message.class}"
+          end
+        end
+
+        def processing?
+          @processing
+        end
+
+        def process!
+          @processing = true
+          receive_buffered_messages
+        end
+
+        private
+          attr_reader :connection
+          attr_reader :buffered_messages
+
+          def valid?(message)
+            message.is_a?(String)
+          end
+
+          def receive(message)
+            connection.receive message
+          end
+
+          def buffer(message)
+            buffered_messages << message
+          end
+
+          def receive_buffered_messages
+            receive buffered_messages.shift until buffered_messages.empty?
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module ActionCable
+  module Server
+    class Socket
+      #--
+      # This class is heavily based on faye-websocket-ruby
+      #
+      # Copyright (c) 2010-2015 James Coglan
+      class Stream # :nodoc:
+        def initialize(event_loop, socket)
+          @event_loop    = event_loop
+          @socket_object = socket
+          @stream_send   = socket.env["stream.send"]
+
+          @rack_hijack_io = nil
+          @write_lock = Mutex.new
+
+          @write_head = nil
+          @write_buffer = Queue.new
+        end
+
+        def each(&callback)
+          @stream_send ||= callback
+        end
+
+        def close
+          shutdown
+          @socket_object.client_gone
+        end
+
+        def shutdown
+          clean_rack_hijack
+        end
+
+        def write(data)
+          if @stream_send
+            return @stream_send.call(data)
+          end
+
+          if @write_lock.try_lock
+            begin
+              if @write_head.nil? && @write_buffer.empty?
+                written = @rack_hijack_io.write_nonblock(data, exception: false)
+
+                case written
+                when :wait_writable
+                  # proceed below
+                when data.bytesize
+                  return data.bytesize
+                else
+                  @write_head = data.byteslice(written, data.bytesize)
+                  @event_loop.writes_pending @rack_hijack_io
+
+                  return data.bytesize
+                end
+              end
+            ensure
+              @write_lock.unlock
+            end
+          end
+
+          @write_buffer << data
+          @event_loop.writes_pending @rack_hijack_io
+
+          data.bytesize
+        rescue EOFError, Errno::ECONNRESET
+          @socket_object.client_gone
+        end
+
+        def flush_write_buffer
+          @write_lock.synchronize do
+            loop do
+              if @write_head.nil?
+                return true if @write_buffer.empty?
+                @write_head = @write_buffer.pop
+              end
+
+              written = @rack_hijack_io.write_nonblock(@write_head, exception: false)
+              case written
+              when :wait_writable
+                return false
+              when @write_head.bytesize
+                @write_head = nil
+              else
+                @write_head = @write_head.byteslice(written, @write_head.bytesize)
+                return false
+              end
+            end
+          end
+        end
+
+        def receive(data)
+          @socket_object.parse(data)
+        end
+
+        def hijack_rack_socket
+          return unless @socket_object.env["rack.hijack"]
+
+          # This should return the underlying io according to the SPEC:
+          @rack_hijack_io = @socket_object.env["rack.hijack"].call
+          # Retain existing behavior if required:
+          @rack_hijack_io ||= @socket_object.env["rack.hijack_io"]
+
+          @event_loop.attach(@rack_hijack_io, self)
+        end
+
+        private
+          def clean_rack_hijack
+            return unless @rack_hijack_io
+            @event_loop.detach(@rack_hijack_io, self)
+            @rack_hijack_io = nil
+          end
+      end
+    end
+  end
+end