wsdirector-core 0.0.1 → 1.0.0

data/lib/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}=#{escape(_2.to_s)}" }.join("; ")
+      end
+
+      if query
+        url = "#{url}?#{query.map { "#{_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/wsdirector/clients_holder.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module WSDirector
+  # Acts as a re-usable global barrier for a fixed number of clients.
+  # Barrier is reset if sucessfully passed in time.
+  class ClientsHolder
+    def initialize(count, sync_timeout: 5)
+      @barrier = Concurrent::CyclicBarrier.new(count)
+      @sync_timeout = sync_timeout
+    end
+
+    def wait_all
+      result = barrier.wait(sync_timeout)
+      raise Error, "Timeout (#{sync_timeout}s) exceeded for #wait_all" unless
+        result
+      barrier.reset
+      result
+    end
+
+    private
+
+    attr_reader :barrier, :sync_timeout
+  end
+end

data/lib/wsdirector/ext/deep_dup.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module WSDirector
+  module Ext
+    # Extend Object through refinements
+    module DeepDup
+      refine ::Hash do
+        # Based on ActiveSupport http://api.rubyonrails.org/classes/Hash.html#method-i-deep_dup
+        def deep_dup
+          each_with_object(dup) do |(key, value), hash|
+            hash[key] = if value.is_a?(::Hash) || value.is_a?(::Array)
+              value.deep_dup
+            else
+              value
+            end
+          end
+        end
+      end
+
+      refine ::Array do
+        # From ActiveSupport http://api.rubyonrails.org/classes/Array.html#method-i-deep_dup
+        def deep_dup
+          map do |value|
+            if value.is_a?(::Hash) || value.is_a?(::Array)
+              value.deep_dup
+            else
+              value
+            end
+          end
+        end
+      end
+
+      refine ::Object do
+        def deep_dup
+          dup
+        end
+      end
+    end
+  end
+end

data/lib/wsdirector/ext/formatting.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module WSDirector
+  module Ext
+    # Extend Object through refinements
+    module Formatting
+      refine ::Object do
+        def truncate(*) = itself
+      end
+
+      refine ::String do
+        def truncate(limit)
+          return self if size <= limit
+
+          "#{self[0..(limit - 3)]}..."
+        end
+      end
+
+      refine ::Hash do
+        def truncate(limit)
+          str = to_json
+
+          str.truncate(limit)
+        end
+      end
+
+      refine ::Float do
+        def duration
+          if self > 1
+            "#{truncate(2)}s"
+          else
+            "#{(self * 1000).to_i}ms"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wsdirector/protocols/action_cable.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module WSDirector
+  module Protocols
+    # ActionCable protocol
+    class ActionCable < Base
+      PING_IGNORE = /['"]type['"]:\s*['"]ping['"]/
+
+      # Add ping ignore and make sure that we receive Welcome message
+      def init_client(**options)
+        options[:ignore] ||= [PING_IGNORE]
+        options[:subprotocol] ||= "actioncable-v1-json"
+
+        super(**options)
+
+        receive("data>" => {"type" => "welcome"})
+        log(:done) { "Welcomed" }
+      end
+
+      def subscribe(step)
+        identifier = extract_identifier(step)
+
+        log { "Subsribing to #{identifier}" }
+
+        client.send({command: "subscribe", identifier:}.to_json)
+
+        begin
+          receive(
+            "data" => {"type" => "confirm_subscription", "identifier" => identifier}
+          )
+          log(:done) { "Subsribed to #{identifier}" }
+        rescue UnmatchedExpectationError => e
+          raise unless /reject_subscription/.match?(e.message)
+          raise UnmatchedExpectationError, "Subscription rejected to #{identifier}"
+        end
+      end
+
+      def unsubscribe(step)
+        identifier = extract_identifier(step)
+
+        client.send({command: "unsubscribe", identifier:}.to_json)
+
+        log(nil) { "Unsubscribed from #{identifier}" }
+      end
+
+      def perform(step)
+        identifier = extract_identifier(step)
+        action = step.delete("action")
+
+        raise Error, "Action is missing" unless action
+
+        data = step.fetch("data", {}).merge(action:).to_json
+
+        client.send({command: "message", data:, identifier:}.to_json)
+
+        log(nil) { "Performed #{action} on #{identifier}" }
+      end
+
+      def receive(step)
+        return super unless step.key?("channel")
+
+        identifier = extract_identifier(step)
+
+        key = step.key?("data") ? "data" : "data>"
+
+        message = step.fetch(key, {})
+        super(key => {"identifier" => identifier, "message" => message})
+      end
+
+      def receive_all(step)
+        messages = step["messages"]
+
+        return super if messages.nil? || messages.empty?
+
+        messages.each do |msg|
+          next unless msg.key?("channel")
+          identifier = extract_identifier(msg)
+
+          key = msg.key?("data") ? "data" : "data>"
+
+          msg[key] = {"identifier" => identifier, "message" => msg[key]}
+        end
+
+        super
+      end
+
+      private
+
+      def extract_identifier(step)
+        channel = step.delete("channel")
+        step.fetch("params", {}).merge(channel: channel).to_json
+      end
+    end
+  end
+end

data/lib/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
+            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
+            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
+            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
+            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(...) = obj.truncate(...)
+    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(...)
+        log { "Connecting" }
+
+        @client = build_client(...)
+
+        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(...)
+        Client.new(...)
+      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/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(...)
+        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:, ref:)
+
+        client.send(cmd.to_json)
+
+        receive({"data>" => new_command(:phx_reply, topic, join_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:, ref:)
+        client.send(cmd.to_json)
+
+        receive({"data>" => new_command(:phx_reply, topic, join_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:, 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:)
+
+        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