anycable-rack-server 0.0.1 → 0.3.0

data/lib/anycable/{rack-server → rack}/errors.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
 module AnyCable
-  module RackServer
+  module Rack
     module Errors
       class HijackNotAvailable < RuntimeError; end
-      class UnknownCommand < StandardError; end
       class MiddlewareSetup < StandardError; end
     end
   end

data/lib/anycable/{rack-server → rack}/hub.rb

@@ -1,9 +1,13 @@
 # frozen_string_literal: true
 
+require "set"
+
 module AnyCable
-  module RackServer
+  module Rack
     # From https://github.com/rails/rails/blob/v5.0.1/actioncable/lib/action_cable/subscription_adapter/subscriber_map.rb
     class Hub
+      INTERNAL_STREAM = :__internal__
+
       attr_reader :streams, :sockets
 
       def initialize
@@ -14,6 +18,12 @@ module AnyCable
         @sync = Mutex.new
       end
 
+      def add_socket(socket, identifier)
+        @sync.synchronize do
+          @streams[INTERNAL_STREAM][identifier] << socket
+        end
+      end
+
       def add_subscriber(stream, socket, channel)
         @sync.synchronize do
           @streams[stream][channel] << socket
@@ -67,6 +77,32 @@ module AnyCable
         end
       end
 
+      def broadcast_all(message)
+        sockets.each_key { |socket| socket.transmit(message) }
+      end
+
+      def disconnect(identifier, reconnect)
+        sockets = @sync.synchronize do
+          return unless @streams[INTERNAL_STREAM].key?(identifier)
+
+          @streams[INTERNAL_STREAM][identifier].to_a
+        end
+
+        msg = disconnect_message("remote", reconnect)
+
+        sockets.each do |socket|
+          socket.transmit(msg)
+          socket.close
+        end
+      end
+
+      def close_all
+        hub.sockets.dup.each do |socket|
+          hub.remove_socket(socket)
+          socket.close
+        end
+      end
+
       private
 
       def cleanup(stream, socket, channel)
@@ -78,6 +114,11 @@ module AnyCable
       def channel_message(channel_id, message, coder)
         coder.encode(identifier: channel_id, message: message)
       end
+
+      # FIXME: coder support?
+      def disconnect_message(reason, reconnect)
+        {type: :disconnect, reason: reason, reconnect: reconnect}.to_json
+      end
     end
   end
 end

data/lib/anycable/{rack-server → rack}/logging.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module AnyCable
-  module RackServer
+  module Rack
     module Logging # :nodoc:
-      PREFIX = 'AnycableRackServer'
+      PREFIX = "AnyCableRackServer"
 
       private
 

data/lib/anycable/rack/middleware.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "websocket"
+
+require "anycable/rack/connection"
+require "anycable/rack/errors"
+require "anycable/rack/socket"
+
+module AnyCable
+  module Rack
+    class Middleware # :nodoc:
+      PROTOCOLS = ["actioncable-v1-json", "actioncable-unsupported"].freeze
+      attr_reader :pinger,
+        :hub,
+        :coder,
+        :rpc_client,
+        :header_names
+
+      def initialize(pinger:, hub:, coder:, rpc_client:, header_names:)
+        @pinger = pinger
+        @hub = hub
+        @coder = coder
+        @rpc_client = rpc_client
+        @header_names = header_names
+      end
+
+      def call(env)
+        return not_found unless websocket?(env)
+
+        rack_hijack(env)
+        listen_socket(env)
+
+        [-1, {}, []]
+      end
+
+      private
+
+      def handshake
+        @handshake ||= WebSocket::Handshake::Server.new(protocols: PROTOCOLS)
+      end
+
+      def rack_hijack(env)
+        raise Errors::HijackNotAvailable unless env["rack.hijack"]
+
+        env["rack.hijack"].call
+        send_handshake(env)
+      end
+
+      def send_handshake(env)
+        handshake.from_rack(env)
+        env["rack.hijack_io"].write(handshake.to_s)
+      end
+
+      def listen_socket(env)
+        socket = Socket.new(env, env["rack.hijack_io"], handshake.version)
+        init_connection(socket)
+        init_pinger(socket)
+        socket.listen
+      end
+
+      def not_found
+        [404, {"Content-Type" => "text/plain"}, ["Not Found"]]
+      end
+
+      def websocket?(env)
+        env["HTTP_UPGRADE"] == "websocket"
+      end
+
+      def init_connection(socket)
+        connection = Connection.new(
+          socket,
+          hub: hub,
+          coder: coder,
+          rpc_client: rpc_client,
+          headers: fetch_headers(socket.request)
+        )
+        socket.onopen { connection.handle_open }
+        socket.onclose { connection.handle_close }
+        socket.onmessage { |data| connection.handle_command(data) }
+      end
+
+      def init_pinger(socket)
+        pinger.add(socket)
+        socket.onclose { pinger.remove(socket) }
+      end
+
+      def fetch_headers(request)
+        header_names.each_with_object({}) do |name, acc|
+          header_val = request.env["HTTP_#{name.tr("-", "_").upcase}"]
+          acc[name] = header_val unless header_val.nil? || header_val.empty?
+        end
+      end
+    end
+  end
+end

