anyt-core 1.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cd161ab373ec324f2d6ab9f17419858fae589bee036122ce1dac7039999ba360
+  data.tar.gz: b94fb021fab87a9d97f0a1bd3502142e969dd8982662805b0c0f5695ae7e7f45
+SHA512:
+  metadata.gz: 3bdbfe03f6aaa1bd8ae6e1cf606e900e56ed06b3e8dda894c73bd89df6484ceeb14e18be2f697f83ea1407a9a24734da32d4988baef423fd84780a201feb55ff
+  data.tar.gz: 7f7d8927b2f2d19734c101f91a5beecaeabea5dfed0b7346abdcd0feab50e2daaddafbb5a3b8041c5eed90c4dc443d68a8d1b5f303647680ed3577b92539a708

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016-2020 palkan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,38 @@
+[![Cult Of Martians](http://cultofmartians.com/assets/badges/badge.svg)](https://cultofmartians.com/tasks/anycable-conformance-tool.html#task)
+[![Gem Version](https://badge.fury.io/rb/anyt.svg)](https://rubygems.org/gems/anyt)
+![Test](https://github.com/anycable/anyt/workflows/Test/badge.svg)
+
+# Action Cable / AnyCable conformance testing tool
+
+AnyT is a command-line tool to test your Action Cable or [AnyCable](http://anycable.io)-compatible WebSocket servers.
+
+It contains a set of tests to determine which features are supported by the implementation under consideration.
+
+## Installation
+
+```sh
+gem install anyt
+```
+
+## Usage
+
+You should provide a command to run the server and the target URL for WebSocket clients:
+
+```sh
+anyt -c "anycable-go" --target-url="ws://localhost:8080/cable"
+```
+
+By default it launches gRPC server on `localhost:50051` and use local Redis instance for broadcasts (`localhost:6379`).
+
+For more options run:
+
+```sh
+anyt -h
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/anycable/anyt/issues.
+
+## License
+The library is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/bin/anyt

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+
+require 'anyt'
+require 'anyt/cli'
+
+begin
+  exit_code = Anyt::Cli.run
+rescue => e
+  puts 'Bummer! There is an error:'
+  puts e
+  puts e.backtrace.take(10).join("\n")
+  exit 1
+end
+
+exit exit_code

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'anyt'
+require 'irb'
+
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/anyt/cli.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require "logger"
+require "optparse"
+
+require "anyt/version"
+require "anyt/remote_control"
+require "anyt/rpc"
+require "anyt/command"
+require "anyt/tests"
+
+$stdout.sync = true
+
+module Anyt
+  module Cli # :nodoc:
+    DUMMY_ROOT = ::File.expand_path(
+      "config.ru",
+      ::File.join(::File.dirname(__FILE__), "dummy")
+    )
+
+    RAILS_COMMAND = "bundle exec puma #{DUMMY_ROOT} -t #{ENV.fetch("RAILS_MAX_THREADS", 5)}"
+
+    class << self
+      # CLI entrypoint
+      def run(args = ARGV)
+        parse_options!(args)
+
+        ActionCable.server.config.logger = Rails.logger = AnyCable.logger
+
+        result = 1
+
+        $stdout.puts "Starting AnyT v#{Anyt::VERSION} (pid: #{Process.pid})\n"
+
+        begin
+          # "Enable" AnyCable as early as possible to activate all the features in tests
+          unless Anyt.config.use_action_cable
+            ActionCable.server.config.cable = {"adapter" => "any_cable"}
+            require "anycable-rails"
+          end
+
+          # Load all test scenarios
+          Tests.load_tests unless @skip_tests
+
+          Rails.application.initialize!
+
+          # Start RPC server (unless specified otherwise, e.g. when
+          # we want to test Action Cable itself)
+          unless @skip_rpc
+            http_rpc = AnyCable.config.http_rpc_mount_path.present?
+
+            @rpc_command =
+              if http_rpc
+                Command.new(RAILS_COMMAND)
+              else
+                RPC.new
+              end
+
+            @rpc_command.start
+
+            if @only_rpc
+              if http_rpc
+                wait_till_terminated
+              else
+                @rpc_command.server.wait_till_terminated
+              end
+              return
+            end
+          end
+
+          # Start webosocket server under test
+          @command = Command.default
+          @command.run
+
+          unless @skip_tests
+            # Run tests
+            result = Tests.run ? 0 : 1
+          end
+
+          wait_till_terminated if @only_rails
+        rescue Interrupt => e
+          $stdout.puts "#{e.message}. Good-bye!"
+        ensure
+          @rpc_command&.stop unless @skip_rpc
+          @command&.stop
+        end
+
+        result
+      end
+
+      private
+
+      def parse_options!(args)
+        parser =
+          OptionParser.new do |cli|
+            cli.banner = <<~BANNER
+              Anyt – AnyCable websocket server conformance tool.
+
+              Usage: anyt [options]
+
+              Options:
+            BANNER
+
+            cli.on("-cCOMMAND", "--command=COMMAND", "Command to run WS server.") do |command|
+              Anyt.config.command = command
+            end
+
+            cli.on("--target-url=TARGET", "URL of target WebSocket server to test.") do |target|
+              Anyt.config.target_url = target
+            end
+
+            cli.on("--redis-url=REDIS_URL", "Redis server URL.") do |redis|
+              AnyCable.config.redis_url = redis
+            end
+
+            cli.on("--skip-rpc", TrueClass, "Do not run RPC server") do |flag|
+              @skip_rpc = flag
+            end
+
+            cli.on("--only-rpc", TrueClass, "Run only RPC server") do |flag|
+              @only_rpc = flag
+            end
+
+            cli.on("--only-rails", TrueClass, "Run only Rails server") do
+              @skip_rpc = true
+              @only_rails = true
+              @skip_tests = true
+
+              configure_rails_command!
+            end
+
+            cli.on("--self-check", "Run tests again Action Cable itself") do
+              @skip_rpc = true
+
+              configure_rails_command!
+            end
+
+            cli.on("--only test1,test2,test3", Array, "Run only specified tests") do |only_tests|
+              Anyt.config.only_tests = only_tests
+            end
+
+            cli.on("--except test1,test2,test3", Array, "Exclude specified tests") do |except_tests|
+              Anyt.config.except_tests = except_tests
+            end
+
+            cli.on("--wait-command=TIMEOUT", Integer,
+              "Number of seconds to wait for WS server initialization") do |timeout|
+              Anyt.config.wait_command = timeout
+            end
+
+            cli.on("--timeout-multiplier=VALUE", Float,
+              "Default exceptation timeouts multiplier") do |val|
+              Anyt.config.timeout_multiplier = val
+            end
+
+            cli.on("-rPATH", "--require=PATH",
+              "Path to additional tests (e.g. features/*.rb") do |path|
+              Anyt.config.tests_relative_path = path
+              ENV["ANYT_TESTS_RELATIVE_PATH"] = path
+            end
+
+            cli.on("--debug", "Enable debug mode.") do
+              AnyCable.config.debug = true
+            end
+
+            cli.on("-h", "--help", "Show this message.") do
+              puts cli
+              exit
+            end
+
+            cli.on("--version", "Print version.") do
+              puts Anyt::VERSION
+              exit
+            end
+          end
+
+        parser.parse!(args)
+      rescue OptionParser::InvalidOption => e
+        unknown_option = e.args.first
+        puts "This option looks unfamiliar: #{unknown_option}. A typo?"
+        puts "Use `anyt --help` to list all available options."
+        exit 1
+      end
+
+      def configure_rails_command!
+        Anyt.config.command = RAILS_COMMAND
+        Anyt.config.use_action_cable = true
+      end
+
+      def wait_till_terminated
+        self_read = setup_signals
+
+        while readable_io = IO.select([self_read]) # rubocop:disable Lint/AssignmentInCondition, Lint/IncompatibleIoSelectWithFiberScheduler
+          signal = readable_io.first[0].gets.strip
+          raise Interrupt, "SIG#{signal} received"
+        end
+      end
+
+      def setup_signals
+        self_read, self_write = IO.pipe
+
+        %w[INT TERM].each do |signal|
+          trap signal do
+            self_write.puts signal
+          end
+        end
+
+        self_read
+      end
+    end
+  end
+end

data/lib/anyt/client.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "anyt"
+
+module Anyt
+  # Synchronous websocket client
+  # Based on https://github.com/rails/rails/blob/v5.0.1/actioncable/test/client_test.rb
+  class Client
+    require "websocket-client-simple"
+    require "concurrent"
+
+    class Error < StandardError; end
+
+    class TimeoutError < Error; end
+
+    class DisconnectedError < Error
+      attr_reader :event
+
+      def initialize(event)
+        @event = event
+        if event
+          super("WebSocket disconnected (code=#{event.code}, reason=#{event.data})")
+        else
+          super("WebSocket disconnected abnormally")
+        end
+      end
+    end
+
+    WAIT_WHEN_EXPECTING_EVENT = 5
+    WAIT_WHEN_NOT_EXPECTING_EVENT = 0.5
+
+    private attr_reader :logger
+
+    attr_reader :url
+
+    def initialize(
+      ignore: [], url: Anyt.config.target_url, qs: "",
+      cookies: "", headers: {},
+      protocol: "actioncable-v1-json",
+      timeout_multiplier: Anyt.config.timeout_multiplier,
+      logger: AnyCable.logger
+    )
+      @logger = logger
+      ignore_message_types = @ignore_message_types = ignore
+      messages = @messages = Queue.new
+      closed = @closed = Concurrent::Event.new
+      has_messages = @has_messages = Concurrent::Semaphore.new(0)
+
+      @timeout_multiplier = timeout_multiplier
+
+      headers = headers.merge("cookie" => cookies)
+      headers["Sec-WebSocket-Protocol"] = protocol
+
+      open = Concurrent::Promise.new
+
+      @url = url
+
+      if !qs.empty?
+        @url += @url.include?("?") ? "&" : "?"
+        @url += qs
+      end
+
+      @ws = WebSocket::Client::Simple.connect(
+        @url,
+        headers: headers
+      ) do |ws|
+        ws.on(:error) do |event|
+          event = RuntimeError.new(event.message) unless event.is_a?(Exception)
+
+          if open.pending?
+            open.fail(event)
+          else
+            messages << event
+            has_messages.release
+          end
+        end
+
+        ws.on(:open) do |_event|
+          open.set(true)
+        end
+
+        ws.on(:message) do |event|
+          next if event.type == :ping
+          if event.type == :close
+            messages << DisconnectedError.new(event)
+            has_messages.release
+            closed.set
+          else
+            message = JSON.parse(event.data)
+
+            next if ignore_message_types.include?(message["type"])
+
+            logger.debug "Message received: #{message}"
+
+            messages << message
+            has_messages.release
+          end
+        end
+
+        ws.on(:close) do |_event|
+          closed.set
+        end
+      end
+
+      open.wait!(WAIT_WHEN_EXPECTING_EVENT * @timeout_multiplier)
+    end
+    # rubocop: enable Metrics/BlockLength
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/MethodLength
+
+    def receive(timeout: WAIT_WHEN_EXPECTING_EVENT)
+      timeout *= @timeout_multiplier
+
+      unless @has_messages.try_acquire(1, timeout)
+        raise DisconnectedError if closed?
+        raise TimeoutError, "Timed out to receive message"
+      end
+
+      msg = @messages.pop(true)
+      raise msg if msg.is_a?(Exception) || msg.is_a?(Error)
+
+      msg
+    end
+
+    def send(message)
+      @ws.send(JSON.generate(message))
+    end
+
+    def close(allow_messages: false)
+      sleep WAIT_WHEN_NOT_EXPECTING_EVENT * @timeout_multiplier
+
+      raise "#{@messages.size} messages unprocessed" unless allow_messages || @messages.empty?
+
+      @ws.close
+      wait_for_close
+    end
+
+    def wait_for_close
+      @closed.wait(WAIT_WHEN_EXPECTING_EVENT * @timeout_multiplier)
+    end
+
+    def closed?
+      @closed.set?
+    end
+  end
+end

data/lib/anyt/command.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "childprocess"
+
+module Anyt
+  # Runs system command (websocket server)
+  class Command
+    class << self
+      attr_reader :instance
+
+      def default
+        @instance ||= new
+      end
+
+      def restart
+        instance&.restart
+      end
+    end
+
+    attr_reader :cmd
+
+    def initialize(cmd = Anyt.config.command)
+      @cmd = cmd
+    end
+
+    def run
+      return if running?
+
+      return unless cmd
+
+      AnyCable.logger.debug "Running command: #{cmd}"
+
+      @process = ChildProcess.build(*cmd.split(/\s+/))
+
+      process.io.inherit! if AnyCable.config.debug
+
+      process.detach = true
+
+      process.environment["ANYCABLE_DEBUG"] = "1" if AnyCable.config.debug?
+      process.environment["ANYT_REMOTE_CONTROL_PORT"] = Anyt.config.remote_control_port
+      process.environment["ACTION_CABLE_ADAPTER"] = "any_cable" unless Anyt.config.use_action_cable
+
+      process.start
+
+      AnyCable.logger.debug "Command PID: #{process.pid}"
+
+      sleep Anyt.config.wait_command
+      raise "Command failed to start" unless running?
+    end
+
+    alias_method :start, :run
+
+    # rubocop: enable Metrics/MethodLength
+    # rubocop: enable Metrics/AbcSize
+
+    def restart
+      return unless running?
+
+      AnyCable.logger.debug "Restarting command PID: #{process.pid}"
+
+      stop
+      process.wait
+
+      run
+    end
+
+    def stop
+      return unless running?
+
+      AnyCable.logger.debug "Terminate PID: #{process.pid}"
+
+      process.stop
+    end
+
+    def running?
+      process&.alive?
+    end
+
+    private
+
+    attr_reader :process
+  end
+end

data/lib/anyt/config.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "anyway"
+
+module Anyt
+  # Anyt configuration
+  class Config < Anyway::Config
+    attr_config :command,
+      :only_tests,
+      :except_tests,
+      :tests_relative_path,
+      remote_control_port: 8919,
+      use_action_cable: false,
+      target_url: "ws://localhost:9292/cable",
+      wait_command: 2,
+      timeout_multiplier: 1
+
+    coerce_types only_tests: {type: :string, array: true}
+    coerce_types except_tests: {type: :string, array: true}
+
+    def tests_path
+      return unless tests_relative_path
+
+      File.expand_path(tests_relative_path, Dir.pwd)
+    end
+
+    def filter_tests?
+      only_tests || except_tests
+    end
+
+    def tests_filter
+      only_rxp = /(#{only_tests.join("|")})/ if only_tests
+      except_rxp = /(#{except_tests.join("|")})/ if except_tests
+
+      @tests_filter ||= lambda do |path|
+        (only_rxp.nil? || only_rxp.match?(path)) &&
+          (except_rxp.nil? || !except_rxp.match?(path))
+      end
+    end
+  end
+end

data/lib/anyt/dummy/application.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "rails"
+require "action_controller/railtie"
+require "action_cable/engine"
+
+require "redis"
+require "anycable-rails"
+
+require "action_dispatch/middleware/cookies"
+
+class TestApp < Rails::Application
+  config.load_defaults 7.0
+
+  config.logger = Logger.new($stdout)
+  config.log_level = AnyCable.config.log_level
+  config.eager_load = true
+
+  config.paths["config/routes.rb"] << File.join(__dir__, "routes.rb")
+end
+
+DISCONNECT_DELAY = ENV["ANYCABLE_DISCONNECT_DELAY"].to_f
+
+module ApplicationCable
+  class Connection < ActionCable::Connection::Base
+    delegate :params, to: :request
+
+    identified_by :uid
+
+    def connect
+      logger.debug "Connected"
+      Anyt::ConnectHandlers.call(self)
+    end
+
+    def disconnect
+      if DISCONNECT_DELAY > 0
+        sleep DISCONNECT_DELAY
+      end
+      logger.debug "Disconnected"
+    end
+  end
+end
+
+module ApplicationCable
+  class Channel < ActionCable::Channel::Base
+  end
+end
+
+ECHO_DELAY = ENV["ANYCABLE_BENCHMARK_ECHO_DELAY"].to_f
+
+# BenchmarkChannel is useful when running Rails app only or RPC only
+class BenchmarkChannel < ApplicationCable::Channel
+  def subscribed
+    stream_from "all#{stream_id}"
+  end
+
+  def echo(data)
+    if ECHO_DELAY > 0
+      sleep ECHO_DELAY
+    end
+    transmit data
+  end
+
+  def broadcast(data)
+    ActionCable.server.broadcast "all#{stream_id}", data
+    data["action"] = "broadcastResult"
+    transmit data
+  end
+
+  def counter(data)
+    num = data.fetch("num", 100).to_i
+    num.times { ActionCable.server.broadcast "all", {text: "Count: #{_1}"} }
+  end
+
+  private
+
+  def stream_id
+    params[:id] || ""
+  end
+end
+
+ActionCable.server.config.cable = {"adapter" => ENV.fetch("ACTION_CABLE_ADAPTER", "redis")}
+ActionCable.server.config.connection_class = -> { ApplicationCable::Connection }
+ActionCable.server.config.disable_request_forgery_protection = true
+ActionCable.server.config.logger =
+  Rails.logger

data/lib/anyt/dummy/config.ru

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "application"
+
+require_relative "../tests"
+require_relative "../remote_control"
+
+# Start remote control
+Anyt::RemoteControl::Server.start(Anyt.config.remote_control_port)
+
+# Load channels from tests
+Anyt::Tests.load_all_tests
+
+Rails.application.initialize!
+
+run Rails.application

data/lib/anyt/dummy/routes.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+Rails.application.routes.draw do
+end

data/lib/anyt/dummy/tmp/development_secret.txt

@@ -0,0 +1 @@
+fe2ecbcf229d5547a64bcdaa9ef4e543404ca3fc9d4ee83aaa7ddab34b6a378fe090c2b1836c9ebd3e5ebbf01c239ddac95e219358baaefc1afaa04cd07bf78c

data/lib/anyt/dummy/tmp/local_secret.txt

@@ -0,0 +1 @@
+8e4e6bba332e819bd6597b2e8961ca1c0ef0c9bcb3401214ea22155b729e262534cefed3012024f57b098e0756baddea2d145675da33f31a0844df44c9230141