anycable-rack-server 0.1.0 → 0.2.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e57a096cf575590410db4c25e824d0b754af2b85eb0927e4d9fdf553da4ccea
-  data.tar.gz: e6c5fce5b74f12bc41ce06955812cff608f50c4c66b063a459fa34ca8ed5e8e1
+  metadata.gz: 30ae82e08a26ece6943ba290783ed093045d5dbac93613741321aa9d62486838
+  data.tar.gz: a506eaaf81f5982b9a8774b6f6b0beae3e06e00ebd3e5bda1607c58375b15c19
 SHA512:
-  metadata.gz: 304f417fc3d477625effcc7134c81708d222df3da565613f4f5878b5c0365fecd5ed2a3e9620cc692976051f9a634a66623f8adfce2729664f34882135eeec2b
-  data.tar.gz: d5a926617db60ec606f15b73189da24ed80d69012e87b8b4968ea6e0c1e0b7f26b86a3af593a48804f575dfd2c5c7867070555df968c69ba43926d4c97df4501
+  metadata.gz: 4ba8c7529041061a05e46c1de89c7f44da1733843026145bd6b4a658221c2f68bd85f05f137c878658dea0ca0a7df74bfc3bbcb6d221b7a2cc013316737549a1
+  data.tar.gz: 64031fb35d63ac3d1fa64a490b7b821b9dd3b5070fc888dbb9e51ed1a3b9c4977b5d4ba5268c4f36dbe58d467187945207fc7e5e21ba4b28c2de8c39dd697308

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019 Yulia Oletskaya
+Copyright (c) 2019-2020 Yulia Oletskaya, Vladimir Dementyev
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,4 +1,6 @@
-[![Gem Version](https://badge.fury.io/rb/anycable-rack-server.svg)](https://rubygems.org/gems/anycable-rack-server) [![Build Status](https://travis-ci.org/anycable/anycable-rack-server.svg?branch=master)](https://travis-ci.org/anycable/anycable-rack-server)
+[![Cult Of Martians](http://cultofmartians.com/assets/badges/badge.svg)](https://cultofmartians.com/tasks/anycable-ruby-server.html)
+[![Gem Version](https://badge.fury.io/rb/anycable-rack-server.svg)](https://rubygems.org/gems/anycable-rack-server)
+[![Build](https://github.com/anycable/anycable-rack-server/workflows/Build/badge.svg)](https://github.com/anycable/anycable-rack-server/actions)
 
 # anycable-rack-server
 
@@ -8,9 +10,7 @@
 
 ```ruby
 # Initialize server instance first.
-#
-# NOTE: you must run RPC server yourself and provide its host
-ws_server = AnyCable::Rack::Server.new rpc_host: "localhost:50051"
+ws_server = AnyCable::Rack::Server.new
 
 app = Rack::Builder.new do
   map "/cable" do
@@ -18,7 +18,7 @@ app = Rack::Builder.new do
   end
 end
 
-# NOTE: don't forget to call `start!` method 
+# NOTE: don't forget to call `start!` method
 ws_server.start!
 
 run app
@@ -28,48 +28,103 @@ run app
 
 Add `gem "anycable-rack-server"` to you `Gemfile` and make sure your Action Cable adapter is set to `:any_cable`. That's it! We automatically start AnyCable Rack server for your at `/cable` path.
 
-## Settings
+## Configuration
+
+AnyCable Rack Server uses [`anyway_config`](https://github.com/palkan/anyway_config) gem for configuration; thus it is possible to set configuration parameters through environment vars (prefixed with `ANYCABLE_`), `config/anycable.yml` file or `secrets.yml` when using Rails.
+
+**NOTE:** AnyCable Rack Server uses the same config name (i.e., env prefix, YML file name, etc.) as AnyCable itself.
+
+You can pass a config object as the option to `AnyCable::Rack::Server.new`:
+
+```ruby
+server = AnyCable::Server::Rack.new(config: AnyCable::Rack::Config.new(**params))
+```
+
+If no config is passed, a default, global, configuration would be used (`AnyCable::Rack.config`).
+
+When using Rails, `config.anycable_rack` points to `AnyCable::Rack.config`.
+
+### Headers
 
 You can customize the headers being sent with each gRPC request.
 
 Default headers: `'cookie', 'x-api-token'`.
 
-Can be specified via options:
+Can be specified via configuration:
 
 ```ruby
-ws_server = AnyCable::Rack::Server.new(
-  rpc_host: "localhost:50051",
-  headers: ["cookie", "x-my-header"]
-)
+AnyCable::Rack.config.headers = ["cookie", "x-my-header"]
 ```
 
-In case of Rails you can set server options via `config.any_cable_rack`:
+Or in Rails:
 
 ```ruby
 # <environment>.rb
 config.any_cable_rack.headers = %w[cookie]
+```
+
+### Rails-specific options
+
+```ruby
+# Mount WebSocket server at the specified path
 config.any_cable_rack.mount_path = "/cable"
 # NOTE: here we specify only the port (we assume that a server is running locally)
 config.any_cable_rack.rpc_port = 50051
 ```
 
+## Broadcast adapters
+
+AnyCable Rack supports Redis (default) and HTTP broadcast adapters (see [the documentation](https://docs.anycable.io/v1/#/ruby/broadcast_adapters)).
+
+Broadcast adapter is inherited from AnyCable configuration (so, you don't need to configure it twice).
+
+### Using HTTP broadcast adapter
+
+### With Rack
+
+```ruby
+AnyCable::Rack.config.broadast_adapter = :http
+
+ws_server = AnyCable::Rack::Server
+
+app = Rack::Builder.new do
+  map "/cable" do
+    run ws_server
+  end
+
+  map "/_anycable_rack_broadcast" do
+    run ws_server.broadcast
+  end
+end
+```
+
+### With Rails
+
+By default, we mount broadcasts endpoint at `/_anycable_rack_broadcast`.
+
+You can change this setting:
+
+```ruby
+config.any_cable_rack.http_broadcast_path = "/_my_broadcast"
+```
+
+**NOTE:** Don't forget to configure `http_broadcast_url` for AnyCable pointing to your web server and the specified broadcast path.
+
 ## Running RPC from the same process
 
 The goal of the Rack server is to simplify the development/testing process. But we still have to run the RPC server.
 
-This gem also provides a way to run RPC server from the same process (spawning a new process):
+This gem also provides a way to run RPC server within the same process.
+All you need to do is set `run_rpc = true` in the configuration:
 
 ```ruby
 # in Rack app
+AnyCable::Rack.config.run_rpc = true
 
-AnyCable::Rack::RPCRunner.run(
-  root_dir: "<path to your app root directory to run `anycable` from>",
-  rpc_host: "...", # optional host to run RPC server on (defaults to '[::]::50051')
-  command_args: [] # additional CLI arguments
-)
+# and only after that
+ws_server.start!
 
-# in Rails app you can just specify the configuration parameter (`false` by default)
-# and we'll take care of it
+# in Rails
 config.any_cable_rack.run_rpc = true
 ```
 
@@ -79,8 +134,8 @@ Run units with `bundle exec rake`.
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/anycable/anycable-rack-server.
+Bug reports and pull requests are welcome on GitHub at [https://github.com/anycable/anycable-rack-server](https://github.com/anycable/anycable-rack-server).
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT License](./LICENSE).

data/lib/anycable-rack-server.rb

@@ -1,4 +1,23 @@
 # frozen_string_literal: true
 
+require "anycable/rack/config"
 require "anycable/rack/server"
+
+module AnyCable
+  module Rack
+    class << self
+      def config
+        @config ||= Config.new
+      end
+
+      def rpc_server
+        return @rpc_server if instance_variable_defined?(:@rpc_server)
+
+        require "anycable/cli"
+        @rpc_server = AnyCable::CLI.new(embedded: true)
+      end
+    end
+  end
+end
+
 require "anycable/rack/railtie" if defined?(Rails)

data/lib/anycable/rack/broadcast_subscribers/base_subscriber.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "json"
+
+module AnyCable
+  module Rack
+    module BroadcastSubscribers
+      class BaseSubscriber
+        include Logging
+
+        attr_reader :hub, :coder
+
+        def initialize(hub:, coder:, **options)
+          @hub = hub
+          @coder = coder
+        end
+
+        def start
+          # no-op
+        end
+
+        def stop
+          # no-op
+        end
+
+        private
+
+        def handle_message(msg)
+          log(:debug) { "Received pub/sub message: #{msg}" }
+
+          data = JSON.parse(msg)
+          if data["stream"]
+            hub.broadcast(data["stream"], data["data"], coder)
+          elsif data["command"] == "disconnect"
+            hub.disconnect(data["payload"]["identifier"], data["payload"]["reconnect"])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/anycable/rack/broadcast_subscribers/http_subscriber.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "json"
+
+module AnyCable
+  module Rack
+    module BroadcastSubscribers
+      # HTTP Pub/Sub subscriber
+      class HTTPSubscriber < BaseSubscriber
+        attr_reader :token, :path
+
+        def initialize(**options)
+          super
+          @token = options[:token]
+          @path = options[:path]
+        end
+
+        def start
+          log(:info) { "Accepting pub/sub request at #{path}" }
+        end
+
+        def call(env)
+          req = ::Rack::Request.new(env)
+
+          return invalid_request unless req.post?
+
+          if token && req.get_header("HTTP_AUTHORIZATION") != "Bearer #{token}"
+            return invalid_request(401)
+          end
+
+          handle_message req.body.read
+
+          [201, {"Content-Type" => "text/plain"}, ["OK"]]
+        end
+
+        private
+
+        def invalid_request(code = 422)
+          [code, {"Content-Type" => "text/plain"}, ["Invalid request"]]
+        end
+      end
+    end
+  end
+end

data/lib/anycable/rack/broadcast_subscribers/redis_subscriber.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+gem "redis", "~> 4"
+
 require "redis"
 require "json"
 
@@ -7,34 +9,47 @@ module AnyCable
   module Rack
     module BroadcastSubscribers
       # Redis Pub/Sub subscriber
-      class RedisSubscriber
-        attr_reader :hub, :coder, :redis_conn, :threads
+      class RedisSubscriber < BaseSubscriber
+        attr_reader :redis_conn, :thread, :channel
 
-        def initialize(hub:, coder:, **options)
-          @hub        = hub
-          @coder      = coder
+        def initialize(hub:, coder:, channel:, **options)
+          super
           @redis_conn = ::Redis.new(options)
-          @threads    = {}
+          @channel = channel
         end
 
-        def subscribe(channel)
-          @threads[channel] = Thread.new do
-            redis_conn.subscribe(channel) do |on|
-              on.message { |_channel, msg| handle_message(msg) }
-            end
-          end
+        def start
+          subscribe(channel)
+
+          log(:info) { "Subscribed to #{channel}" }
         end
 
-        def unsubscribe(channel)
-          @threads[channel]&.terminate
-          @threads.delete(channel)
+        def stop
+          thread&.terminate
         end
 
-        private
+        def subscribe(channel)
+          @thread ||= Thread.new do
+            Thread.current.abort_on_exception = true
+
+            redis_conn.without_reconnect do
+              redis_conn.subscribe(channel) do |on|
+                on.subscribe do |chan, count|
+                  log(:debug) { "Redis subscriber connected to #{chan} (#{count})" }
+                end
+
+                on.unsubscribe do |chan, count|
+                  log(:debug) { "Redis subscribed disconnected from #{chan} (#{count})" }
+                end
 
-        def handle_message(msg)
-          data = JSON.parse(msg)
-          hub.broadcast(data["stream"], data["data"], coder)
+                on.message do |_channel, msg|
+                  handle_message(msg)
+                rescue
+                  log(:error) { "Failed to broadcast message: #{msg}" }
+                end
+              end
+            end
+          end
         end
       end
     end

data/lib/anycable/rack/config.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "anyway_config"
+
+module AnyCable
+  module Rack
+    class Config < Anyway::Config
+      DEFAULT_HEADERS = %w[cookie x-api-token].freeze
+
+      config_name :anycable
+      env_prefix "ANYCABLE"
+
+      attr_config mount_path: "/cable",
+                  headers: DEFAULT_HEADERS,
+                  rpc_addr: "localhost:50051",
+                  rpc_client_pool_size: 5,
+                  rpc_client_timeout: 5,
+                  http_broadcast_path: "/_anycable_rack_broadcast",
+                  run_rpc: false
+    end
+  end
+end

data/lib/anycable/rack/connection.rb

@@ -14,23 +14,24 @@ module AnyCable
       include Logging
 
       attr_reader :coder,
-                  :headers,
-                  :hub,
-                  :socket,
-                  :rpc_client,
-                  :sid
+        :headers,
+        :hub,
+        :socket,
+        :rpc_client,
+        :sid
 
-      def initialize(socket, hub:, coder:, rpc_host:, headers:)
+      def initialize(socket, hub:, coder:, rpc_client:, headers:)
         @socket = socket
         @coder = coder
         @headers = headers
         @hub = hub
         @sid = SecureRandom.hex(6)
 
-        @rpc_client = RPC::Client.new(rpc_host)
+        @rpc_client = rpc_client
 
-        @_identifiers   = "{}"
+        @_identifiers = "{}"
         @_subscriptions = Set.new
+        @_istate = {}
       end
 
       def handle_open
@@ -53,13 +54,13 @@ module AnyCable
         log(:debug) { "Command: #{decoded}" }
 
         case command
-        when "subscribe"   then subscribe(channel_identifier)
+        when "subscribe" then subscribe(channel_identifier)
         when "unsubscribe" then unsubscribe(channel_identifier)
-        when "message"     then send_message(channel_identifier, decoded["data"])
+        when "message" then send_message(channel_identifier, decoded["data"])
         else
           log(:error, "Command not found #{command}")
         end
-      rescue Exception => e
+      rescue Exception => e # rubocop:disable Lint/RescueException
         log(:error, "Failed to execute command #{command}: #{e.message}")
       end
 
@@ -77,12 +78,8 @@ module AnyCable
         socket.request
       end
 
-      def request_path
-        request.fullpath
-      end
-
       def rpc_connect
-        rpc_client.connect(headers: headers, path: request_path)
+        rpc_client.connect(headers: headers, url: request.url)
       end
 
       def rpc_disconnect
@@ -90,7 +87,8 @@ module AnyCable
           identifiers: @_identifiers,
           subscriptions: @_subscriptions.to_a,
           headers: headers,
-          path: request_path
+          url: request.url,
+          state: @_cstate
         )
       end
 
@@ -99,7 +97,11 @@ module AnyCable
           command: command,
           identifier: identifier,
           connection_identifiers: @_identifiers,
-          data: data
+          data: data,
+          headers: headers,
+          url: request.url,
+          connection_state: @_cstate,
+          state: @_istate[identifier]
         )
       end
 
@@ -133,13 +135,20 @@ module AnyCable
         response.transmissions.each { |transmission| transmit(decode(transmission)) }
         hub.remove_channel(socket, identifier) if response.stop_streams
         response.streams.each { |stream| hub.add_subscriber(stream, socket, identifier) }
+        response.stopped_streams.each { |stream| hub.remove_subscriber(stream, socket, identifier) }
+
+        @_istate[identifier] ||= {}
+        @_istate[identifier].merge!(response.env.istate&.to_h || {})
+
         close_connection if response.disconnect
       end
 
       def process_open(response)
+        response.transmissions&.each { |transmission| transmit(decode(transmission)) }
         if response.status == :SUCCESS
           @_identifiers = response.identifiers
-          response.transmissions.each { |transmission| transmit(decode(transmission)) }
+          @_cstate = response.env.cstate&.to_h || {}
+          hub.add_socket(socket, @_identifiers)
           log(:debug) { "Opened" }
         else
           log(:error, "RPC connection command failed: #{response.inspect}")

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
@@ -69,6 +77,25 @@ 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)
@@ -87,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/middleware.rb

@@ -11,16 +11,16 @@ module AnyCable
     class Middleware # :nodoc:
       PROTOCOLS = ["actioncable-v1-json", "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

@@ -45,7 +45,7 @@ module AnyCable
       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

@@ -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,5 +1,6 @@
 # frozen_string_literal: true
 
+require "connection_pool"
 require "grpc"
 
 module AnyCable
@@ -7,35 +8,53 @@ module AnyCable
     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::RPC::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)
           request = DisconnectRequest.new(
             identifiers: identifiers,
             subscriptions: subscriptions,
-            headers: headers,
-            path: path
+            env: Env.new(
+              headers: headers,
+              url: url,
+              cstate: state
+            )
           )
-          stub.disconnect(request)
+          pool.with do |stub|
+            stub.disconnect(request, metadata)
+          end
         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,8 +7,7 @@ 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/broadcast_subscribers/base_subscriber"
 require "anycable/rack/coders/json"
 
 module AnyCable # :nodoc: all
@@ -16,43 +15,39 @@ module AnyCable # :nodoc: all
     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
+        # 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: 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 +56,19 @@ module AnyCable # :nodoc: all
 
         pinger.run
 
-        broadcast.subscribe(AnyCable.config.redis_channel)
+        broadcast.start
 
-        log(:info) { "Subscribed to #{AnyCable.config.redis_channel}" }
+        Rack.rpc_server.run if config.run_rpc
 
         @_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 +77,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 +87,32 @@ 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
     end
   end

data/lib/anycable/rack/socket.rb

@@ -15,11 +15,11 @@ module AnyCable
         @socket = socket
         @version = version
 
-        @_open_handlers    = []
+        @_open_handlers = []
         @_message_handlers = []
-        @_close_handlers   = []
-        @_error_handlers   = []
-        @_active           = true
+        @_close_handlers = []
+        @_error_handlers = []
+        @_active = true
       end
 
       def transmit(data, type: :text)
@@ -29,7 +29,7 @@ module AnyCable
           type: type
         )
         socket.write(frame.to_s)
-      rescue IOError, Errno::EPIPE, Errno::ETIMEDOUT => e
+      rescue Exception => e # rubocop:disable Lint/RescueException
         log(:error, "Socket send failed: #{e}")
         close
       end
@@ -62,13 +62,11 @@ module AnyCable
             @_open_handlers.each(&:call)
             each_frame do |data|
               @_message_handlers.each do |handler|
-                begin
-                  handler.call(data)
-                rescue => e # rubocop: disable Style/RescueStandardError
-                  log(:error, "Socket receive failed: #{e}")
-                  @_error_handlers.each { |eh| eh.call(e, data) }
-                  close
-                end
+                handler.call(data)
+              rescue => e # rubocop: disable Style/RescueStandardError
+                log(:error, "Socket receive failed: #{e}")
+                @_error_handlers.each { |eh| eh.call(e, data) }
+                close
               end
             end
           ensure
@@ -104,7 +102,7 @@ module AnyCable
         frame = WebSocket::Frame::Outgoing::Server.new(version: version, type: :close, code: 1000)
         socket.write(frame.to_s) if frame.supported?
         socket.close
-      rescue IOError, Errno::EPIPE, Errno::ETIMEDOUT
+      rescue Exception # rubocop:disable Lint/RescueException
         # already closed
       end
 
@@ -113,8 +111,7 @@ module AnyCable
           Thread.current.abort_on_exception = true
           loop do
             sleep 5
-            time = Time.now.to_i
-            transmit({ message: time, type: :ping }.to_json)
+            transmit nil, type: :ping
           end
         end
 
@@ -137,7 +134,7 @@ module AnyCable
 
           framebuffer << data
 
-          while frame = framebuffer.next
+          while frame = framebuffer.next # rubocop:disable Lint/AssignmentInCondition
             case frame.type
             when :close
               return
@@ -146,7 +143,7 @@ module AnyCable
             end
           end
         end
-      rescue Errno::EHOSTUNREACH, Errno::ETIMEDOUT, Errno::ECONNRESET, IOError, Errno::EBADF => e
+      rescue Exception => e # rubocop:disable Lint/RescueException
         log(:error, "Socket frame error: #{e}")
         nil # client disconnected or timed out
       end

data/lib/anycable/rack/version.rb

@@ -2,6 +2,6 @@
 
 module AnyCable
   module Rack
-    VERSION = "0.1.0"
+    VERSION = "0.2.0.rc1"
   end
 end

metadata

@@ -1,71 +1,86 @@
 --- !ruby/object:Gem::Specification
 name: anycable-rack-server
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0.rc1
 platform: ruby
 authors:
 - Yulia Oletskaya
+- Vladimir Dementyev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-14 00:00:00.000000000 Z
+date: 2020-06-25 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: anyway_config
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.2
 - !ruby/object:Gem::Dependency
   name: anycable
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: websocket
+  name: connection_pool
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '2.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
-  name: redis
+  name: websocket
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: anyt
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.4
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.4
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -96,32 +111,46 @@ dependencies:
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.3'
+        version: '4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.3'
+        version: '4'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.60.0
+        version: '0.80'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.60.0
+        version: '0.80'
 description: AnyCable-compatible Ruby Rack middleware
 email: yulia.oletskaya@gmail.com
 executables: []
@@ -131,8 +160,11 @@ files:
 - LICENSE
 - README.md
 - lib/anycable-rack-server.rb
+- lib/anycable/rack/broadcast_subscribers/base_subscriber.rb
+- lib/anycable/rack/broadcast_subscribers/http_subscriber.rb
 - lib/anycable/rack/broadcast_subscribers/redis_subscriber.rb
 - lib/anycable/rack/coders/json.rb
+- lib/anycable/rack/config.rb
 - lib/anycable/rack/connection.rb
 - lib/anycable/rack/errors.rb
 - lib/anycable/rack/hub.rb
@@ -142,7 +174,6 @@ files:
 - lib/anycable/rack/railtie.rb
 - lib/anycable/rack/rpc/client.rb
 - lib/anycable/rack/rpc/rpc.proto
-- lib/anycable/rack/rpc_runner.rb
 - lib/anycable/rack/server.rb
 - lib/anycable/rack/socket.rb
 - lib/anycable/rack/version.rb
@@ -161,13 +192,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
-summary: Anycable Rack Server
+summary: AnyCable Rack Server
 test_files: []

data/lib/anycable/rack/rpc_runner.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require "anycable"
-require "anycable/rack/logging"
-
-$stdout.sync = true
-
-module AnyCable
-  module Rack
-    # Runs AnyCable CLI in a separate process
-    module RPCRunner
-      class << self
-        include Logging
-
-        attr_accessor :running, :pid
-
-        def run(root_dir:, command_args: [], rpc_host: "[::]:50051", env: {})
-          return if @running
-
-          command_args << "--rpc-host=\"#{rpc_host}\""
-
-          command = "bundle exec anycable #{command_args.join(' ')}"
-
-          log(:info, "Running AnyCable (from #{root_dir}): #{command}")
-
-          out = AnyCable.config.debug? ? STDOUT : IO::NULL
-
-          @pid = Dir.chdir(root_dir) do
-            Process.spawn(
-              env,
-              command,
-              out: out,
-              err: out
-            )
-          end
-
-          log(:debug) { "AnyCable PID: #{pid}" }
-
-          @running = true
-
-          at_exit { stop }
-        end
-
-        def stop
-          return unless running
-
-          log(:debug) { "Terminate PID: #{pid}" }
-
-          Process.kill("SIGKILL", pid)
-
-          @running = false
-        end
-
-        def running?
-          running == true
-        end
-      end
-    end
-  end
-end