specwrk 0.1.0

data/lib/specwrk/queue.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "time"
+require "json"
+
+module Specwrk
+  # Thread-safe Hash access
+  class Queue
+    def initialize(hash = {})
+      if block_given?
+        @mutex = Monitor.new # Reentrant locking is required here
+        # It's possible to enter the proc from two threads, so we need to ||= in case
+        # one thread has set a value prior to the yield.
+        hash.default_proc = proc { |h, key| @mutex.synchronize { yield(h, key) } }
+      end
+
+      @mutex ||= Mutex.new # Monitor is up-to 20% slower than Mutex, so if no block is given, use a mutex
+      @hash = hash
+    end
+
+    def synchronize(&blk)
+      @mutex.synchronize { yield(@hash) }
+    end
+
+    def method_missing(name, *args, &block)
+      if @hash.respond_to?(name)
+        @mutex.synchronize { @hash.public_send(name, *args, &block) }
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      @hash.respond_to?(name, include_private) || super
+    end
+  end
+
+  class PendingQueue < Queue
+    attr_reader :previous_run_times
+
+    def shift_bucket
+      return bucket_by_file unless previous_run_times
+
+      case ENV["SPECWRK_SRV_GROUP_BY"]
+      when "file"
+        bucket_by_file
+      else
+        bucket_by_timings
+      end
+    end
+
+    def run_time_bucket_threshold
+      return 1 unless previous_run_times
+
+      previous_run_times.dig(:meta, :average_run_time)
+    end
+
+    # TODO: move reading the file to the getter method
+    def previous_run_times_file=(path)
+      return unless path
+      return unless File.exist? path
+
+      File.open(path, "r") do |file|
+        file.flock(File::LOCK_EX)
+
+        @previous_run_times = JSON.parse(file.read, symbolize_names: true)
+
+        file.flock(File::LOCK_UN)
+      end
+    end
+
+    def merge_with_previous_run_times!(h2)
+      @mutex.synchronize do
+        h2.each { |_id, example| merge_example(example) }
+
+        # Sort by exepcted run time, slowest to fastest
+        @hash = @hash.sort_by { |_, example| example[:expected_run_time] }.reverse.to_h
+      end
+    end
+
+    private
+
+    # Take elements from the hash where the file_path is the same
+    def bucket_by_file
+      bucket = []
+
+      @mutex.synchronize do
+        key = @hash.keys.first
+        break if key.nil?
+
+        file_path = @hash[key][:file_path]
+        @hash.each do |id, example|
+          next unless example[:file_path] == file_path
+
+          bucket << example
+          @hash.delete id
+        end
+      end
+
+      bucket
+    end
+
+    # Take elements from the hash until the average runtime bucket has filled
+    def bucket_by_timings
+      bucket = []
+
+      @mutex.synchronize do
+        estimated_run_time_total = 0
+
+        while estimated_run_time_total < run_time_bucket_threshold
+          key = @hash.keys.first
+          break if key.nil?
+
+          estimated_run_time_total += @hash.dig(key, :expected_run_time)
+          break if estimated_run_time_total > run_time_bucket_threshold && bucket.length.positive?
+
+          bucket << @hash[key]
+          @hash.delete key
+        end
+      end
+
+      bucket
+    end
+
+    # Ensure @mutex is held when calling this method
+    def merge_example(example)
+      return if @hash.key? example[:id]
+      return if @hash.key? example[:file_path]
+
+      @hash[example[:id]] = if previous_run_times
+        example.merge!(
+          expected_run_time: previous_run_times.dig(:examples, example[:id].to_sym, :run_time) || 99999.9 # run "unknown" files first
+        )
+      else
+        example.merge!(
+          expected_run_time: 99999.9 # run "unknown" files first
+        )
+      end
+    end
+  end
+
+  class CompletedQueue < Queue
+    def dump_and_write(path)
+      write_output_to(path, dump)
+    end
+
+    def dump
+      @mutex.synchronize do
+        @run_times = []
+        @first_started_at = Time.new(2999, 1, 1, 0, 0, 0) # TODO: Make future proof /s
+        @last_finished_at = Time.new(1900, 1, 1, 0, 0, 0)
+
+        @output = {
+          file_totals: Hash.new { |h, filename| h[filename] = 0.0 },
+          meta: {failures: 0, passes: 0, pending: 0},
+          examples: {}
+        }
+
+        @hash.values.each { |example| calculate(example) }
+
+        @output[:meta][:total_run_time] = @run_times.sum
+        @output[:meta][:average_run_time] = @output[:meta][:total_run_time] / @run_times.length.to_f
+        @output[:meta][:first_started_at] = @first_started_at.iso8601(6)
+        @output[:meta][:last_finished_at] = @last_finished_at.iso8601(6)
+
+        @output
+      end
+    end
+
+    private
+
+    def calculate(example)
+      @run_times << example[:run_time]
+      @output[:file_totals][example[:file_path]] += example[:run_time]
+
+      started_at = Time.parse(example[:started_at])
+      finished_at = Time.parse(example[:finished_at])
+
+      @first_started_at = started_at if started_at < @first_started_at
+      @last_finished_at = finished_at if finished_at > @last_finished_at
+
+      case example[:status]
+      when "passed"
+        @output[:meta][:passes] += 1
+      when "failed"
+        @output[:meta][:failures] += 1
+      when "pending"
+        @output[:meta][:pending] += 1
+      end
+
+      @output[:examples][example[:id]] = example
+    end
+
+    def write_output_to(path, output)
+      File.open(path, "w") do |file|
+        file.flock(File::LOCK_EX)
+
+        file.write JSON.pretty_generate(output)
+
+        file.flock(File::LOCK_UN)
+      end
+    end
+  end
+end

