wsdirector-core 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7a99e2e1bbcbf4e63a8c7fcda1653260b0294e0ffc0f3a78c279425c59336f1
-  data.tar.gz: 7dc4ee111ce35d7de921e385cfb860500eaa465109a1bb910fa7a592dee9c86e
+  metadata.gz: 9f1fd8da87e97c9a82a6f0505a8d4a7ef28a9dabb0a75809ee60b1739481e08c
+  data.tar.gz: 77f4c9ab2836f8f1e407c6376ee1b2d73b07ed1963770f5d38837bd24c5a598c
 SHA512:
-  metadata.gz: f149a7b303f7fbbb60c8a5c79431f73ab89abeaa25a8a17725172d43100079d63d6ea636f36c67dbe9c51af08d9e882c49780bfd144d488b762d012148c32a38
-  data.tar.gz: b4de9feedaa87184c63490b81c8f3c9b8b04e23918b48c8783a2f74e190498425ab58d6cb04df5e7b9ddd1292def023af3d848c43bcc39c102f13c0b8e8c5ae5
+  metadata.gz: 935e69a837cf42cb0bb3121a8f3f9b415534c492245b350549cf2f0f6a839f382a9e8167179c7db00c0157e4312d0a7efc6480fa9e5bac65076a3a20d9a26cd9
+  data.tar.gz: 61b7ee833e4a236167ef4ede04354b46d44bbc29cdc56b6caa05d3d28f5f0588131c933f3f5ab59833b1d74dfaca509b6a30f1b0bc3280591784b7cd211a448e

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## master
 
+## 1.0.2 (2023-01-12)
+
+- Fix adding transpiled files to releases. ([@palkan][])
+
 ## 1.0.1 (2022-09-29)
 
 - Fix `wsdirector-cli` dependencies.