data/lib/anycable/{rack-server → rack}/pinger.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
+require "json"
+
 module AnyCable
-  module RackServer
+  module Rack
     # Sends pings to sockets
     class Pinger
       INTERVAL = 3
@@ -9,7 +11,6 @@ module AnyCable
       def initialize
         @_sockets = []
         @_stopped = false
-        run
       end
 
       def add(socket)
@@ -24,7 +25,6 @@ module AnyCable
         @_stopped = true
       end
 
-      # rubocop: disable Metrics/MethodLength
       def run
         Thread.new do
           loop do
@@ -41,12 +41,11 @@ module AnyCable
           end
         end
       end
-      # rubocop: enable Metrics/MethodLength
 
       private
 
       def ping_message(time)
-        { type: :ping, message: time }.to_json
+        {type: :ping, message: time}.to_json
       end
     end
   end

data/lib/anycable/rack/railtie.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module Rack
+    class Railtie < ::Rails::Railtie # :nodoc: all
+      config.before_configuration do
+        config.any_cable_rack = AnyCable::Rack.config
+      end
+
+      initializer "anycable.rack.mount", after: "action_cable.routes" do
+        config.after_initialize do |app|
+          config = app.config.any_cable_rack
+
+          next unless config.mount_path
+
+          server = AnyCable::Rack::Server.new
+
+          app.routes.prepend do
+            mount server => config.mount_path
+
+            if AnyCable.config.broadcast_adapter.to_s == "http"
+              mount server.broadcast => config.http_broadcast_path
+            end
+          end
+
+          server.start!
+        end
+      end
+    end
+  end
+end

data/lib/anycable/rack/rpc/client.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "connection_pool"
+require "anycable/grpc"
+
+module AnyCable
+  module Rack
+    module RPC
+      # AnyCable RPC client
+      class Client
+        attr_reader :pool, :metadata
+
+        def initialize(host:, size:, timeout:)
+          @pool = ConnectionPool.new(size: size, timeout: timeout) do
+            AnyCable::GRPC::Service.rpc_stub_class.new(host, :this_channel_is_insecure)
+          end
+          @metadata = {metadata: {"protov" => "v1"}}.freeze
+        end
+
+        def connect(headers:, url:)
+          request = ConnectionRequest.new(env: Env.new(headers: headers, url: url))
+          pool.with do |stub|
+            stub.connect(request, metadata)
+          end
+        end
+
+        def command(command:, identifier:, connection_identifiers:, data:, headers:, url:, connection_state: nil, state: nil)
+          message = CommandMessage.new(
+            command: command,
+            identifier: identifier,
+            connection_identifiers: connection_identifiers,
+            data: data,
+            env: Env.new(
+              headers: headers,
+              url: url,
+              cstate: connection_state,
+              istate: state
+            )
+          )
+          pool.with do |stub|
+            stub.command(message, metadata)
+          end
+        end
+
+        def disconnect(identifiers:, subscriptions:, headers:, url:, state: nil, channels_state: nil)
+          request = DisconnectRequest.new(
+            identifiers: identifiers,
+            subscriptions: subscriptions,
+            env: Env.new(
+              headers: headers,
+              url: url,
+              cstate: state,
+              istate: encode_istate(channels_state)
+            )
+          )
+          pool.with do |stub|
+            stub.disconnect(request, metadata)
+          end
+        end
+
+        private
+
+        # We need a string -> string Hash here
+        def encode_istate(state)
+          state.transform_values(&:to_json)
+        end
+      end
+    end
+  end
+end

data/lib/anycable/{rack-server → rack}/rpc/rpc.proto

@@ -14,9 +14,20 @@ enum Status {
   FAILURE = 2;
 }
 
