anycable-rack-server 0.1.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e57a096cf575590410db4c25e824d0b754af2b85eb0927e4d9fdf553da4ccea
-  data.tar.gz: e6c5fce5b74f12bc41ce06955812cff608f50c4c66b063a459fa34ca8ed5e8e1
+  metadata.gz: ac33d07a88c1d94d982a7068f7636fc74013dd13e18a08ba29019c1b6e90bdb1
+  data.tar.gz: c655148349178d792f6609202762845189669053a14f89aa4a5f0c6efae67ff6
 SHA512:
-  metadata.gz: 304f417fc3d477625effcc7134c81708d222df3da565613f4f5878b5c0365fecd5ed2a3e9620cc692976051f9a634a66623f8adfce2729664f34882135eeec2b
-  data.tar.gz: d5a926617db60ec606f15b73189da24ed80d69012e87b8b4968ea6e0c1e0b7f26b86a3af593a48804f575dfd2c5c7867070555df968c69ba43926d4c97df4501
+  metadata.gz: 4ecbcb8c30cfa5e4b79948bc37c06405068d80bb192f53d98901d7177110da4822a20eff456a12fb7da5e7a3c3f8757ad219acb0befb2d7cd705288b3b1a3b12
+  data.tar.gz: a687c493138b5e0c7429e6a58c1b99ea4388a8b988988f0cc4bcab656db4789494e6b0fb05d59936794dfb6a99dc1b4868b90f82c551c049a2c33cf1c9c78d98

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,59 +28,96 @@ 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
 ```
 
-## Running RPC from the same process
+## Broadcast adapters
+
+AnyCable Rack supports Redis (default) and HTTP broadcast adapters (see [the documentation](https://docs.anycable.io/#/ruby/broadcast_adapters)).
+
+Broadcast adapter is inherited from AnyCable configuration (so, you don't need to configure it twice).
 
-The goal of the Rack server is to simplify the development/testing process. But we still have to run the RPC server.
+### Using HTTP broadcast adapter
 
-This gem also provides a way to run RPC server from the same process (spawning a new process):
+### With Rack
 
 ```ruby
-# in Rack app
+AnyCable::Rack.config.broadast_adapter = :http
 
-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
-)
+ws_server = AnyCable::Rack::Server
 
-# in Rails app you can just specify the configuration parameter (`false` by default)
-# and we'll take care of it
-config.any_cable_rack.run_rpc = true
+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.
+
 ## Testing
 
 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,17 @@
 # frozen_string_literal: true
 
+require "anycable/rack/version"
+require "anycable/rack/config"
 require "anycable/rack/server"
+
+module AnyCable
+  module Rack
+    class << self
+      def config
+        @config ||= Config.new
+      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"], coder)
+          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/coders/json.rb

@@ -5,7 +5,7 @@ require "json"
 module AnyCable
   module Rack
     module Coders
-      module JSON # :nodoc:
+      module Json # :nodoc:
         class << self
           def decode(json_str)
             ::JSON.parse(json_str)

data/lib/anycable/rack/coders/msgpack.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+gem "msgpack", "~> 1.4"
+require "msgpack"
+
+module AnyCable
+  module Rack
+    module Coders
+      module Msgpack # :nodoc:
+        class << self
+          def decode(bin)
+            MessagePack.unpack(bin)
+          end
+
+          def encode(ruby_obj)
+            BinaryFrame.new(MessagePack.pack(ruby_obj))
+          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,
+                  coder: :json,
+                  rpc_addr: "localhost:50051",
+                  rpc_client_pool_size: 5,
+                  rpc_client_timeout: 5,
+                  http_broadcast_path: "/_anycable_rack_broadcast"
+    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,20 +54,21 @@ 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
 
       private
 
       def transmit(cable_message)
-        socket.transmit(encode(cable_message))
+        encoded = encode(cable_message)
+        socket.transmit(encoded)
       end
 
       def close
@@ -77,12 +79,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 +88,9 @@ module AnyCable
           identifiers: @_identifiers,
           subscriptions: @_subscriptions.to_a,
           headers: headers,
-          path: request_path
+          url: request.url,
+          state: @_cstate,
+          channels_state: @_istate
         )
       end
 
@@ -99,7 +99,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
 
@@ -130,16 +134,23 @@ module AnyCable
       end
 
       def process_command(response, identifier)
-        response.transmissions.each { |transmission| transmit(decode(transmission)) }
+        response.transmissions.each { |transmission| transmit(decode_transmission(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(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}")
@@ -171,6 +182,10 @@ module AnyCable
         coder.encode(cable_message)
       end
 
+      def decode_transmission(json_message)
+        JSON.parse(json_message)
+      end
+
       def decode(websocket_message)
         coder.decode(websocket_message)
       end