data/lib/specwrk/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Specwrk
+  VERSION = "0.1.0"
+end

data/lib/specwrk/web/app.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "webrick"
+require "rack"
+
+# rack v3 or v2
+begin
+  require "rackup/handler/webrick"
+rescue LoadError
+  require "rack/handler/webrick"
+end
+
+require "specwrk/web/auth"
+require "specwrk/web/endpoints"
+
+module Specwrk
+  class Web
+    class App
+      def self.run!
+        Process.setproctitle "specwrk-server"
+
+        server_opts = {
+          Port: ENV.fetch("SPECWRK_SRV_PORT", "5138").to_i,
+          Logger: WEBrick::Log.new($stdout, WEBrick::Log::FATAL),
+          AccessLog: [],
+          KeepAliveTimeout: 300
+        }
+
+        # rack v3 or v2
+        handler_klass = defined?(Rackup::Handler) ? Rackup::Handler::WEBrick : Rack::Handler.get("webrick")
+
+        handler_klass.run(rackup, **server_opts) do |server|
+          ["INT", "TERM"].each do |sig|
+            trap(sig) do
+              puts "\n→ Shutting down gracefully..." unless ENV["SPECWRK_FORKED"]
+              server.shutdown
+            end
+          end
+        end
+      end
+
+      def call(env)
+        request = Rack::Request.new(env)
+
+        route(method: request.request_method, path: request.path_info)
+          .new(request)
+          .response
+      end
+
+      private_class_method def self.rackup
+        Rack::Builder.new do
+          use Specwrk::Web::Auth          # global auth check
+          run Specwrk::Web::App.new       # your router
+        end
+      end
+
+      def route(method:, path:)
+        case [method, path]
+        when ["GET", "/heartbeat"]
+          Endpoints::Heartbeat
+        when ["POST", "/pop"]
+          Endpoints::Pop
+        when ["POST", "/complete"]
+          Endpoints::Complete
+        when ["POST", "/seed"]
+          Endpoints::Seed
+        when ["GET", "/stats"]
+          Endpoints::Stats
+        when ["DELETE", "/shutdown"]
+          Endpoints::Shutdown
+        else
+          Endpoints::NotFound
+        end
+      end
+    end
+  end
+end

data/lib/specwrk/web/auth.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rack/auth/abstract/request"
+
+module Specwrk
+  class Web
+    class Auth
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        return @app.call(env) if [nil, ""].include? ENV["SPECWRK_SRV_KEY"]
+
+        auth = Rack::Auth::AbstractRequest.new(env)
+
+        return unauthorized unless auth.provided?
+        return unauthorized unless auth.scheme == "bearer"
+        return unauthorized unless Rack::Utils.secure_compare(auth.params, ENV["SPECWRK_SRV_KEY"])
+
+        @app.call(env)
+      end
+
+      private
+
+      def unauthorized
+        [401, {"Content-Type" => "application/json"}, ["Unauthorized"]]
+      end
+    end
+  end
+end

