bugsnag-maze-runner 7.22.1

data/lib/maze/terminating_server.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'socket'
+
+module Maze
+  # Receives and terminates network connections without reading any data
+  class TerminatingServer
+    CONTINUE_RESPONSE = "HTTP/1.1 100 CONTINUE\n\r"
+    BAD_REQUEST_RESPONSE = "HTTP/1.1 400 BAD REQUEST\n\r"
+
+    class << self
+
+      # Starts the socket accept loop in a separate thread
+      def start
+        # Only run a single server thread
+        return if running?
+
+        attempts = 0
+        loop do
+
+          @thread = Thread.new do
+            # Reset the received count
+            @received_requests = 0
+
+            Socket.tcp_server_loop(Maze.config.null_port) {|socket, _client_addrinfo|
+              $logger.info 'Terminating server received request'
+              @received_requests += 1
+              headers = receive_headers(socket)
+
+              body_length = headers['Content-Length']
+              receive_data(socket, body_length) unless body_length.nil?
+
+              end_connection(socket)
+            }
+          rescue StandardError => e
+            $logger.warn "Terminating server error: #{e.message}"
+          end
+
+          break if running?
+
+          # Bail out after 3 attempts
+          attempts += 1
+          raise 'Too many failed attempts to start terminating server' if attempts == 3
+
+          # Failed to start - sleep before retrying
+          $logger.info 'Retrying in 3 seconds'
+          sleep 1
+        end
+      end
+
+      # The maximum string length to be received before disconnecting
+      #
+      # @return [Integer] The string length, defaults to 1MB
+      def max_received_size
+        @max_received_size ||= 1048576
+      end
+
+      # Set the maximum string length to be received before disconnecting
+      #
+      # @param new_max_size [Integer] The new maximum size
+      def max_received_size=(new_max_size)
+        @max_received_size = new_max_size
+      end
+
+      # The response string sent to a connected client
+      #
+      # @return [String] The response string, defaults to "400/BAD REQUEST"
+      def response
+        @response ||= BAD_REQUEST_RESPONSE
+      end
+
+      # Set the response string to an arbitrary value
+      #
+      # @param new_response [String] The new response
+      def response=(new_response)
+        @response = new_response
+      end
+
+      # Resets the response string to "400/BAD REQUEST" and the read size to 1MB
+      def reset_elements
+        @response = BAD_REQUEST_RESPONSE
+        @max_received_size = 1048576
+      end
+
+      # Whether the server thread is running
+      #
+      # @return [Boolean] If the server is running
+      def running?
+        @thread&.alive?
+      end
+
+      # Outputs the amount of times the server has received a connection on the last run
+      def received_request_count
+        @received_requests ||= 0
+      end
+
+      # Stops the socket accept loop if alive
+      def stop
+        @thread&.kill if @thread&.alive?
+        @thread = nil
+      end
+
+      private
+
+      def receive_headers(socket)
+        headers = {}
+        while (request = socket.gets) && (request.chomp.length > 0)
+          key, val = request.chomp.split(': ')
+          headers[key] = val
+          $logger.debug "Received #{headers.size} headers"
+        end
+        headers
+      end
+
+      def receive_data(socket, body_length)
+        read_length = body_length.to_i < max_received_size ? body_length.to_i : max_received_size
+        $logger.info "Reading #{read_length} bytes"
+        socket.read(read_length)
+      end
+
+      def end_connection(socket)
+        $logger.info "Responding with: #{response}"
+        # Unlikely to be used, but replicates pipeline response
+        socket.print response
+        socket.close
+      end
+    end
+  end
+end

data/lib/maze/timers.rb

@@ -0,0 +1,51 @@
+module Maze
+
+  # A simple run/stop timer
+  class Timer
+    attr_accessor :total
+
+    def initialize
+      @total = 0
+    end
+
+    def time(&block)
+      start = Time.now
+
+      block.call
+    ensure
+      @total += Time.now - start
+    end
+
+    def reset
+      @total = 0
+    end
+  end
+
+  # Stores a collection of timers
+  class Timers
+    def initialize
+      @timers = {}
+    end
+
+    def add(name)
+      timer = Timer.new
+      @timers[name] = timer
+      timer
+    end
+
+    def get(name)
+      @timers[name]
+    end
+
+    def size
+      @timers.size
+    end
+
+    def report
+      $logger.info 'Timer totals:'
+      @timers.sort.each do |name, timer|
+        $logger.info "  #{name}: #{timer.total}"
+      end
+    end
+  end
+end

data/lib/maze/wait.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Maze
+  # Allows repeated attempts at something, until it is successful or the timeout
+  # is exceed
+  class Wait
+    # @param interval [Numeric] Optional. The time to sleep between attempts
+    # @param timeout [Numeric] The amount of time to spend on attempts before giving up
+    def initialize(interval: 0.1, timeout:)
+      raise "Interval must be greater than zero, got '#{interval}'" unless interval > 0
+      raise "Timeout (#{timeout}) must be greater than interval (#{interval})" unless timeout > interval
+
+      @interval = interval
+      @max_attempts = timeout / interval
+    end
+
+    # Wait until the given block succeeds (returns a truthy value) or the
+    # timeout is exceeded
+    #
+    # @return [Object] The last value returned by the block
+    def until(&block)
+      success = false
+      attempts = 0
+
+      until success || attempts >= @max_attempts do
+        attempts += 1
+        success = block.call
+
+        sleep @interval unless success
+      end
+
+      success
+    end
+  end
+end

data/lib/maze.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'maze/configuration'
+require_relative 'maze/hooks/hooks'
+require_relative 'maze/timers'
+
+# Glues the various parts of MazeRunner together that need to be accessed globally,
+# providing an alternative to the proliferation of global variables or singletons.
+module Maze
+  VERSION = '7.22.1'
+
+  class << self
+    attr_accessor :check, :driver, :internal_hooks, :mode, :start_time, :dynamic_retry, :public_address, :run_uuid
+
+    def config
+      @config ||= Maze::Configuration.new
+    end
+
+    def hooks
+      @hooks ||= Maze::Hooks::Hooks.new
+    end
+
+    def timers
+      @timers ||= Maze::Timers.new
+    end
+  end
+end

data/lib/utils/deep_merge.rb

@@ -0,0 +1,17 @@
+class Hash
+  def deep_merge!(other_hash, &block)
+    merge!(other_hash) do |key, this_val, other_val|
+      if this_val.is_a?(Hash) && other_val.is_a?(Hash)
+        this_val.deep_merge(other_val, &block)
+      elsif block_given?
+        block.call(key, this_val, other_val)
+      else
+        other_val
+      end
+    end
+  end
+
+  def deep_merge(other_hash, &block)
+    dup.deep_merge!(other_hash, &block)
+  end
+end

data/lib/utils/selenium_money_patch.rb

@@ -0,0 +1,17 @@
+# Log the full response so we see more than just the error code
+module Selenium
+  module WebDriver
+    module Error
+      class ServerError < StandardError
+        def initialize(response)
+          if response.is_a? String
+            super(response)
+          else
+            $logger.error "Server response: #{response.inspect}"
+            super("status code #{response.code}")
+          end
+        end
+      end # ServerError
+    end # Error
+  end # WebDriver
+end # Selenium