data/lib/.rbnext/2.7/wsdirector/cli.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "uri"
+
+require "wsdirector"
+
+module WSDirector
+  # Command line interface for WsDirector
+  class CLI
+    class Configuration
+      attr_accessor :ws_url, :scenario_path, :colorize, :scale,
+        :sync_timeout, :json_scenario, :subprotocol, :verbose
+
+      def initialize
+        reset!
+      end
+
+      def colorize?
+        colorize == true
+      end
+
+      # Restore to defaults
+      def reset!
+        @scale = 1
+        @colorize = $stdout.tty?
+        @sync_timeout = 5
+      end
+    end
+
+    attr_reader :config
+
+    def run
+      @config = Configuration.new
+
+      parse_args!
+
+      begin
+        require "colorize" if config.colorize?
+      rescue LoadError
+        config.colorize = false
+        warn "Install colorize to use colored output"
+      end
+
+      connection_options = {
+        subprotocol: config.subprotocol
+      }.compact
+
+      scenario = config.scenario_path || config.json_scenario
+
+      config.ws_url = "ws://#{config.ws_url}" unless config.ws_url.start_with?(/wss?:\/\//)
+
+      url = config.ws_url
+      scale = config.scale
+      sync_timeout = config.sync_timeout
+      colorize = config.colorize
+
+      logger = $stdout if config.verbose
+
+      result = WSDirector.run(
+        scenario,
+        url: url,
+        connection_options: connection_options,
+        scale: scale,
+        sync_timeout: sync_timeout,
+        logger: logger,
+        colorize: colorize
+      )
+
+      puts "\n\n" if config.verbose
+
+      result.print_summary(colorize: config.colorize?)
+      result.success? || exit(1)
+    end
+
+    private
+
+    FILE_FORMAT = /.+.(json|yml)\z/
+    private_constant :FILE_FORMAT
+
+    def parse_args!
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: wsdirector scenario_path ws_url [options]"
+
+        opts.on("-s SCALE", "--scale=SCALE", Integer, "Scale factor") do |_1|
+          config.scale = _1
+        end
+
+        opts.on("-t TIMEOUT", "--timeout=TIMEOUT", Integer, "Synchronization (wait_all) timeout") do |_1|
+          config.sync_timeout = _1
+        end
+
+        opts.on("-i JSON", "--include=JSON", String, "Include JSON to parse") do |_1|
+          config.json_scenario = _1
+        end
+
+        opts.on("-u URL", "--url=URL", Object, "Websocket server URL") do |_1|
+          config.ws_url = _1
+        end
+
+        opts.on("-f PATH", "--file=PATH", String, "Scenario path") do |_1|
+          config.scenario_path = _1
+        end
+
+        opts.on("--subprotocol=VALUE", String, "WebSocket subprotocol") do |_1|
+          config.subprotocol = _1
+        end
+
+        opts.on("-c", "--[no-]color", "Colorize output") do |_1|
+          config.colorize = _1
+        end
+
+        opts.on("-v", "--version", "Print version") do
+          $stdout.puts WSDirector::VERSION
+          exit 0
+        end
+
+        opts.on("-vv", "Print verbose logs") do
+          config.verbose = true
+        end
+
+        opts.on("-r", "--require=PATH", "Load Ruby file (e.g., protocol)") do |_1|
+          Kernel.load(_1)
+        end
+      end
+
+      parser.parse!
+
+      unless config.scenario_path
+        config.scenario_path = ARGV.grep(FILE_FORMAT).last
+      end
+
+      unless config.ws_url
+        config.ws_url = ARGV.grep(URI::DEFAULT_PARSER.make_regexp).last
+      end
+
+      check_for_errors
+    end
+
+    def check_for_errors
+      if config.json_scenario.nil?
+        raise(Error, "Scenario is missing") unless config.scenario_path
+
+        unless File.file?(config.scenario_path)
+          raise(Error, "File doesn't exist # config.scenario_path}")
+        end
+      end
+
+      raise(Error, "Websocket server url is missing") unless config.ws_url
+    end
+  end
+end

data/lib/.rbnext/2.7/wsdirector/client.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "websocket-client-simple"
+require "securerandom"
+
+module WSDirector
+  # WebSocket client
+  class Client
+    include CGI::Escape
+
+    WAIT_WHEN_EXPECTING_EVENT = 5
+
+    attr_reader :ws, :id
+
+    # Create new WebSocket client and connect to WSDirector
+    # ws URL.
+    #
+    # Optionally provide an ignore pattern (to ignore incoming message,
+    # for example, pings)
+    def initialize(url:, ignore: nil, intercept: nil, subprotocol: nil, headers: nil, id: nil, query: nil, cookies: nil)
+      @ignore = ignore
+      @interceptor = intercept
+      @mailbox = []
+
+      has_messages = @has_messages = Concurrent::Semaphore.new(0)
+      messages = @messages = Queue.new
+      open = Concurrent::Promise.new
+      client = self
+
+      options = {}
+
+      if subprotocol
+        headers ||= {}
+        headers["Sec-WebSocket-Protocol"] = subprotocol
+      end
+
+      if cookies
+        headers ||= {}
+        headers["Cookie"] = cookies.map { |_1, _2| "#{_1}=#{escape(_2.to_s)}" }.join("; ")
+      end
+
+      if query
+        url = "#{url}?#{query.map { |_1, _2| "#{_1}=#{escape(_2.to_s)}" }.join("&")}"
+      end
+
+      options[:headers] = headers if headers
+
+      @id = id || SecureRandom.hex(6)
+      @ws = WebSocket::Client::Simple.connect(url, options) do |ws|
+        ws.on(:open) do |_event|
+          open.set(true)
+        end
+
+        ws.on :message do |msg|
+          data = msg.data
+          next if data.empty?
+          next if client.ignored?(data)
+          next if client.intercepted?(data)
+          messages << data
+          has_messages.release
+        end
+
+        ws.on :error do |e|
+          messages << Error.new("WebSocket Error #{e.inspect} #{e.backtrace}")
+        end
+      end
+
+      open.wait!(WAIT_WHEN_EXPECTING_EVENT)
+    rescue Errno::ECONNREFUSED
+      raise Error, "Failed to connect to #{url}"
+    end
+
+    def each_message
+      @mailbox.dup.each.with_index do |msg, i|
+        yield msg, i
+      end
+
+      loop do
+        msg = receive
+        @mailbox << msg
+        yield msg, (@mailbox.size - 1)
+      end
+    end
+
+    def receive(timeout = WAIT_WHEN_EXPECTING_EVENT)
+      @has_messages.try_acquire(1, timeout)
+      msg = @messages.pop(true)
+      raise msg if msg.is_a?(Exception)
+      msg
+    end
+
+    # Push message back to the mailbox (when it doesn't match the expectation)
+    def consumed(id)
+      @mailbox.delete_at(id)
+    end
+
+    def send(msg)
+      @ws.send(msg)
+    end
+
+    def ignored?(msg)
+      return false unless @ignore
+      @ignore.any? { |pattern| msg =~ Regexp.new(pattern) }
+    end
+
+    def intercepted?(msg)
+      return false unless @interceptor
+
+      instance_exec(msg, &@interceptor)
+    end
+  end
+end

data/lib/.rbnext/2.7/wsdirector/protocols/base.rb

@@ -0,0 +1,288 @@
+# frozen_string_literal: true
+
+require "time"
+require "wsdirector/ext/formatting"
+
+module WSDirector
+  module Protocols
+    using Ext::Formatting
+
+    using(Module.new do
+      refine ::Object do
+        def matches?(other)
+          self == other
+        end
+
+        def partially_matches?(other)
+          self == other
+        end
+      end
+
+      refine ::Array do
+        def matches?(actual)
+          if actual.is_a?(::String)
+            actual = JSON.parse(actual) rescue nil # rubocop:disable Style/RescueModifier
+          end
+
+          return false unless actual
+
+          each.with_index do |_1, _2|
+            return false unless _1.matches?(actual[_2])
+          end
+
+          true
+        end
+
+        def partially_matches?(actual)
+          if actual.is_a?(::String)
+            actual = JSON.parse(actual) rescue nil # rubocop:disable Style/RescueModifier
+          end
+
+          return false unless actual
+
+          each.with_index do |_1, _2|
+            return false unless _1.partially_matches?(actual[_2])
+          end
+
+          true
+        end
+      end
+
+      refine ::Hash do
+        def matches?(actual)
+          unless actual.is_a?(::Hash)
+            actual = JSON.parse(actual) rescue nil # rubocop:disable Style/RescueModifier
+          end
+
+          return false unless actual
+
+          actual.each_key do |_1|
+            return false unless actual[_1].matches?(self[_1])
+          end
+
+          true
+        end
+
+        def partially_matches?(actual)
+          unless actual.is_a?(::Hash)
+            actual = JSON.parse(actual) rescue nil # rubocop:disable Style/RescueModifier
+          end
+
+          return false unless actual
+
+          each_key do |_1|
+            return false unless self[_1].partially_matches?(actual[_1])
+          end
+
+          true
+        end
+      end
+    end)
+
+    class PartialMatcher
+      attr_reader :obj
+
+      def initialize(obj)
+        @obj = obj
+      end
+
+      def matches?(actual)
+        obj.partially_matches?(actual)
+      end
+
+      def inspect
+        "an object including #{obj.inspect}"
+      end
+
+      def truncate(*__rest__, &__block__) ;  obj.truncate(*__rest__, &__block__); end
+    end
+
+    # Base protocol describes basic actions
+    class Base
+      include WSDirector::Utils
+
+      def initialize(task, scale: 1, logger: nil, id: nil, color: nil)
+        @task = task
+        @scale = scale
+        @logger = logger
+        @id = id
+        @color = color
+      end
+
+      def init_client(*__rest__, &__block__)
+        log { "Connecting" }
+
+        @client = build_client(*__rest__, &__block__)
+
+        log(:done) { "Connected" }
+      end
+
+      def handle_step(step)
+        type = step.delete("type")
+        raise Error, "Unknown step: #{type}" unless respond_to?(type)
+
+        return unless task.sampled?(step)
+
+        public_send(type, step)
+      end
+
+      # Sleeps for a specified number of seconds.
+      #
+      # If "shift" is provided than the initial value is
+      # shifted by random number from (-shift, shift).
+      #
+      # Set "debug" to true to print the delay time.
+      def sleep(step)
+        delay = step.fetch("time").to_f
+        shift = step.fetch("shift", 0).to_f
+
+        delay = delay - shift * rand + shift * rand
+
+        log { "Sleep for #{delay}s" }
+
+        Kernel.sleep delay if delay > 0
+
+        log(:done) { "Slept for #{delay}s" }
+      end
+
+      # Prints provided message
+      def debug(step)
+        with_logger do
+          log(nil) { step.fetch("message") }
+        end
+      end
+
+      def receive(step)
+        expected = step["data"] || PartialMatcher.new(step["data>"])
+        ordered = step["ordered"]
+
+        log { "Receive a message: #{expected.truncate(50)}" }
+
+        received = nil
+
+        client.each_message do |msg, id|
+          received = msg
+          if expected.matches?(msg)
+            client.consumed(id)
+            break
+          end
+
+          if ordered
+            raise UnmatchedExpectationError, prepare_receive_error(expected, received)
+          end
+        end
+
+        log(:done) { "Received a message: #{received&.truncate(50)}" }
+      rescue ThreadError
+        if received
+          raise UnmatchedExpectationError, prepare_receive_error(expected, received)
+        else
+          raise NoMessageError, "Expected to receive #{expected} but nothing has been received"
+        end
+      end
+
+      def receive_all(step)
+        messages = step.delete("messages")
+        raise ArgumentError, "Messages array must be specified" if
+          messages.nil? || messages.empty?
+
+        expected =
+          messages.map do |msg|
+            multiplier = parse_multiplier(msg.delete("multiplier") || "1")
+            [msg["data"] || PartialMatcher.new(msg["data>"]), multiplier]
+          end.to_h
+
+        total_expected = expected.values.sum
+        total_received = 0
+
+        log { "Receive #{total_expected} messages" }
+
+        total_expected.times do
+          received = client.receive
+
+          total_received += 1
+
+          match = expected.find { |k, _| k.matches?(received) }
+
+          raise UnexpectedMessageError, "Unexpected message received: #{received}" if
+            match.nil?
+
+          expected[match.first] -= 1
+          expected.delete(match.first) if expected[match.first].zero?
+        end
+
+        log(:done) { "Received #{total_expected} messages" }
+      rescue ThreadError
+        raise NoMessageError,
+          "Expected to receive #{total_expected} messages " \
+          "but received only #{total_received}"
+      end
+      # rubocop: enable Metrics/CyclomaticComplexity
+
+      def send(step)
+        data = step.fetch("data")
+        data = JSON.generate(data) if data.is_a?(Hash)
+
+        client.send(data)
+
+        log(nil) { "Sent message: #{data.truncate(50)}" }
+      end
+
+      def wait_all(_step)
+        log { "Wait all clients" }
+        task.global_holder.wait_all
+        log { "All clients" }
+      end
+
+      def to_proc
+        proc { |step| handle_step(step) }
+      end
+
+      private
+
+      attr_reader :client, :task, :logger, :id, :color
+
+      def build_client(*__rest__, &__block__)
+        Client.new(*__rest__, &__block__)
+      end
+
+      def prepare_receive_error(expected, received)
+        <<~MSG
+          Action failed: #receive
+             -- expected: #{expected.inspect}
+             ++ got: #{received} (#{received.class})
+        MSG
+      end
+
+      def log(state = :begin)
+        return unless logger
+
+        if state == :begin
+          @last_event_at = Time.now.to_f
+        end
+
+        done_info =
+          if state == :done
+            " (#{(Time.now.to_f - @last_event_at).duration})"
+          else
+            ""
+          end
+
+        msg = "[#{Time.now.strftime("%H:%I:%S.%L")}] client=#{id} #{yield}#{done_info}"
+
+        msg = msg.colorize(color) if color
+
+        logger.puts msg
+      end
+
+      def with_logger
+        return yield if logger
+
+        @logger = $stdout
+        yield
+      ensure
+        @logger = nil
+      end
+    end
+  end
+end

data/lib/.rbnext/2.7/wsdirector/protocols/phoenix.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module WSDirector
+  module Protocols
+    # Phoenix Channels protocol
+    # See https://github.com/phoenixframework/phoenix/blob/master/lib/phoenix/socket/serializers/v2_json_serializer.ex
+    class Phoenix < Base
+      attr_reader :topics_to_join_ref
+      attr_accessor :refs_counter, :join_refs_counter
+
+      def initialize(*__rest__, &__block__)
+        super
+
+        @refs_counter = 3
+        @join_refs_counter = 3
+        @topics_to_join_ref = {}
+      end
+
+      def init_client(**options)
+        options[:query] ||= {}
+        # Make sure we use the v2 of the protocol
+        options[:query][:vsn] = "2.0.0"
+
+        super(**options)
+      end
+
+      def join(step)
+        topic = step.fetch("topic")
+
+        join_ref = join_refs_counter
+        self.join_refs_counter += 1
+
+        ref = refs_counter
+        self.refs_counter += 1
+
+        log { "Joining #{topic} (##{ref})" }
+
+        cmd = new_command(:phx_join, topic, join_ref: join_ref, ref: ref)
+
+        client.send(cmd.to_json)
+
+        receive({"data>" => new_command(:phx_reply, topic, join_ref: join_ref, ref: ref, payload: {"status" => "ok"})})
+
+        log(:done) { "Joined #{topic} (##{ref})" }
+      end
+
+      def leave(step)
+        topic = step.fetch("topic")
+        join_ref = topics_to_join_ref.fetch(topic)
+
+        ref = refs_counter
+        self.refs_counter += 1
+
+        cmd = new_command(:phx_leave, topic, join_ref: join_ref, ref: ref)
+        client.send(cmd.to_json)
+
+        receive({"data>" => new_command(:phx_reply, topic, join_ref: join_ref, ref: ref, payload: {"status" => "ok"})})
+
+        log(nil) { "Left #{topic} (##{join_ref})" }
+      end
+
+      def send(step)
+        return super unless step.key?("topic")
+
+        ref = refs_counter
+        self.refs_counter += 1
+
+        topic = step.fetch("topic")
+        event = step.fetch("event")
+        payload = step["data"]
+
+        super({"data" => new_command(event, topic, payload: payload, ref: ref).to_json})
+      end
+
+      def receive(step)
+        return super unless step.key?("topic")
+
+        topic = step.fetch("topic")
+        event = step.fetch("event")
+
+        key = step.key?("data") ? "data" : "data>"
+        payload = step.fetch(key)
+
+        cmd = new_command(event, topic, payload: payload)
+
+        super({key => cmd})
+      end
+
+      private
+
+      def new_command(event, topic, join_ref: nil, ref: nil, payload: {})
+        [
+          join_ref&.to_s,
+          ref&.to_s,
+          topic.to_s,
+          event.to_s,
+          payload
+        ]
+      end
+    end
+  end
+end