wsdirector-cli 0.4.0 → 1.0.0

data/bin/wsdirector

@@ -1,15 +0,0 @@
-#!/usr/bin/env ruby
-
-require "rubygems"
-
-$:.unshift(File.expand_path(__dir__ + "/../lib"))
-
-require "wsdirector/cli"
-
-begin
-  WSDirector::CLI.new.tap { |cli| cli.run }
-rescue => e
-  STDERR.puts e.message
-  STDERR.puts e.backtrace.join("\n")
-  exit 1
-end

data/lib/wsdirector/cli.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-require "optparse"
-
-require "wsdirector"
-require "wsdirector/scenario_reader"
-require "wsdirector/runner"
-
-module WSDirector
-  # Command line interface for WsDirector
-  class CLI
-    def initialize
-    end
-
-    def run
-      parse_args!
-
-      begin
-        require "colorize" if WSDirector.config.colorize?
-      rescue LoadError
-        WSDirector.config.colorize = false
-        warn "Install colorize to use colored output"
-      end
-
-      scenario = WSDirector::ScenarioReader.parse(
-        WSDirector.config.scenario_path
-      )
-
-      if WSDirector::Runner.new(scenario).start
-        exit 0
-      else
-        exit 1
-      end
-    rescue Error => e
-      warn e.message
-      exit 1
-    end
-
-    private
-
-    def parse_args!
-      # rubocop: disable Metrics/LineLength
-      parser = OptionParser.new do |opts|
-        opts.banner = "Usage: wsdirector scenario_path ws_url [options]"
-
-        opts.on("-s SCALE", "--scale=SCALE", Integer, "Scale factor") do |v|
-          WSDirector.config.scale = v
-        end
-
-        opts.on("-t TIMEOUT", "--timeout=TIMEOUT", Integer, "Synchronization (wait_all) timeout") do |v|
-          WSDirector.config.sync_timeout = v
-        end
-
-        opts.on("-c", "--[no-]color", "Colorize output") do |v|
-          WSDirector.config.colorize = v
-        end
-
-        opts.on("-v", "--version", "Print versin") do
-          $stdout.puts WSDirector::VERSION
-          exit 0
-        end
-      end
-      # rubocop: enable Metrics/LineLength
-
-      parser.parse!
-
-      WSDirector.config.scenario_path = ARGV[0]
-      WSDirector.config.ws_url = ARGV[1]
-
-      raise(Error, "Scenario path is missing") if WSDirector.config.scenario_path.nil?
-
-      raise(Error, "File doesn't exist #{WSDirector.config.scenario_path}") unless
-        File.file?(WSDirector.config.scenario_path)
-
-      raise(Error, "Websocket server url is missing") if WSDirector.config.ws_url.nil?
-    end
-  end
-end

data/lib/wsdirector/client.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require "websocket-client-simple"
-require "securerandom"
-
-module WSDirector
-  # WebSocket client
-  class Client
-    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(ignore: nil)
-      @ignore = ignore
-      has_messages = @has_messages = Concurrent::Semaphore.new(0)
-      messages = @messages = Queue.new
-      path = WSDirector.config.ws_url
-      open = Concurrent::Promise.new
-      client = self
-
-      @id = SecureRandom.hex(6)
-      @ws = WebSocket::Client::Simple.connect(path) 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)
-          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 #{path}"
-    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
-
-    def send(msg)
-      @ws.send(msg)
-    end
-
-    def ignored?(msg)
-      return false unless @ignore
-      @ignore.any? { |pattern| msg =~ pattern }
-    end
-  end
-end

data/lib/wsdirector/clients_holder.rb

@@ -1,23 +0,0 @@
-# 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)
-      @barrier = Concurrent::CyclicBarrier.new(count)
-    end
-
-    def wait_all
-      result = barrier.wait(WSDirector.config.sync_timeout)
-      raise Error, "Timeout (#{WSDirector.config.sync_timeout}s) exceeded for #wait_all" unless
-        result
-      barrier.reset
-      result
-    end
-
-    private
-
-    attr_reader :barrier
-  end
-end

data/lib/wsdirector/configuration.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module WSDirector
-  # WSDirector configuration
-  class Configuration
-    attr_accessor :ws_url, :scenario_path, :colorize, :scale,
-      :sync_timeout
-
-    def initialize
-      reset!
-    end
-
-    def colorize?
-      colorize == true
-    end
-
-    # Restore to defaults
-    def reset!
-      @scale = 1
-      @colorize = false
-      @sync_timeout = 5
-    end
-  end
-end