data/lib/specwrk/web/endpoints.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Specwrk
+  class Web
+    module Endpoints
+      class Base
+        def initialize(request)
+          @request = request
+        end
+
+        def response
+          not_found
+        end
+
+        private
+
+        attr_reader :request
+
+        def not_found
+          [404, {"Content-Type" => "text/plain"}, ["This is not the path you're looking for, 'ol chap..."]]
+        end
+
+        def ok
+          [200, {"Content-Type" => "text/plain"}, ["OK, 'ol chap"]]
+        end
+
+        def payload
+          @payload ||= JSON.parse(body, symbolize_names: true)
+        end
+
+        def body
+          @body ||= request.body.read
+        end
+
+        def pending_queue
+          Web::PENDING_QUEUES[request.get_header("HTTP_X_SPECWRK_RUN")]
+        end
+
+        def processing_queue
+          Web::PROCESSING_QUEUES[request.get_header("HTTP_X_SPECWRK_RUN")]
+        end
+
+        def completed_queue
+          Web::COMPLETED_QUEUES[request.get_header("HTTP_X_SPECWRK_RUN")]
+        end
+      end
+
+      # Base default response is 404
+      NotFound = Class.new(Base)
+
+      class Heartbeat < Base
+        def response
+          ok
+        end
+      end
+
+      class Seed < Base
+        def response
+          examples = payload.map { |hash| [hash[:id], hash] }.to_h
+          pending_queue.merge_with_previous_run_times!(examples)
+
+          ok
+        end
+      end
+
+      class Complete < Base
+        def response
+          processing_queue.synchronize do |processing_queue_hash|
+            payload.each do |example|
+              processing_queue_hash.delete(example[:id])
+              completed_queue[example[:id]] = example
+            end
+          end
+
+          if pending_queue.length.zero? && processing_queue.length.zero? && ENV["SPECWRK_SRV_OUTPUT"]
+            completed_queue.dump_and_write(ENV["SPECWRK_SRV_OUTPUT"])
+          end
+
+          ok
+        end
+      end
+
+      class Pop < Base
+        def response
+          processing_queue.synchronize do |processing_queue_hash|
+            @examples = pending_queue.shift_bucket
+
+            @examples.each do |example|
+              processing_queue_hash[example[:id]] = example
+            end
+          end
+
+          if @examples.length.positive?
+            [200, {"Content-Type" => "application/json"}, [JSON.generate(@examples)]]
+          elsif processing_queue.length.zero?
+            [410, {"Content-Type" => "text/plain"}, ["That's a good lad. Run along now and go home."]]
+          else
+            not_found
+          end
+        end
+      end
+
+      class Stats < Base
+        def response
+          data = {
+            pending: {count: pending_queue.length},
+            processing: {count: processing_queue.length},
+            completed: completed_queue.dump
+          }
+
+          if data.dig(:completed, :examples).length.positive?
+            [200, {"Content-Type" => "application/json"}, [JSON.generate(data)]]
+          else
+            not_found
+          end
+        end
+      end
+
+      class Shutdown < Base
+        def response
+          if ENV["SPECWRK_SRV_SINGLE_RUN"]
+            interupt!
+          elsif processing_queue.length.positive?
+            # Push any processing jobs back into the pending queue
+            processing_queue.synchronize do |processing_queue_hash|
+              pending_queue.synchronize do |pending_queue_hash|
+                processing_queue_hash.each do |id, example|
+                  pending_queue_hash[id] = example
+                  processing_queue_hash.delete(id)
+                end
+              end
+            end
+
+          elsif processing_queue.length.zero? && pending_queue.length.zero?
+            # All done, we can clear the completed queue
+            completed_queue.clear
+          end
+
+          # TODO: clear any zombie queues
+
+          [200, {"Content-Type" => "text/plain"}, ["✌️"]]
+        end
+
+        def interupt!
+          Thread.new do
+            # give the socket a moment to flush the response
+            sleep 0.2
+            Process.kill("INT", Process.pid)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/specwrk/web.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "specwrk/queue"
+
+module Specwrk
+  class Web
+    PENDING_QUEUES = Queue.new { |h, key| h[key] = PendingQueue.new.tap { |q| q.previous_run_times_file = ENV["SPECWRK_SRV_OUTPUT"] } }
+    PROCESSING_QUEUES = Queue.new { |h, key| h[key] = Queue.new }
+    COMPLETED_QUEUES = Queue.new { |h, key| h[key] = CompletedQueue.new }
+
+    def self.clear_queues
+      [PENDING_QUEUES, PROCESSING_QUEUES, COMPLETED_QUEUES].each(&:clear)
+    end
+  end
+end

data/lib/specwrk/worker/completion_formatter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Specwrk
+  class Worker
+    class CompletionFormatter
+      RSpec::Core::Formatters.register self, :stop
+
+      attr_reader :examples
+
+      def initialize
+        @examples = []
+      end
+
+      def stop(group_notification)
+        group_notification.notifications.map do |notification|
+          examples << {
+            id: notification.example.id,
+            full_description: notification.example.full_description,
+            status: notification.example.metadata[:execution_result].status,
+            file_path: notification.example.metadata[:file_path],
+            line_number: notification.example.metadata[:line_number],
+            started_at: notification.example.metadata[:execution_result].started_at.iso8601(6),
+            finished_at: notification.example.metadata[:execution_result].finished_at.iso8601(6),
+            run_time: notification.example.metadata[:execution_result].run_time
+          }
+        end
+      end
+    end
+  end
+end