-message ConnectionRequest {
-  string path = 1;
+message Env {
+  string url = 1;
   map<string,string> headers = 2;
+  map<string,string> cstate = 3;
+  map<string,string> istate = 4;
+}
+
+message EnvResponse {
+  map<string,string> cstate = 1;
+  map<string,string> istate = 2;
+}
+
+message ConnectionRequest {
+  Env env = 3;
 }
 
 message ConnectionResponse {
@@ -24,6 +35,7 @@ message ConnectionResponse {
   string identifiers = 2;
   repeated string transmissions = 3;
   string error_msg = 4;
+  EnvResponse env = 5;
 }
 
 message CommandMessage {
@@ -31,6 +43,7 @@ message CommandMessage {
   string identifier = 2;
   string connection_identifiers = 3;
   string data = 4;
+  Env env = 5;
 }
 
 message CommandResponse {
@@ -40,13 +53,14 @@ message CommandResponse {
   repeated string streams = 4;
   repeated string transmissions = 5;
   string error_msg = 6;
+  EnvResponse env = 7;
+  repeated string stopped_streams = 8;
 }
 
 message DisconnectRequest {
   string identifiers = 1;
   repeated string subscriptions = 2;
-  string path = 3;
-  map<string,string> headers = 4;
+  Env env = 5;
 }
 
 message DisconnectResponse {

data/lib/anycable/rack/server.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "anycable"
+
+require "anycable/rack/hub"
+require "anycable/rack/pinger"
+require "anycable/rack/errors"
+require "anycable/rack/middleware"
+require "anycable/rack/logging"
+require "anycable/rack/broadcast_subscribers/base_subscriber"
+require "anycable/rack/coders/json"
+
+module AnyCable # :nodoc: all
+  module Rack
+    class Server
+      include Logging
+
+      attr_reader :config,
+        :broadcast,
+        :coder,
+        :hub,
+        :middleware,
+        :pinger,
+        :rpc_client,
+        :headers,
+        :rpc_cli
+
+      def initialize(config: AnyCable::Rack.config)
+        @config = config
+        @hub = Hub.new
+        @pinger = Pinger.new
+        # TODO: Support other coders
+        @coder = Coders::JSON
+
+        @broadcast = resolve_broadcast_adapter
+        @rpc_client = RPC::Client.new(
+          host: config.rpc_addr,
+          size: config.rpc_client_pool_size,
+          timeout: config.rpc_client_timeout
+        )
+
+        @middleware = Middleware.new(
+          header_names: config.headers,
+          pinger: pinger,
+          hub: hub,
+          rpc_client: rpc_client,
+          coder: coder
+        )
+
+        log(:info) { "Connecting to RPC server at #{config.rpc_addr}" }
+      end
+      # rubocop:enable
+
+      def start!
+        log(:info) { "Starting..." }
+
+        pinger.run
+
+        broadcast.start
+
+        @_started = true
+      end
+
+      def shutdown
+        log(:info) { "Shutting down..." }
+        Rack.rpc_server&.shutdown
+        hub.broadcast_all(coder.encode(type: "disconnect", reason: "server_restart", reconnect: true))
+      end
+
+      def started?
+        @_started == true
+      end
+
+      def stop
+        return unless started?
+
+        @_started = false
+        broadcast_subscriber.stop
+        pinger.stop
+        hub.close_all
+      end
+
+      def call(env)
+        middleware.call(env)
+      end
+
+      def inspect
+        "#<AnyCable::Rack::Server(rpc_addr: #{config.rpc_addr}, headers: [#{config.headers.join(", ")}])>"
+      end
+
+      private
+
+      def resolve_broadcast_adapter
+        adapter = AnyCable.config.broadcast_adapter.to_s
+        require "anycable/rack/broadcast_subscribers/#{adapter}_subscriber"
+
+        if adapter.to_s == "redis"
+          BroadcastSubscribers::RedisSubscriber.new(
+            hub: hub,
+            coder: coder,
+            channel: AnyCable.config.redis_channel,
+            **AnyCable.config.to_redis_params
+          )
+        elsif adapter.to_s == "http"
+          BroadcastSubscribers::HTTPSubscriber.new(
+            hub: hub,
+            coder: coder,
+            token: AnyCable.config.http_broadcast_secret,
+            path: config.http_broadcast_path
+          )
+        else
+          raise ArgumentError, "Unsupported broadcast adatper: #{adapter}. AnyCable Rack server only supports: redis, http"
+        end
+      end
+    end
+  end
+end