anycable-rack-server 0.0.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 416a34b5853c2b0f81f4693e59fe4c9b10021b41fc8eb2e710b8fd82b5a67c04
-  data.tar.gz: fcb0f8b569adc737b704025393237b573b7de616ea4e5deedaa77e442a51bc09
+  metadata.gz: 61ac3aaa885caabfc4e6761dc77f3c8f792d966c13dc598b6c100c58c160c334
+  data.tar.gz: f1317d8d0b6d38266bd8c9f6866c2d4e1e7e24225b758d2e8c06ef6176251cc4
 SHA512:
-  metadata.gz: 7cd8bcd7b5afda208b3df2e476b0729faf9fbfbfd9d6fb36735f26cba48b9589e3a4704a9dbc69c6743bdf4f209c2ee9e6d44f8521a5fc89036a42859f0f9090
-  data.tar.gz: 68f4b98948bb3ec8fb330947faed0f933ee7dd12dab2f1ca6abbb35af41ab3f7b7f3ad720ea74be82af486f309b250c340603e8e10716478a03975704c3ba3f5
+  metadata.gz: 577a63b90c45172860302d22893db7828f748a80dc3fe8443a819c78b4c91eed10d61fecf70e6d8aeb00f50daa667cb31d9dcfe661d73e20ae65027ebbdb6a87
+  data.tar.gz: 4d1c8fa0810a6ea93ebebcbbc868e0713e648cebfe1af0d6761205b396b0a44cc2c79b716f50d740314c8d8faa382f873124e60275430563faa8460e019754b6

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018 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,37 +1,123 @@
+[![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
 
-AnyCable-compatible Rack hijack based Ruby Web Socket server middleware designed for development and testing purposes.
+[AnyCable](https://anycable.io)-compatible Rack hijack based Ruby Web Socket server designed for development and testing purposes.
 
-## Usage
+## Using with Rack
 
-Mount the rack middleware
 ```ruby
-# config/routes.rb
-Rails.application.routes.draw do
-  mount AnyCable::Rack.new => '/cable'
+# Initialize server instance first.
+ws_server = AnyCable::Rack::Server.new
+
+app = Rack::Builder.new do
+  map "/cable" do
+    run ws_server
+  end
 end
+
+# NOTE: don't forget to call `start!` method
+ws_server.start!
+
+run app
 ```
 
-## Settings
+## Usage with Rails
+
+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.
+
+## Configuration
 
-Customizable options: headers being sent with each gRPC request. The gem uses AnyCable config for redis and gRPC host settings.
+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 env variable
+Can be specified via configuration:
+
+```ruby
+AnyCable::Rack.config.headers = ["cookie", "x-my-header"]
+```
+
+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
 ```
-ANYCABLE_HEADERS=cookie,x-api-token,origin
+
+## 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).
+
+### 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
 ```
 
-Or
+### With Rails
+
+By default, we mount broadcasts endpoint at `/_anycable_rack_broadcast`.
+
+You can change this setting:
 
 ```ruby
-options = { headers: ['cookie', 'origin'] }
-AnyCable::Rack.new(nil, options)
+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 `rake`.
+Run units with `bundle exec rake`.
+
+## Contributing
+
+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
 
-Instructions for testing with [anyt](https://github.com/anycable/anyt) (anycable conformance testing) can be found [here](https://github.com/tuwukee/anycable-rack-server/tree/master/test/support).
+The gem is available as open source under the terms of the [MIT License](./LICENSE).

data/lib/anycable-rack-server.rb

@@ -1,3 +1,17 @@
 # frozen_string_literal: true
 
-require 'anycable/rack-server'
+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"])
+          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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+gem "redis", "~> 4"
+
+require "redis"
+require "json"
+
+module AnyCable
+  module Rack
+    module BroadcastSubscribers
+      # Redis Pub/Sub subscriber
+      class RedisSubscriber < BaseSubscriber
+        attr_reader :redis_conn, :thread, :channel
+
+        def initialize(hub:, coder:, channel:, **options)
+          super
+          @redis_conn = ::Redis.new(options)
+          @channel = channel
+        end
+
+        def start
+          subscribe(channel)
+
+          log(:info) { "Subscribed to #{channel}" }
+        end
+
+        def stop
+          thread&.terminate
+        end
+
+        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
+
+                on.message do |_channel, msg|
+                  handle_message(msg)
+                rescue
+                  log(:error) { "Failed to broadcast message: #{msg}" }
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
+require "json"
+
 module AnyCable
-  module RackServer
+  module Rack
     module Coders
-      module JSON
+      module JSON # :nodoc:
         class << self
           def decode(json_str)
             ::JSON.parse(json_str)

data/lib/anycable/rack/config.rb

@@ -0,0 +1,21 @@
+# 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"
+    end
+  end
+end

data/lib/anycable/rack/connection.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "set"
+require "json"
+
+require "anycable/rack/rpc/client"
+require "anycable/rack/logging"
+require "anycable/rack/errors"
+
+module AnyCable
+  module Rack
+    class Connection # :nodoc:
+      include Logging
+
+      attr_reader :coder,
+        :headers,
+        :hub,
+        :socket,
+        :rpc_client,
+        :sid
+
+      def initialize(socket, hub:, coder:, rpc_client:, headers:)
+        @socket = socket
+        @coder = coder
+        @headers = headers
+        @hub = hub
+        @sid = SecureRandom.hex(6)
+
+        @rpc_client = rpc_client
+
+        @_identifiers = "{}"
+        @_subscriptions = Set.new
+        @_istate = {}
+      end
+
+      def handle_open
+        response = rpc_connect
+        process_open(response)
+      end
+
+      def handle_close
+        response = rpc_disconnect
+        process_close(response)
+        reset_connection
+      end
+
+      def handle_command(websocket_message)
+        decoded = decode(websocket_message)
+        command = decoded.delete("command")
+
+        channel_identifier = decoded["identifier"]
+
+        log(:debug) { "Command: #{decoded}" }
+
+        case command
+        when "subscribe" then subscribe(channel_identifier)
+        when "unsubscribe" then unsubscribe(channel_identifier)
+        when "message" then send_message(channel_identifier, decoded["data"])
+        else
+          log(:error, "Command not found #{command}")
+        end
+      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))
+      end
+
+      def close
+        socket.close
+      end
+
+      def request
+        socket.request
+      end
+
+      def rpc_connect
+        rpc_client.connect(headers: headers, url: request.url)
+      end
+
+      def rpc_disconnect
+        rpc_client.disconnect(
+          identifiers: @_identifiers,
+          subscriptions: @_subscriptions.to_a,
+          headers: headers,
+          url: request.url,
+          state: @_cstate,
+          channels_state: @_istate
+        )
+      end
+
+      def rpc_command(command, identifier, data = "")
+        rpc_client.command(
+          command: command,
+          identifier: identifier,
+          connection_identifiers: @_identifiers,
+          data: data,
+          headers: headers,
+          url: request.url,
+          connection_state: @_cstate,
+          state: @_istate[identifier]
+        )
+      end
+
+      def subscribe(identifier)
+        response = rpc_command("subscribe", identifier)
+        if response.status == :SUCCESS
+          @_subscriptions.add(identifier)
+        elsif response.status == :ERROR
+          log(:error, "RPC subscribe command failed: #{response.inspect}")
+        end
+        process_command(response, identifier)
+      end
+
+      def unsubscribe(identifier)
+        response = rpc_command("unsubscribe", identifier)
+        if response.status == :SUCCESS
+          @_subscriptions.delete(identifier)
+        elsif response.status == :ERROR
+          log(:error, "RPC unsubscribe command failed: #{response.inspect}")
+        end
+        process_command(response, identifier)
+      end
+
+      def send_message(identifier, data)
+        response = rpc_command("message", identifier, data)
+        log(:error, "RPC message command failed: #{response.inspect}") if response.status == :ERROR
+        process_command(response, identifier)
+      end
+
+      def process_command(response, identifier)
+        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
+          @_cstate = response.env.cstate&.to_h || {}
+          hub.add_socket(socket, @_identifiers)
+          log(:debug) { "Opened" }
+        else
+          log(:error, "RPC connection command failed: #{response.inspect}")
+          close_connection
+        end
+      end
+
+      def process_close(response)
+        if response.status == :SUCCESS
+          log(:debug) { "Closed" }
+        else
+          log(:error, "RPC disconnection command failed: #{response.inspect}")
+        end
+      end
+
+      def reset_connection
+        @_identifiers = "{}"
+        @_subscriptions = []
+
+        hub.remove_socket(socket)
+      end
+
+      def close_connection
+        reset_connection
+        close
+      end
+
+      def encode(cable_message)
+        coder.encode(cable_message)
+      end
+
+      def decode(websocket_message)
+        coder.decode(websocket_message)
+      end
+
+      def log(level, msg = nil)
+        super(level, msg ? log_fmt(msg) : nil) { log_fmt(yield) }
+      end
+
+      def log_fmt(msg)
+        "[sid=#{sid}] #{msg}"
+      end
+    end
+  end
+end