data/lib/wsdirector/ext/deep_dup.rb

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

data/lib/wsdirector/printer.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module WSDirector
-  # Print messages (optionally colorized) to STDOUT
-  class Printer
-    def self.out(message, color = nil)
-      message = message.colorize(color) if WSDirector.config.colorize? && color
-      $stdout.puts(message)
-    end
-  end
-end

data/lib/wsdirector/protocols/action_cable.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module WSDirector
-  module Protocols
-    # ActionCable protocol
-    class ActionCable < Base
-      WELCOME_MSG = {type: "welcome"}.to_json
-      PING_IGNORE = /['"]type['"]:\s*['"]ping['"]/
-
-      # Add ping ignore and make sure that we receive Welcome message
-      def init_client(**options)
-        options[:ignore] ||= [PING_IGNORE]
-
-        super(**options)
-
-        receive("data" => WELCOME_MSG)
-      end
-
-      def subscribe(step)
-        identifier = extract_identifier(step)
-
-        client.send({command: "subscribe", identifier: identifier}.to_json)
-
-        begin
-          receive(
-            "data" => {"type" => "confirm_subscription", "identifier" => identifier}
-          )
-        rescue UnmatchedExpectationError => e
-          raise unless /reject_subscription/.match?(e.message)
-          raise UnmatchedExpectationError, "Subscription rejected to #{identifier}"
-        end
-      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: action).to_json
-
-        client.send({command: "message", data: data, identifier: identifier}.to_json)
-      end
-
-      def receive(step)
-        return super unless step.key?("channel")
-
-        identifier = extract_identifier(step)
-        message = step.fetch("data", {})
-        super("data" => {"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)
-          msg["data"] = {"identifier" => identifier, "message" => msg["data"]}
-        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

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-require "time"
-
-module WSDirector
-  module Protocols
-    # Base protocol describes basic actions
-    class Base
-      include WSDirector::Utils
-
-      def initialize(task)
-        @task = task
-      end
-
-      def init_client(**options)
-        @client = build_client(**options)
-      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
-
-        print("Sleep for #{delay}s") if step.fetch("debug", false)
-
-        Kernel.sleep delay if delay > 0
-      end
-
-      # Prints provided message
-      def debug(step)
-        print(step.fetch("message"))
-      end
-
-      def receive(step)
-        expected = step.fetch("data")
-        received = client.receive
-        raise UnmatchedExpectationError, prepare_receive_error(expected, received) unless
-          receive_matches?(expected, received)
-      rescue ThreadError
-        raise NoMessageError, "Expected to receive #{expected} but nothing has been received"
-      end
-
-      # rubocop: disable Metrics/CyclomaticComplexity
-      def receive_all(step)
-        messages = step.delete("messages")
-        raise ArgumentError, "Messages array must be specified" if
-          messages.nil? || messages.empty?
-
-        expected =
-          Hash[messages.map do |msg|
-            multiplier = parse_multiplier(msg.delete("multiplier") || "1")
-            [msg["data"], multiplier]
-          end]
-
-        total_expected = expected.values.sum
-        total_received = 0
-
-        total_expected.times do
-          received = client.receive
-
-          total_received += 1
-
-          match = expected.find { |k, _| receive_matches?(k, received) }
-
-          raise UnexpectedMessageError, "Unexpected message received: #{received}" if
-            match.nil?
-
-          expected[match.first] -= 1
-          expected.delete(match.first) if expected[match.first].zero?
-        end
-      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)
-      end
-
-      def wait_all(_step)
-        task.global_holder.wait_all
-      end
-
-      def to_proc
-        proc { |step| handle_step(step) }
-      end
-
-      private
-
-      attr_reader :client, :task
-
-      def build_client(**options)
-        Client.new(**options)
-      end
-
-      def receive_matches?(expected, received)
-        received = JSON.parse(received) if expected.is_a?(Hash)
-
-        received == expected
-      end
-
-      def prepare_receive_error(expected, received)
-        <<~MSG
-          Action failed: #receive
-             -- expected: #{expected}
-             ++ got: #{received}
-        MSG
-      end
-
-      def print(msg)
-        $stdout.puts "DEBUG #{Time.now.iso8601}  client=#{client.id} #{msg}\n"
-      end
-    end
-  end
-end

data/lib/wsdirector/protocols.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require "wsdirector/protocols/base"
-require "wsdirector/protocols/action_cable"
-
-module WSDirector
-  ID2CLASS = {
-    "base" => "Base",
-    "action_cable" => "ActionCable"
-  }.freeze
-
-  module Protocols # :nodoc:
-    # Raised when received not expected message
-    class UnmatchedExpectationError < WSDirector::Error; end
-    # Raised when received message is unexpected
-    class UnexpectedMessageError < WSDirector::Error; end
-    # Raised when nothing has been received
-    class NoMessageError < WSDirector::Error; end
-
-    class << self
-      def get(id)
-        raise Error, "Unknown protocol: #{id}" unless ID2CLASS.key?(id)
-        class_name = ID2CLASS.fetch(id)
-        const_get(class_name)
-      end
-    end
-  end
-end

data/lib/wsdirector/result.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module WSDirector
-  # Handle results from all clients from the group
-  class Result
-    attr_reader :group, :errors
-
-    def initialize(group)
-      @group = group
-      @errors = Concurrent::Array.new
-
-      @all = Concurrent::AtomicFixnum.new(0)
-      @failures = Concurrent::AtomicFixnum.new(0)
-
-      @sampling_mutex = Mutex.new
-      @sampling_counter = Hash.new { |h, k| h[k] = 0 }
-    end
-
-    # Called when client successfully finished it's work
-    def succeed
-      all.increment
-    end
-
-    # Called when client failed
-    def failed(error_message)
-      errors << error_message
-      all.increment
-      failures.increment
-    end
-
-    def success?
-      failures.value.zero?
-    end
-
-    def total_count
-      all.value
-    end
-
-    def failures_count
-      failures.value
-    end
-
-    def track_sample(id, max)
-      sampling_mutex.synchronize do
-        return false if sampling_counter[id] >= max
-
-        sampling_counter[id] += 1
-        true
-      end
-    end
-
-    private
-
-    attr_reader :all, :success, :failures, :sampling_counter, :sampling_mutex
-  end
-end

data/lib/wsdirector/results_holder.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require "wsdirector/printer"
-
-module WSDirector
-  # Holds all results for all groups of clients
-  class ResultsHolder
-    def initialize
-      @groups = Concurrent::Map.new
-    end
-
-    def success?
-      @groups.values.all?(&:success?)
-    end
-
-    def print_summary
-      single_group = groups.size == 1
-      groups.each do |group, result|
-        color = result.success? ? :green : :red
-        prefix = single_group ? "" : "Group #{group}: "
-        Printer.out(
-          "#{prefix}#{result.total_count} clients, #{result.failures_count} failures\n",
-          color
-        )
-
-        unless result.success?
-          print_errors(result.errors)
-          Printer.out "\n"
-        end
-      end
-    end
-
-    def <<(result)
-      groups[result.group] = result
-    end
-
-    private
-
-    attr_reader :groups
-
-    def print_errors(errors)
-      Printer.out "\n"
-      errors.each.with_index do |error, i|
-        Printer.out "#{i + 1}) #{error}\n", :red
-      end
-    end
-  end
-end

data/lib/wsdirector/runner.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require "wsdirector/clients_holder"
-require "wsdirector/results_holder"
-require "wsdirector/result"
-require "wsdirector/task"
-require "wsdirector/ext/deep_dup"
-
-module WSDirector
-  # Initiates all clients as a separate tasks (=threads)
-  class Runner
-    using WSDirector::Ext::DeepDup
-
-    def initialize(scenario)
-      @scenario = scenario
-      @total_count = scenario["total"]
-      @global_holder = ClientsHolder.new(total_count)
-      @results_holder = ResultsHolder.new
-    end
-
-    def start
-      Thread.abort_on_exception = true
-
-      tasks = scenario["clients"].flat_map do |client|
-        result = Result.new(client.fetch("name"))
-        results_holder << result
-
-        Array.new(client.fetch("multiplier")) do
-          Thread.new do
-            Task.new(client.deep_dup, global_holder: global_holder, result: result)
-              .run
-          end
-        end
-      end
-
-      tasks.each(&:join)
-      results_holder.print_summary
-      results_holder.success?
-    end
-
-    private
-
-    attr_reader :scenario, :total_count, :global_holder, :results_holder
-  end
-end