data/lib/specwrk/worker/executor.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "tempfile"
+
+require "rspec"
+
+require "specwrk/worker/progress_formatter"
+require "specwrk/worker/completion_formatter"
+require "specwrk/worker/null_formatter"
+
+module Specwrk
+  class Worker
+    class Executor
+      def examples
+        completion_formatter.examples
+      end
+
+      def final_output
+        progress_formatter.final_output
+      end
+
+      def run(examples)
+        reset!
+
+        example_ids = examples.map { |example| example[:id] }
+
+        options = RSpec::Core::ConfigurationOptions.new rspec_options + example_ids
+        RSpec::Core::Runner.new(options).run($stderr, $stdout)
+      end
+
+      # https://github.com/skroutz/rspecq/blob/341383ce3ca25f42fad5483cbb6a00ba1c405570/lib/rspecq/worker.rb#L208-L224
+      def reset!
+        completion_formatter.examples.clear
+
+        RSpec.clear_examples
+
+        # see https://github.com/rspec/rspec-core/pull/2723
+        if Gem::Version.new(RSpec::Core::Version::STRING) <= Gem::Version.new("3.9.1")
+          RSpec.world.instance_variable_set(
+            :@example_group_counts_by_spec_file, Hash.new(0)
+          )
+        end
+
+        # RSpec.clear_examples does not reset those, which causes issues when
+        # a non-example error occurs (subsequent jobs are not executed)
+        RSpec.world.non_example_failure = false
+
+        # we don't want an error that occured outside of the examples (which
+        # would set this to `true`) to stop the worker
+        RSpec.world.wants_to_quit = Specwrk.force_quit
+
+        RSpec.configuration.silence_filter_announcements = true
+
+        RSpec.configuration.add_formatter progress_formatter
+        RSpec.configuration.add_formatter completion_formatter
+
+        # This formatter may be specified by the runner options so
+        # it will be initialized by RSpec
+        RSpec.configuration.add_formatter NullFormatter
+
+        true
+      end
+
+      # We want to persist this object between example runs
+      def progress_formatter
+        @progress_formatter ||= ProgressFormatter.new($stdout)
+      end
+
+      def completion_formatter
+        @completion_formatter ||= CompletionFormatter.new
+      end
+
+      def rspec_options
+        @rspec_options ||= if ENV["SPECWRK_OUT"]
+          ["--format", "json", "--out", File.join(ENV["SPECWRK_OUT"], "#{ENV.fetch("SPECWRK_ID", "specwrk-worker")}.json")]
+        else
+          ["--format", "Specwrk::Worker::NullFormatter"]
+        end
+      end
+    end
+  end
+end

data/lib/specwrk/worker/null_formatter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Specwrk
+  class Worker
+    class NullFormatter
+      RSpec::Core::Formatters.register self, :example_passed
+
+      attr_reader :output
+
+      def initialize(output)
+        @output = output
+      end
+
+      def example_passed(_notification)
+      end
+    end
+  end
+end

data/lib/specwrk/worker/progress_formatter.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "tempfile"
+
+RSpec::Support.require_rspec_core "formatters/base_text_formatter"
+RSpec::Support.require_rspec_core "formatters/console_codes"
+
+module Specwrk
+  class Worker
+    class ProgressFormatter
+      RSpec::Core::Formatters.register self, :example_passed, :example_pending, :example_failed, :dump_failures, :dump_pending
+      attr_reader :output, :final_output
+
+      def initialize(output)
+        @output = output
+
+        @final_output = Tempfile.new
+        @final_output.define_singleton_method(:tty?) { true }
+        @final_output.sync = true
+      end
+
+      def example_passed(_notification)
+        output.print RSpec::Core::Formatters::ConsoleCodes.wrap(".", :success)
+      end
+
+      def example_pending(_notification)
+        output.print RSpec::Core::Formatters::ConsoleCodes.wrap("*", :pending)
+      end
+
+      def example_failed(_notification)
+        output.print RSpec::Core::Formatters::ConsoleCodes.wrap("F", :failure)
+      end
+
+      def dump_failures(notification)
+        return if notification.failure_notifications.empty?
+        final_output.puts notification.fully_formatted_failed_examples
+      end
+
+      def dump_pending(notification)
+        return if notification.pending_examples.empty?
+        final_output.puts notification.fully_formatted_pending_examples
+      end
+    end
+  end
+end