From da8e81b8e3e6d35beedeac0731ab3c57baf89a08 Mon Sep 17 00:00:00 2001 From: Vladimir Dementyev Date: Fri, 13 Sep 2024 10:22:05 -0700 Subject: [PATCH] init it --- .anycable-rails-revision | 1 + .github/workflows/ci.yml | 42 ++++++++++ .gitignore | 10 +++ .rails-revision | 1 + Gemfile | 50 ++++++++++++ Makefile | 24 ++++++ README.md | 68 +++++++++++++++++ bento | 31 ++++++++ bin/anycable-go | 22 ++++++ bin/rails | 11 +++ bin/wait_tcp | 24 ++++++ lib/application.rb | 68 +++++++++++++++++ lib/servers/anycable.rb | 21 +++++ lib/servers/falcon.rb | 127 +++++++++++++++++++++++++++++++ lib/servers/puma.rb | 15 ++++ scripts/wsdirector/broadcast.yml | 27 +++++++ scripts/wsdirector/echo.yml | 15 ++++ 17 files changed, 557 insertions(+) create mode 100644 .anycable-rails-revision create mode 100644 .github/workflows/ci.yml create mode 100644 .gitignore create mode 100644 .rails-revision create mode 100644 Gemfile create mode 100644 Makefile create mode 100644 README.md create mode 100755 bento create mode 100755 bin/anycable-go create mode 100755 bin/rails create mode 100755 bin/wait_tcp create mode 100644 lib/application.rb create mode 100644 lib/servers/anycable.rb create mode 100644 lib/servers/falcon.rb create mode 100644 lib/servers/puma.rb create mode 100644 scripts/wsdirector/broadcast.yml create mode 100644 scripts/wsdirector/echo.yml diff --git a/.anycable-rails-revision b/.anycable-rails-revision new file mode 100644 index 0000000..d1b440c --- /dev/null +++ b/.anycable-rails-revision @@ -0,0 +1 @@ +https://github.com/anycable/anycable-rails.git#feat/actioncable-v8 diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..8025759 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,42 @@ +name: CI + +on: + push: + branches: + - master + pull_request: + workflow_dispatch: + +jobs: + wsdirector: + if: ${{ !contains(github.event.head_commit.message, '[ci skip]') }} + runs-on: ubuntu-latest + env: + BUNDLE_JOBS: 4 + BUNDLE_RETRY: 3 + CI: true + services: + redis: + image: redis:7.0-alpine + ports: ["6379:6379"] + options: --health-cmd="redis-cli ping" --health-interval 1s --health-timeout 3s --health-retries 30 + strategy: + fail-fast: false + matrix: + server: ["puma", "anycable"] + steps: + - uses: actions/checkout@v4 + - uses: ruby/setup-ruby@v1 + with: + ruby-version: 3.3 + bundler-cache: true + - name: Run server + run: | + bundle exec bento --${{ matrix.server }} & + bin/wait_tcp 8080 + - name: Run echo scenario + run: | + SCENARIO=echo make wsdirector + - name: Run broadcast scenario + run: | + SCENARIO=broadcast make wsdirector diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..36dd26a --- /dev/null +++ b/.gitignore @@ -0,0 +1,10 @@ +anycable-go-* +k6 + +.rails-path +.anycable-path + +bin/dist +!bin/dist/.keep + +Gemfile.lock diff --git a/.rails-revision b/.rails-revision new file mode 100644 index 0000000..7dff62f --- /dev/null +++ b/.rails-revision @@ -0,0 +1 @@ +https://github.com/palkan/rails.git#refactor/action-cable-server-adapterization diff --git a/Gemfile b/Gemfile new file mode 100644 index 0000000..dbf10e0 --- /dev/null +++ b/Gemfile @@ -0,0 +1,50 @@ +source "https://rubygems.org" + +rails_path = File.file?(File.join(__dir__, ".rails-path")) ? File.read(File.join(__dir__, ".rails-path")).strip : File.join(__dir__, "../rails") + +# Use local Rails copy if available +if File.directory?(rails_path) + gem "rails", group: :preload, path: rails_path +# Use Rails from a git repo +elsif File.file?(File.join(__dir__, ".rails-revision")) + git, branch = *File.read(File.join(__dir__, ".rails-revision")).strip.split("#", 2) + gem "rails", group: :preload, git:, branch: +else + gem "rails", "~> 8.0" +end + +# Baseline setup: Puma + Redis pub/sub +gem "puma", "~> 6.4" +gem "redis", "~> 5.0", group: :preload + +# Async setup +# TODO + +# AnyCable setup +gem "grpc_kit" if ENV["ANYCABLE_GRPC_IMPL"] == "grpc_kit" +gem "grpc" unless ENV["ANYCABLE_GRPC_IMPL"] == "grpc_kit" + +anycable_dir_path = File.file?(File.join(__dir__, ".anycable-path")) ? File.read(File.join(__dir__, ".anycable-path")).strip : File.join(__dir__, "..") + +if File.file?(File.join(anycable_dir_path, "anycable/anycable-core.gemspec")) + gem "anycable-core", group: :preload, path: File.join(anycable_dir_path, "anycable") +elsif File.file?(File.join(__dir__, ".anycable-revision")) + git, branch = *File.read(File.join(__dir__, ".anycable-revision")).strip.split("#", 2) + gem "anycable-core", require: false, group: :preload, git:, branch: +else + gem "anycable-core" +end + +if File.file?(File.join(anycable_dir_path, "anycable-rails/anycable-rails.gemspec")) + gem "anycable-rails", group: :preload, path: File.join(anycable_dir_path, "anycable-rails") +elsif File.file?(File.join(__dir__, ".anycable-rails-revision")) + git, branch = *File.read(File.join(__dir__, ".anycable-rails-revision")).strip.split("#", 2) + gem "anycable-rails", require: false, group: :preload, git:, branch: +else + gem "anycable-rails" +end + +# Tools +gem "wsdirector-cli", require: false + +gem "debug" unless ENV["CI"] diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..0e3c0d2 --- /dev/null +++ b/Makefile @@ -0,0 +1,24 @@ +SCENARIO ?= echo +SCALE ?= 10 + +websocket-bench: + websocket-bench broadcast ws://localhost:8080/cable \ + --concurrent 8 \ + --sample-size 100 \ + --step-size 200 \ + --payload-padding 200 \ + --total-steps 10 \ + --origin http://0.0.0.0 \ + --server-type=actioncable + +build-k6: + @test -x ./k6 || \ + xk6 build v0.42.0 --with github.com/anycable/xk6-cable@latest + +k6: build-k6 + ./k6 run scripts/k6/benchmark.js + +wsdirector: + @bundle exec wsdirector -f scripts/wsdirector/$(SCENARIO).yml -u ws://localhost:8080/cable -s $(SCALE) + +.PHONY: websocket-bench diff --git a/README.md b/README.md new file mode 100644 index 0000000..afc9e3b --- /dev/null +++ b/README.md @@ -0,0 +1,68 @@ +# Action Cable 8 playground + +This is a support project for the Action Server adapterization happening here: [rails/rails#50979][the-pr]. + +This project contains examples, tests and benchmarks aiming to ensure that the refactoring goes well and brings the promised benefits. + +## Usage + +Install the dependencies: + +```sh +bundle install +``` + +NOTE: You can use local dependencies (Rails, AnyCable) either by following path conventions or by providing `.xxx-path` files (see the Gemfile). + +Now you should be able to run a minimal Action Cable application via one of the supported web servers. By default, Puma is used: + +```sh +$ bundle exec bento + +⚡️ Running Action Cable via puma + +[18378] Puma starting in cluster mode... + +... +``` + +Other servers: + +```sh +# AnyCable + +$ bundle exec bento --anycable + +⚡️ Running Action Cable via anycable + +2024-09-13 10:07:54.272 INF Starting AnyCable 1.5.3-56288f0 (pid: 37818, open file limit: 122880, gomaxprocs: 8) nodeid=NFoelH + +... +``` + +## Tests + +You can run basic smoke tests via [wsdirector][] as follows (NOTE: the server must be running): + +```sh +# The default scenario is echo +$ make wsdirector + +10 clients, 0 failures + +# Run broadcast scenario +$ SCENARIO=broadcast make wsdirector + +Group publisher: 10 clients, 0 failures +Group listener: 20 clients, 0 failures + +# You can specify the scale factor, too (default: 10) +$ SCALE=20 SCENARIO=broadcast make wsdirector + +Group publisher: 20 clients, 0 failures +Group listener: 40 clients, 0 failures + +``` + +[the-pr]: https://github.com/rails/rails/pull/50979 +[wsdirector]: https://github.com/palkan/wsdirector diff --git a/bento b/bento new file mode 100755 index 0000000..ec5f95f --- /dev/null +++ b/bento @@ -0,0 +1,31 @@ +#!/usr/bin/env ruby + +require "bundler/setup" + +$stdout.puts "YJIT is enabled 🎉" if RUBY_DESCRIPTION =~ /\+YJIT/ + +require "optparse" + +$benchmark_server = :puma + +OptionParser.new do |opts| + opts.banner = "Usage: bento [options]" + + opts.on('--puma', 'Run Rails via Puma server') do |v| + $benchmark_server = :puma + end + + opts.on('--anycable', 'Run AnyCable RPC server') do |v| + $benchmark_server = :anycable + end + + opts.on('--falcon', 'Run Falcon/Async server') do |v| + $benchmark_server = :falcon + end +end.parse! + +require_relative "lib/application" + +$stdout.puts "⚡️ Running Action Cable via #{$benchmark_server}" + +BenchmarkServer.run! diff --git a/bin/anycable-go b/bin/anycable-go new file mode 100755 index 0000000..91efe9d --- /dev/null +++ b/bin/anycable-go @@ -0,0 +1,22 @@ +#!/bin/bash + +cd $(dirname $0)/.. + +# It's recommended to use the exact version of AnyCable-Go here +version="1.5.3" + +if [ ! -f ./bin/dist/anycable-go ]; then + echo "AnyCable server is not installed, downloading..." + ./bin/rails g anycable:download --version=$version --bin-path=$(pwd)/bin/dist +fi + +curVersion=$(./bin/dist/anycable-go -v) + +if [[ "$version" != "latest" ]]; then + if [[ "$curVersion" != "$version"* ]]; then + echo "AnyCable server version is not $version, downloading a new one..." + ./bin/rails g anycable:download --version=$version --bin-path=$(pwd)/bin/dist + fi +fi + +./bin/dist/anycable-go $@ diff --git a/bin/rails b/bin/rails new file mode 100755 index 0000000..6f92e35 --- /dev/null +++ b/bin/rails @@ -0,0 +1,11 @@ +#!/usr/bin/env ruby + +require "bundler/setup" + +APP_PATH = File.expand_path("../lib/application", __dir__) + +require_relative APP_PATH + +Dir.chdir(File.dirname(APP_PATH)) + +require "rails/commands" diff --git a/bin/wait_tcp b/bin/wait_tcp new file mode 100755 index 0000000..297c891 --- /dev/null +++ b/bin/wait_tcp @@ -0,0 +1,24 @@ +#!/usr/bin/env ruby + +require "socket" + +host = "127.0.0.1" +port = ARGV[0] +timeout = ARGV[1]&.to_f || 5.0 # seconds + +$stdout.puts "Waiting for TCP server to start at #{port}" + +while timeout > 0 + begin + Socket.tcp(host, port, connect_timeout: 1).close + $stdout.puts "TCP server is listening at #{port}" + return + rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, SocketError + end + + sleep 0.5 + timeout -= 0.5 +end + +$stderr.puts "No server is listening at #{port}" +exit(1) diff --git a/lib/application.rb b/lib/application.rb new file mode 100644 index 0000000..5b9a2a7 --- /dev/null +++ b/lib/application.rb @@ -0,0 +1,68 @@ +# frozen_string_literal: true + +require "rails" +require "global_id" + +require "action_controller/railtie" +require "action_view/railtie" +require "action_cable/engine" + +require "debug" unless ENV["CI"] + +# config/application.rb +class App < Rails::Application + config.root = __dir__ + config.eager_load = false + config.consider_all_requests_local = true + config.action_dispatch.show_exceptions = false + config.secret_key_base = "i_am_a_secret" + + config.hosts = [] + + config.logger = ActiveSupport::Logger.new((ENV["LOG"] == "1") ? $stdout : IO::NULL) + config.log_level = (ENV["LOG"] == "1") ? :debug : :fatal + + routes.append do + # Add routes here if needed + end +end + +ActionCable.server.config.connection_class = -> { ApplicationCable::Connection } +ActionCable.server.config.disable_request_forgery_protection = true +ActionCable.server.config.logger = Rails.logger + +# Load server configuration +require_relative "servers/#{$benchmark_server}" if defined?($benchmark_server) + +Rails.application.initialize! + +module ApplicationCable + class Connection < ActionCable::Connection::Base + identified_by :uid + end + + class Channel < ActionCable::Channel::Base + end +end + +class BenchmarkChannel < ApplicationCable::Channel + def subscribed + stream_from "all#{stream_id}" + end + + def echo(data) + transmit data + end + + def broadcast(data) + ActionCable.server.broadcast "all#{stream_id}", data + data["action"] = "broadcastResult" + transmit data + end + + private + + def stream_id + params[:id] || "" + end +end diff --git a/lib/servers/anycable.rb b/lib/servers/anycable.rb new file mode 100644 index 0000000..dc9d591 --- /dev/null +++ b/lib/servers/anycable.rb @@ -0,0 +1,21 @@ +# frozen_string_literal: true + +require "redis" +require "anycable-rails" + +ActionCable.server.config.cable = { + "adapter" => $benchmark_server == :anycable ? "any_cable" : "redis", + "url" => ENV["REDIS_URL"] +} + +class BenchmarkServer + def self.run! + require "anycable/cli" + cli = AnyCable::CLI.new + # We're already within the app context + cli.define_singleton_method(:boot_app!) { } + + anycable_server_path = Rails.root.join("../bin/anycable-go") + cli.run(["--server-command", "#{anycable_server_path} --host 0.0.0.0"]) + end +end diff --git a/lib/servers/falcon.rb b/lib/servers/falcon.rb new file mode 100644 index 0000000..b06c507 --- /dev/null +++ b/lib/servers/falcon.rb @@ -0,0 +1,127 @@ +# frozen_string_literal: true + +# TODO: This is an old version from here: https://github.com/anycable/anycable/blob/a0c48aeffe7b57f8abcf49ec244e2129f7424c97/benchmarks/rails/bento#L113 +# Requires upgrade for Action Cable 8 +class AsyncApp + def call(req) + Async::WebSocket::Adapters::HTTP.open(req) do |connection| + env = {url: "/cable"} + + connected = AnyCable.rpc_handler.handle( + :connect, + AnyCable::ConnectionRequest.new(env: env) + ).then do |response| + handle_response(connection, response) + + if response.status != :SUCCESS + connection.close + next false + end + + true + end + + next unless connected + + loop do + msg = connection.read + cmd = Protocol::WebSocket::JSONMessage.wrap(msg)&.to_h + + next unless cmd + + identifier = cmd[:identifier] + command = cmd[:command] + + case command + when "subscribe" + AnyCable.rpc_handler.handle( + :command, + AnyCable::CommandMessage.new( + command:, + identifier:, + connection_identifiers: "{}", + env: + ) + ).then do |response| + handle_response(connection, response, identifier) + end + when "message" + AnyCable.rpc_handler.handle( + :command, + AnyCable::CommandMessage.new( + command:, + identifier:, + connection_identifiers: "{}", + data: cmd[:data], + env: + ) + ).then do |response| + handle_response(connection, response, identifier) + end + end + end + rescue EOFError + end + end + + private + + def handle_response(connection, response, identifier = nil) + response.transmissions&.each do |msg| + connection.write(msg) + end + connection.flush + + # Command response + if identifier + writer = proc do |msg| + msg = {identifier: identifier, message: JSON.parse(msg)}.to_json + connection.write(msg) + connetion.flush + end + + response.streams&.each do |stream| + ActionCable.server.pubsub.subscribe(stream, writer) + end + end + end +end + +class BenchmarkServer + def self.run! + require "async/websocket" + require "async/websocket/adapters/http" + require 'protocol/websocket/json_message' + + require "falcon/command" + require "falcon/command/serve" + + # Patch Action Cable subscriber to be async-aware + require "async/semaphore" + ActionCable::SubscriptionAdapter::SubscriberMap.prepend(Module.new do + def initialize(...) + super + @semaphore = Async::Semaphore.new(1024) + end + + def broadcast(channel, message) + list = @sync.synchronize do + return if !@subscribers.key?(channel) + @subscribers[channel].dup + end + + Async do + list.each do |subscriber| + @semaphore.async do + invoke_callback(subscriber, message) + end + end + end + end + end) + + cmd = Falcon::Command::Serve.new(["-p", "8080", "-b", "tcp://0.0.0.0", "--#{ENV.fetch("FALCON_MODE", "forked")}"]) + cmd.define_singleton_method(:load_app) { AsyncApp.new } + cmd.call + end +end diff --git a/lib/servers/puma.rb b/lib/servers/puma.rb new file mode 100644 index 0000000..daefc52 --- /dev/null +++ b/lib/servers/puma.rb @@ -0,0 +1,15 @@ +# frozen_string_literal: true + +ActionCable.server.config.cable = { + "adapter" => ENV.fetch("ACTION_CABLE_ADAPTER", "redis"), + "url" => ENV["REDIS_URL"] +} + +class BenchmarkServer + def self.run! + require "puma/cli" + cli = Puma::CLI.new(["-w", "#{ENV.fetch("WEB_CONCURRENCY", 4)}", "-t", "5", "-p", "8080", "-b", "tcp://0.0.0.0"]) + cli.instance_variable_get(:@conf).options[:app] = Rails.application + cli.run + end +end diff --git a/scripts/wsdirector/broadcast.yml b/scripts/wsdirector/broadcast.yml new file mode 100644 index 0000000..55af650 --- /dev/null +++ b/scripts/wsdirector/broadcast.yml @@ -0,0 +1,27 @@ +- client: + multiplier: ":scale" + name: "publisher" + protocol: "action_cable" + actions: + - subscribe: + channel: "BenchmarkChannel" + - wait_all + - perform: + channel: "BenchmarkChannel" + action: "broadcast" + data: + text: "hello" + +- client: + name: "listener" + multiplier: ":scale * 2" + protocol: "action_cable" + actions: + - subscribe: + channel: "BenchmarkChannel" + - wait_all + - receive: + multiplier: ":scale" + channel: "BenchmarkChannel" + data: + text: "hello" diff --git a/scripts/wsdirector/echo.yml b/scripts/wsdirector/echo.yml new file mode 100644 index 0000000..a586087 --- /dev/null +++ b/scripts/wsdirector/echo.yml @@ -0,0 +1,15 @@ +- client: + multiplier: ":scale" + protocol: "action_cable" + actions: + - subscribe: + channel: "BenchmarkChannel" + - perform: + channel: "BenchmarkChannel" + action: "echo" + data: + text: "ping" + - receive: + channel: "BenchmarkChannel" + data: + text: "ping"