anycable-rack-server 0.1.0 → 0.4.0

data/lib/anycable/rack/hub.rb

@@ -6,6 +6,8 @@ module AnyCable
   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
@@ -16,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
@@ -63,12 +71,31 @@ module AnyCable
         end
 
         list.each do |(channel_id, sockets)|
-          decoded = coder.decode(message)
+          decoded = JSON.parse(message)
           cmessage = channel_message(channel_id, decoded, coder)
           sockets.each { |socket| socket.transmit(cmessage) }
         end
       end
 
+      def broadcast_all(message)
+        sockets.each_key { |socket| socket.transmit(message) }
+      end
+
+      def disconnect(identifier, reconnect, coder)
+        sockets = @sync.synchronize do
+          return unless @streams[INTERNAL_STREAM].key?(identifier)
+
+          @streams[INTERNAL_STREAM][identifier].to_a
+        end
+
+        msg = disconnect_message("remote", reconnect, coder)
+
+        sockets.each do |socket|
+          socket.transmit(msg)
+          socket.close
+        end
+      end
+
       def close_all
         hub.sockets.dup.each do |socket|
           hub.remove_socket(socket)
@@ -87,6 +114,10 @@ module AnyCable
       def channel_message(channel_id, message, coder)
         coder.encode(identifier: channel_id, message: message)
       end
+
+      def disconnect_message(reason, reconnect, coder)
+        coder.encode({type: :disconnect, reason: reason, reconnect: reconnect})
+      end
     end
   end
 end

data/lib/anycable/rack/middleware.rb

@@ -9,18 +9,18 @@ require "anycable/rack/socket"
 module AnyCable
   module Rack
     class Middleware # :nodoc:
-      PROTOCOLS = ["actioncable-v1-json", "actioncable-unsupported"].freeze
+      PROTOCOLS = ["actioncable-v1-json", "actioncable-v1-msgpack", "actioncable-unsupported"].freeze
       attr_reader :pinger,
-                  :hub,
-                  :coder,
-                  :rpc_host,
-                  :header_names
-
-      def initialize(pinger:, hub:, coder:, rpc_host:, header_names:)
-        @pinger    = pinger
-        @hub       = hub
-        @coder     = coder
-        @rpc_host  = rpc_host
+        :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
 
@@ -59,7 +59,7 @@ module AnyCable
       end
 
       def not_found
-        [404, { "Content-Type" => "text/plain" }, ["Not Found"]]
+        [404, {"Content-Type" => "text/plain"}, ["Not Found"]]
       end
 
       def websocket?(env)
@@ -71,7 +71,7 @@ module AnyCable
           socket,
           hub: hub,
           coder: coder,
-          rpc_host: rpc_host,
+          rpc_client: rpc_client,
           headers: fetch_headers(socket.request)
         )
         socket.onopen { connection.handle_open }
@@ -86,8 +86,8 @@ module AnyCable
 
       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?
+          header_val = request.env["HTTP_#{name.tr("-", "_").upcase}"]
+          acc[name] = header_val unless header_val.nil? || header_val.empty?
         end
       end
     end

data/lib/anycable/rack/pinger.rb

@@ -8,7 +8,10 @@ module AnyCable
     class Pinger
       INTERVAL = 3
 
-      def initialize
+      attr_reader :coder
+
+      def initialize(coder)
+        @coder = coder
         @_sockets = []
         @_stopped = false
       end
@@ -45,7 +48,7 @@ module AnyCable
       private
 
       def ping_message(time)
-        { type: :ping, message: time }.to_json
+        coder.encode({type: :ping, message: time})
       end
     end
   end

data/lib/anycable/rack/railtie.rb

@@ -3,48 +3,24 @@
 module AnyCable
   module Rack
     class Railtie < ::Rails::Railtie # :nodoc: all
-      class Config < Anyway::Config
-        config_name :anycable_rack
-        env_prefix "ANYCABLE_RACK"
-
-        attr_config mount_path: "/cable",
-                    headers: AnyCable::Rack::Server::DEFAULT_HEADERS,
-                    rpc_port: 50_051,
-                    rpc_host: "localhost",
-                    run_rpc: false,
-                    running_rpc: false
-
-        private :running_rpc=
-      end
-
       config.before_configuration do
-        config.any_cable_rack = Config.new
+        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
 
-          # Only if AnyCable adapter is used
-          next unless ::ActionCable.server.config.cable&.fetch("adapter", nil) == "any_cable"
+          next unless config.mount_path
 
-          server = AnyCable::Rack::Server.new(
-            headers: config.headers,
-            rpc_host: "#{config.rpc_host}:#{config.rpc_port}"
-          )
+          server = AnyCable::Rack::Server.new
 
           app.routes.prepend do
             mount server => config.mount_path
-          end
 
-          if config.run_rpc && !config.running_rpc
-            AnyCable::Rack::RPCRunner.run(
-              rpc_host: "[::]:#{config.rpc_port}",
-              root_dir: ::Rails.root.to_s,
-              env: {
-                "ANYCABLE_RACK_RUNNING_RPC" => "true"
-              }
-            )
+            if AnyCable.config.broadcast_adapter.to_s == "http"
+              mount server.broadcast => config.http_broadcast_path
+            end
           end
 
           server.start!

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

@@ -1,41 +1,68 @@
 # frozen_string_literal: true
 
-require "grpc"
+require "connection_pool"
+require "anycable/grpc"
 
 module AnyCable
   module Rack
     module RPC
       # AnyCable RPC client
       class Client
-        attr_reader :stub
+        attr_reader :pool, :metadata
 
-        def initialize(host)
-          @stub = AnyCable::RPC::Service.rpc_stub_class.new(host, :this_channel_is_insecure)
+        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:, path:)
-          request = ConnectionRequest.new(headers: headers, path: path)
-          stub.connect(request)
+        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:)
+        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
+            data: data,
+            env: Env.new(
+              headers: headers,
+              url: url,
+              cstate: connection_state,
+              istate: state
+            )
           )
-          stub.command(message)
+          pool.with do |stub|
+            stub.command(message, metadata)
+          end
         end
 
-        def disconnect(identifiers:, subscriptions:, headers:, path:)
+        def disconnect(identifiers:, subscriptions:, headers:, url:, state: nil, channels_state: nil)
           request = DisconnectRequest.new(
             identifiers: identifiers,
             subscriptions: subscriptions,
-            headers: headers,
-            path: path
+            env: Env.new(
+              headers: headers,
+              url: url,
+              cstate: state,
+              istate: encode_istate(channels_state)
+            )
           )
-          stub.disconnect(request)
+          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

data/lib/anycable/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

@@ -7,52 +7,45 @@ require "anycable/rack/pinger"
 require "anycable/rack/errors"
 require "anycable/rack/middleware"
 require "anycable/rack/logging"
-require "anycable/rack/rpc_runner"
-require "anycable/rack/broadcast_subscribers/redis_subscriber"
-require "anycable/rack/coders/json"
+require "anycable/rack/broadcast_subscribers/base_subscriber"
 
 module AnyCable # :nodoc: all
   module Rack
     class Server
       include Logging
 
-      DEFAULT_HEADERS = %w[cookie x-api-token].freeze
-
-      attr_reader :broadcast,
-                  :coder,
-                  :hub,
-                  :middleware,
-                  :pinger,
-                  :pubsub_channel,
-                  :rpc_host,
-                  :headers
-
-      def initialize(*args)
-        options = args.last.is_a?(Hash) ? args.last : {}
-
+      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
-        @coder = options.fetch(:coder, Coders::JSON)
-        @pubsub_channel = pubsub_channel
-
-        @headers = options.fetch(:headers, DEFAULT_HEADERS)
-        @rpc_host = options.fetch(:rpc_host)
-
-        @broadcast = BroadcastSubscribers::RedisSubscriber.new(
-          hub: hub,
-          coder: coder,
-          **AnyCable.config.to_redis_params
+        @coder = resolve_coder(config.coder)
+        @pinger = Pinger.new(coder)
+
+        @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: headers,
+          header_names: config.headers,
           pinger: pinger,
           hub: hub,
-          rpc_host: rpc_host,
+          rpc_client: rpc_client,
           coder: coder
         )
 
-        log(:info) { "Using RPC server at #{rpc_host}" }
+        log(:info) { "Connecting to RPC server at #{config.rpc_addr}" }
       end
       # rubocop:enable
 
@@ -61,13 +54,17 @@ module AnyCable # :nodoc: all
 
         pinger.run
 
-        broadcast.subscribe(AnyCable.config.redis_channel)
-
-        log(:info) { "Subscribed to #{AnyCable.config.redis_channel}" }
+        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
@@ -76,7 +73,7 @@ module AnyCable # :nodoc: all
         return unless started?
 
         @_started = false
-        broadcast_subscriber.unsubscribe(@_redis_channel)
+        broadcast_subscriber.stop
         pinger.stop
         hub.close_all
       end
@@ -86,7 +83,37 @@ module AnyCable # :nodoc: all
       end
 
       def inspect
-        "#<AnyCable::Rack::Server(rpc_host: #{rpc_host}, headers: [#{headers.join(', ')}])>"
+        "#<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
+
+      def resolve_coder(name)
+        require "anycable/rack/coders/#{name}"
+        AnyCable::Rack::Coders.const_get(name.capitalize)
       end
     end
   end