flatware 1.2.0 → 2.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9da02a0ce1009b7c0fc4c03cd33af10e5e2984b706ef46aca34dd8f33c593267
-  data.tar.gz: 94563ca34708d9d7563f36291eb781ab6f48654a09a0fe7d7912d04aae008a5b
+  metadata.gz: 944469a1460443f84117dcdacbe79ec133c7605e83cc2b2882faaf573661a458
+  data.tar.gz: cc120e2ad04cf8baabf001921f16a03c67f15dd81884a6df83d097c06af420ae
 SHA512:
-  metadata.gz: 9ac813bab61e13d630fde64a875e57eb973fd74c6a59d48772ab1ec2d5a688a99899b70e4874c9fcdd71348f88a4b668a97955fdea156c667968fe2ca63523fe
-  data.tar.gz: d7af5aa56a6ffd45043834440c144f8baebc7c7b59a6fc1d80e93dddc959d20f3db3b6cb66cd183e3f055898abbcd09ec9864266ed91f8df361efae15f70671e
+  metadata.gz: 80d9ae698fd2f8c9c01c78e09d65fa36a1989b6bbdbee62cac5b74c5d69003734025cec6862f89415ca1e79ced1fbce97a17d37b31238f617b5d4fc5e160e74f
+  data.tar.gz: 35a22fe1de1df1a761ef16114729d10e51ddd797c3a7590293d49465f9ab9e86a77e22572d89abb4b603e56093da0d2ec8b1dccccd4c7cbc666339aa693d987d

data/README.md

@@ -7,39 +7,6 @@
 
 Flatware parallelizes your test suite to significantly reduce test time.
 
-## Requirements
-
-* ZeroMQ > 4.0
-
-## Installation
-
-### ZeroMQ
-
-#### Linux Ubuntu
-
-```sh
-sudo apt-get install -qq libzmq3-dev
-```
-
-(Never you mind the 3. This package contains ZMQ version 4.)
-
-#### Mac OSX
-
-
-If you're on macOS 10.12, use the custom hashrocket ZMQ homebrew formula.
-
-```sh
-brew tap hashrocket/formulas
-brew install hashrocket/formulas/zeromq
-```
-
-The stock homebrew version will likely work on older versions of macOS.
-
-
-```sh
-brew install zeromq
-```
-
 ### Flatware
 
 Add the runners you need to your Gemfile:
@@ -81,8 +48,9 @@ For this to work the configuration option must be loaded before any specs are ru
 
     --require spec_helper
 
-But beware, if you're using ActiveRecord in your suite you'll need to avoid doing things that cause it to establish a database connection in `spec_helper.rb`. If ActiveRecord connects before flatware forks off workers, each will die messily. All of this will just work if you're following [the recomended pattern of splitting your helpers into `spec_helper` and `rails_helper`](https://github.com/rspec/rspec-rails/blob/v3.8.2/lib/generators/rspec/install/templates/spec/rails_helper.rb).
-
+But beware, if you're using ActiveRecord in your suite you'll need to avoid doing things that cause it to establish a database connection in `spec_helper.rb`. If ActiveRecord connects before flatware forks off workers, each will die messily. All of this will just work if you're following [the recomended pattern of splitting your helpers into `spec_helper` and `rails_helper`](https://github.com/rspec/rspec-rails/blob/v3.8.2/lib/generators/rspec/install/templates/spec/rails_helper.rb). Another option is to use [the configurable hooks](
+#faster-startup-with-activerecord
+).
 
 ### Options
 
@@ -134,9 +102,31 @@ Now you are ready to rock:
 $ flatware rspec && flatware cucumber
 ```
 
-## Planned Features
+### Faster Startup With ActiveRecord
+
+Flatware has a couple lifecycle callbacks that you can use to avoid booting your app
+over again on every core. One way to take advantage of this via a `spec/flatware_helper.rb` file like so:
 
-* Use heuristics to run your slowest tests first
+```ruby
+Flatware.configure do |conf|
+  conf.before_fork do
+    require 'rails_helper'
+
+    ActiveRecord::Base.connection.disconnect!
+  end
+
+  conf.after_fork do |test_env_number|
+    config = ActiveRecord::Base.connection_config
+
+    ActiveRecord::Base.establish_connection(
+      config.merge(
+        database: config.fetch(:database) + test_env_number.to_s
+      )
+    )
+  end
+end
+```
+Now when I run `bundle exec flatware rspec -r ./spec/flatware_helper` My app only boots once, rather than once per core.
 
 ## Design Goals
 
@@ -167,20 +157,10 @@ directory. CD there and `flatware` will be in your path so you can tinker away.
 
 ## How it works
 
-Flatware relies on a message passing system to enable concurrency.
-The main process declares a worker for each cpu in the computer. Each
-worker forks from the main process and is then assigned a portion of the
-test suite.  As the worker runs the test suite it sends progress
-messages to the main process.  These messages are collected and when
-the last worker is finished the main process provides a report on the
-collected progress messages.
+Flatware relies on a message passing system to enable concurrency. The main process forks a worker for each cpu in the computer. These workers are each given a chunk of the tests to run. The workers report back to the main process about their progress. The main process prints those progress messages. When the last worker is finished the main process prints the results.
 
 ## Resources
 
-To learn more about the messaging system that Flatware uses, take a look at the
-[excellent ZeroMQ guide][z].
-
-[z]: http://zguide.zeromq.org/page:all
 [a]: https://github.com/cucumber/aruba
 
 ## Contributing to Flatware

data/bin/flatware

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
-lib = File.expand_path('../../lib', __FILE__)
-$:.unshift lib unless $:.include? lib
+lib = File.expand_path('../lib', __dir__)
+$LOAD_PATH.unshift lib unless $LOAD_PATH.include? lib
 
 require 'flatware'
 Flatware::CLI.start

data/lib/flatware.rb

@@ -1,10 +1,39 @@
+# frozen_string_literal: true
+
+require 'logger'
+
 module Flatware
-  require 'flatware/processor_info'
   require 'flatware/job'
   require 'flatware/cli'
-  require 'flatware/poller'
   require 'flatware/sink'
-  require 'flatware/socket'
   require 'flatware/worker'
   require 'flatware/broadcaster'
+
+  module_function
+
+  def logger
+    @logger ||= Logger.new($stderr, level: :fatal)
+  end
+
+  def logger=(logger)
+    @logger = logger
+  end
+
+  def log(*message)
+    case message.first
+    when Exception
+      logger.error message.first
+    else
+      logger.info(([$PROGRAM_NAME] + message).join(' '))
+    end
+    message
+  end
+
+  def verbose=(bool)
+    logger.level = bool ? :debug : :fatal
+  end
+
+  def verbose?
+    logger.level < Logger::SEV_LABEL.index('FATAL')
+  end
 end

data/lib/flatware/broadcaster.rb

@@ -1,5 +1,17 @@
+# frozen_string_literal: true
+
 module Flatware
+  # sends messages to all formatters
   class Broadcaster
+    FORMATTER_MESSAGES = %i[
+      jobs
+      started
+      progress
+      finished
+      summarize
+      summarize_remaining
+    ].freeze
+
     attr_reader :formatters
 
     def initialize(formatters)
@@ -7,9 +19,14 @@ module Flatware
     end
 
     def method_missing(name, *args)
-      formatters.each do |formatter|
-        formatter.send name, *args if formatter.respond_to? name
-      end
+      return super unless FORMATTER_MESSAGES.include? name
+
+      formatters.select { |formatter| formatter.respond_to? name }
+                .each { |formatter| formatter.send name, *args }
+    end
+
+    def respond_to_missing?(name, _include_all)
+      FORMATTER_MESSAGES.include? name
     end
   end
 end

data/lib/flatware/cli.rb

@@ -1,18 +1,32 @@
 # frozen_string_literal: true
 
 require 'thor'
-require 'flatware/pids'
+require 'flatware/pid'
+require 'etc'
+
 module Flatware
+  # shared flatware cli
   class CLI < Thor
     def self.processors
-      @processors ||= ProcessorInfo.count
+      @processors ||= Etc.nprocessors
     end
 
     def self.worker_option
-      method_option :workers, aliases: '-w', type: :numeric, default: processors, desc: 'Number of concurent processes to run'
+      method_option(
+        :workers,
+        aliases: '-w',
+        type: :numeric,
+        default: processors,
+        desc: 'Number of concurent processes to run'
+      )
     end
 
-    class_option :log, aliases: '-l', type: :boolean, desc: 'Print debug messages to $stderr'
+    class_option(
+      :log,
+      aliases: '-l',
+      type: :boolean,
+      desc: 'Print debug messages to $stderr'
+    )
 
     worker_option
     desc 'fan [COMMAND]', 'executes the given job on all of the workers'
@@ -32,7 +46,7 @@ module Flatware
 
     desc 'clear', 'kills all flatware processes'
     def clear
-      (Flatware.pids - [$PROCESS_ID]).each do |pid|
+      (Flatware.pids - [Process.pid]).each do |pid|
         Process.kill 6, pid
       end
     end
@@ -42,14 +56,15 @@ module Flatware
     def start_sink(jobs:, workers:, formatter:)
       $0 = 'flatware sink'
       Process.setpgrp
-      passed = Sink.start_server jobs: jobs, formatter: Flatware::Broadcaster.new([formatter]), sink: options['sink-endpoint'], dispatch: options['dispatch-endpoint'], worker_count: workers
+      passed = Sink.start_server(
+        jobs: jobs,
+        formatter: Flatware::Broadcaster.new([formatter]),
+        sink: options['sink-endpoint'],
+        worker_count: workers
+      )
       exit passed ? 0 : 1
     end
 
-    def log(*args)
-      Flatware.log(*args)
-    end
-
     def workers
       options[:workers]
     end
@@ -59,11 +74,9 @@ end
 flatware_gems = %w[flatware-rspec flatware-cucumber]
 
 loaded_flatware_gem_count = flatware_gems.map do |flatware_gem|
-  begin
-    require flatware_gem
-  rescue LoadError
-    nil
-  end
+  require flatware_gem
+rescue LoadError
+  nil
 end.compact.size
 
 if loaded_flatware_gem_count.zero?
@@ -72,5 +85,4 @@ if loaded_flatware_gem_count.zero?
       The flatware gem is a dependency of flatware runners for rspec and cucumber.
       Install %<gem_list>s for more usefull commands.
     MESSAGE
-
 end

data/lib/flatware/configuration.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Flatware
+  class Configuration
+    def initialize
+      reset!
+    end
+
+    def before_fork(&block)
+      if block_given?
+        @before_fork = block
+      else
+        @before_fork
+      end
+    end
+
+    def after_fork(&block)
+      if block_given?
+        @after_fork = block
+      else
+        @after_fork
+      end
+    end
+
+    def reset!
+      @before_fork = -> {}
+      @after_fork = ->(_) {}
+    end
+  end
+
+  module_function
+
+  def configuration
+    @configuration ||= Configuration.new
+  end
+
+  def configure(&_block)
+    yield configuration
+  end
+end

data/lib/flatware/job.rb

@@ -4,7 +4,19 @@ module Flatware
     attr_writer :failed
 
     def failed?
-      !!@failed
+      @failed == true
+    end
+
+    def failed!
+      @failed = true
+    end
+
+    def sentinel?
+      id == 'seppuku'
+    end
+
+    def self.sentinel
+      new 'seppuku'
     end
   end
 end

data/lib/flatware/pid.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'etc'
+
+module Flatware
+  module_function
+
+  # All the pids of all the processes called flatware on this machine
+  def pids
+    Pid.pids { |pid| pid.command =~ /flatware/ }
+  end
+
+  def pids_of_group(group_pid)
+    Pid.pids { |pid| pid.pgid == group_pid }
+  end
+
+  Pid = Struct.new(:pid, :pgid, :ppid, :command) do
+    def self.pids(&block)
+      ps.select(&block).map(&:pid)
+    end
+
+    def self.ps
+      args = ['-o', members.join(',')]
+      args += { 'Darwin' => %w[-c] }.fetch(Etc.uname.fetch(:sysname), [])
+
+      IO
+        .popen(['ps', *args])
+        .readlines
+        .map do |row|
+        fields = row.strip.split(/\s+/, 4)
+        new(*fields.take(3).map(&:to_i), fields.last)
+      end
+    end
+
+    def pids_of_group(group_pid)
+      ps
+        .select { |pid| pid.pgid == group_pid }
+        .map(&:pid)
+    end
+  end
+end

data/lib/flatware/serialized_exception.rb

@@ -2,15 +2,25 @@ module Flatware
   class SerializedException
     attr_reader :class, :message, :cause
     attr_accessor :backtrace
-    def initialize(klass, message, backtrace, cause='')
-      @class, @message, @backtrace, @cause = serialized(klass), message, backtrace, cause
+
+    def initialize(klass, message, backtrace, cause = '')
+      @class = serialized(klass)
+      @message = message
+      @backtrace = backtrace
+      @cause = cause
     end
 
     def self.from(exception)
-      new exception.class, exception.message, exception.backtrace, exception.cause
+      new(
+        exception.class,
+        exception.message,
+        exception.backtrace,
+        exception.cause
+      )
     end
 
     private
+
     def serialized(klass)
       SerializedClass.new(klass.to_s)
     end
@@ -19,6 +29,8 @@ module Flatware
   class SerializedClass
     attr_reader :name
     alias to_s name
-    def initialize(name); @name = name end
+    def initialize(name)
+      @name = name
+    end
   end
 end

data/lib/flatware/sink.rb

@@ -1,104 +1,136 @@
-require 'flatware'
+require 'drb/drb'
+
 module Flatware
   module Sink
-    extend self
+    module_function
+
+    def start_server(**args)
+      Server.new(**args).start
+    end
 
-    def start_server(*args)
-      Server.new(*args).start
+    def client
+      @client
+    end
+
+    def client=(client)
+      @client = client
     end
 
     class Server
-      attr_reader :sink, :dispatch, :poller, :workers, :checkpoints, :jobs, :formatter
+      attr_reader :checkpoints, :completed_jobs, :formatter, :jobs, :queue, :sink, :workers
 
-      def initialize(jobs:, formatter:, dispatch:, sink:, worker_count: 0)
+      def initialize(jobs:, formatter:, sink:, worker_count: 0, **)
+        @checkpoints = []
+        @completed_jobs = []
         @formatter = formatter
-        @jobs = group_jobs(jobs, worker_count)
-        @sink = Flatware.socket(ZMQ::PULL, bind: sink)
-        @dispatch = Flatware.socket(ZMQ::REP, bind: dispatch)
-        @poller = Poller.new(@sink, @dispatch)
+        @jobs = group_jobs(jobs, worker_count).freeze
+        @queue = @jobs.dup
+        @sink = sink
         @workers = Set.new(worker_count.times.to_a)
-        @checkpoints = []
       end
 
       def start
-        trap 'INT' do
-          puts "Interrupted!"
-          formatter.summarize checkpoints
-          summarize_remaining
-          puts "\n\nCleaning up. Please wait...\n"
-          Flatware.close!
-          Process.waitall
-          puts "thanks."
-          exit 1
-        end
+        trap_interrupt
         formatter.jobs jobs
-        listen.tap do
-          Flatware.close
-        end
+        DRb.start_service(sink, self, verbose: Flatware.verbose?)
+        DRb.thread.join
+        !failures?
       end
 
-      def listen
-        que = jobs.dup
-        poller.each do |socket|
-          message, content = socket.recv
-
-          case message
-          when :ready
-            workers << content
-            job = que.shift
-            if job and not done?
-              dispatch.send job
-            else
-              workers.delete content
-              dispatch.send 'seppuku'
-            end
-          when :checkpoint
-            checkpoints << content
-          when :finished
-            completed_jobs << content
-            formatter.finished content
-          else
-            formatter.send message, content
-          end
-          break if workers.empty? and done?
+      def ready(worker)
+        job = queue.shift
+        if job && !(remaining_work.empty? || interruped?)
+          workers << worker
+          job
+        else
+          workers.delete worker
+          check_finished!
+          Job.sentinel
         end
-        formatter.summarize(checkpoints)
-        !failures?
+      end
+
+      def checkpoint(checkpoint)
+        checkpoints << checkpoint
+      end
+
+      def finished(job)
+        completed_jobs << job
+        formatter.finished(job)
+        check_finished!
+      end
+
+      def method_missing(name, *args)
+        super unless formatter.respond_to?(name)
+        Flatware.log(name, *args)
+        formatter.send(name, *args)
+      end
+
+      def respond_to_missing?(name, include_all)
+        formatter.respond_to?(name, include_all)
       end
 
       private
 
-      def failures?
-        checkpoints.any?(&:failures?) || completed_jobs.any?(&:failed?)
+      def trap_interrupt
+        Thread.main[:signals] = Queue.new
+
+        Thread.new(&method(:handle_interrupt))
+
+        trap 'INT' do
+          Thread.main[:signals] << :int
+        end
       end
 
-      def summarize_remaining
-        return if remaining_work.empty?
-        formatter.summarize_remaining remaining_work
+      def handle_interrupt
+        Thread.main[:signals].pop
+        puts 'Interrupted!'
+        summarize_remaining
+        puts "\n\nCleaning up. Please wait...\n"
+        Process.waitall
+        puts 'done.'
+        abort
       end
 
-      def log(*args)
-        Flatware.log *args
+      def interruped?
+        signals = Thread.main[:signals]
+        signals && !signals.empty?
       end
 
-      def completed_jobs
-        @completed_jobs ||= []
+      def check_finished!
+        return unless [workers, remaining_work].all?(&:empty?)
+
+        DRb.stop_service
+        summarize
       end
 
-      def done?
-        remaining_work.empty?
+      def failures?
+        checkpoints.any?(&:failures?) || completed_jobs.any?(&:failed?)
+      end
+
+      def summarize_remaining
+        summarize
+        return if remaining_work.empty?
+
+        formatter.summarize_remaining remaining_work
       end
 
       def remaining_work
         jobs - completed_jobs
       end
 
+      def summarize
+        formatter.summarize(checkpoints)
+      end
+
       def group_jobs(jobs, worker_count)
         return jobs unless worker_count > 1
-        jobs.group_by.with_index do |_,i|
-          i % worker_count
-        end.values.map do |jobs|
-          Job.new(jobs.map(&:id).flatten, jobs.first.args)
+
+        jobs
+          .group_by
+          .with_index { |_, i| i % worker_count }
+          .values
+          .map do |job_group|
+          Job.new(job_group.map(&:id).flatten, jobs.first.args)
         end
       end
     end

data/lib/flatware/sink/client.rb

@@ -1,15 +1,17 @@
-require 'flatware/socket'
+require 'drb/drb'
+
 module Flatware
   module Sink
-    extend self
+    module_function
+
     attr_accessor :client
 
     class Client
       def initialize(sink_endpoint)
-        @socket = Flatware.socket ZMQ::PUSH, connect: sink_endpoint
+        @sink = DRbObject.new_with_uri sink_endpoint
       end
 
-      %w[finished started progress checkpoint].each do |message|
+      %w[ready finished started progress checkpoint].each do |message|
         define_method message do |content|
           push [message.to_sym, content]
         end
@@ -18,7 +20,7 @@ module Flatware
       private
 
       def push(message)
-        @socket.send message
+        @sink.public_send message
       end
     end
   end

data/lib/flatware/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Flatware
-  VERSION = '1.2.0'
+  VERSION = '2.0.0.rc1'
 end

data/lib/flatware/worker.rb

@@ -1,57 +1,76 @@
-require 'flatware/sink/client'
+# frozen_string_literal: true
+
+require 'drb/drb'
+
 module Flatware
+  require 'flatware/configuration'
+  # executes tests and sends results to the sink
   class Worker
-    attr_reader :id
+    attr_reader :sink, :runner, :id
 
-    def initialize(id, runner, dispatch_endpoint, sink_endpoint)
+    def initialize(id, runner, sink_endpoint)
       @id       = id
       @runner   = runner
-      @sink     = Sink::Client.new sink_endpoint
-      @task     = Flatware.socket ZMQ::REQ, connect: dispatch_endpoint
+      @sink     = DRbObject.new_with_uri sink_endpoint
+      Flatware::Sink.client = @sink
     end
 
-    def self.spawn(count:, runner:, dispatch:, sink:)
+    def self.spawn(count:, runner:, sink:, **)
+      Flatware.configuration.before_fork.call
       count.times do |i|
         fork do
           $0 = "flatware worker #{i}"
           ENV['TEST_ENV_NUMBER'] = i.to_s
-          new(i, runner, dispatch, sink).listen
+          Flatware.configuration.after_fork.call(i)
+          new(i, runner, sink).listen
         end
       end
     end
 
     def listen
-      trap 'INT' do
-        Flatware.close!
-        @want_to_quit = true
-        exit(1)
-      end
-
-      Sink.client = sink
-      report_for_duty
-      loop do
-        job = task.recv
-        break if job == 'seppuku' or @want_to_quit
-        job.worker = id
-        sink.started job
-        begin
-          runner.run job.id, job.args
-        rescue => e
-          Flatware.log e
-          job.failed = true
+      retrying(times: 10, wait: 0.1) do
+        job = sink.ready id
+        until want_to_quit? || job.sentinel?
+          job.worker = id
+          sink.started job
+          run job
+          job = sink.ready id
         end
-        sink.finished job
-        report_for_duty
       end
-      Flatware.close unless @want_to_quit
     end
 
     private
 
-    attr_reader :task, :sink, :runner
+    def run(job)
+      runner.run job.id, job.args
+      sink.finished job
+    rescue Interrupt
+      want_to_quit!
+    rescue StandardError => e
+      Flatware.log e
+      job.failed!
+      sink.finished job
+    end
 
-    def report_for_duty
-      task.send [:ready, id]
+    def want_to_quit!
+      @want_to_quit = true
+    end
+
+    def want_to_quit?
+      @want_to_quit == true
+    end
+
+    def retrying(times:, wait:)
+      tries = 0
+      begin
+        yield unless want_to_quit?
+      rescue DRb::DRbConnError => e
+        raise if (tries += 1) >= times
+
+        sleep wait
+        Flatware.log('retrying', e.message)
+        retry
+      end
     end
   end
 end

metadata

@@ -1,71 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: flatware
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 2.0.0.rc1
 platform: ruby
 authors:
 - Brian Dunn
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-08-23 00:00:00.000000000 Z
+date: 2021-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: ffi-rzmq
+  name: thor
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: thor
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.13'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.13'
-- !ruby/object:Gem::Dependency
-  name: aruba
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.14'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.14'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 10.1.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 10.1.0
 description: A distributed rspec and cucumber runner
 email: brian@hashrocket.com
 executables:
@@ -81,37 +39,38 @@ files:
 - lib/flatware.rb
 - lib/flatware/broadcaster.rb
 - lib/flatware/cli.rb
+- lib/flatware/configuration.rb
 - lib/flatware/job.rb
-- lib/flatware/pids.rb
-- lib/flatware/poller.rb
-- lib/flatware/processor_info.rb
+- lib/flatware/pid.rb
 - lib/flatware/serialized_exception.rb
 - lib/flatware/sink.rb
 - lib/flatware/sink/client.rb
-- lib/flatware/socket.rb
 - lib/flatware/version.rb
 - lib/flatware/worker.rb
 homepage: http://github.com/briandunn/flatware
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+  - - "<"
     - !ruby/object:Gem::Version
-      version: '2.1'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: A distributed rspec and cucumber runner
 test_files: []

data/lib/flatware/pids.rb

@@ -1,25 +0,0 @@
-require 'flatware/processor_info'
-module Flatware
-  extend self
-  # All the pids of all the processes called flatware on this machine
-  def pids
-    pids_command.map do |row|
-      row =~ /(\d+).*flatware/ and $1.to_i
-    end.compact
-  end
-
-  def pids_command
-    case ProcessorInfo.operating_system
-    when 'Darwin'
-      `ps -c -opid,pgid,command`
-    when 'Linux'
-      `ps -opid,pgid,command`
-    end.split("\n")[1..-1]
-  end
-
-  def pids_of_group(group_pid)
-    pids_command.map(&:split).map do |pid, pgid, _|
-      pid.to_i if pgid.to_i == group_pid
-    end.compact
-  end
-end

data/lib/flatware/poller.rb

@@ -1,35 +0,0 @@
-module Flatware
-  class Poller
-    attr_reader :sockets, :zmq_poller
-    def initialize(*sockets)
-      @sockets    = sockets
-      @zmq_poller = ZMQ::Poller.new
-      register_sockets
-    end
-
-    def each(&block)
-      while (result = zmq_poller.poll) != 0
-        raise Error, ZMQ::Util.error_string, caller if result == -1
-        for socket in zmq_poller.readables.map &find_wrapped_socket
-          yield socket
-        end
-      end
-    end
-
-    private
-
-    def find_wrapped_socket
-      ->(s) do
-        sockets.find do |socket|
-          socket.socket == s
-        end
-      end
-    end
-
-    def register_sockets
-      sockets.each do |socket|
-        zmq_poller.register_readable socket.socket
-      end
-    end
-  end
-end

data/lib/flatware/processor_info.rb

@@ -1,24 +0,0 @@
-module Flatware
-  class ProcessorInfo
-    def count
-      case operating_system
-      when 'Darwin'
-        `hostinfo`.match(/^(?<processors>\d+) processors are logically available\.$/)[:processors].to_i
-      when 'Linux'
-        `grep --count '^processor' /proc/cpuinfo`.to_i
-      end
-    end
-
-    def operating_system
-      `uname`.chomp
-    end
-
-    def self.count
-      new.count
-    end
-
-    def self.operating_system
-      new.operating_system
-    end
-  end
-end

data/lib/flatware/socket.rb

@@ -1,176 +0,0 @@
-require 'ffi-rzmq'
-require 'securerandom'
-require 'logger'
-
-module Flatware
-  Error = Class.new StandardError
-
-  extend self
-
-  def logger
-    @logger ||= Logger.new($stderr)
-  end
-
-  def logger=(logger)
-    @logger = logger
-  end
-
-  def socket(*args)
-    context.socket(*args)
-  end
-
-  def close(force: false)
-    @ignore_errors = true if force
-    context.close(force: force)
-    @context = nil
-  end
-
-  def close!
-    close force: true
-  end
-
-  def socket_error(name=nil)
-    raise(Error, [$0,name,ZMQ::Util.error_string].compact.join(' - '), caller) unless @ignore_errors
-  end
-
-  def log(*message)
-    if Exception === message.first
-      logger.error message.first
-    elsif verbose?
-      logger.info ([$0] + message).join(' ')
-    end
-    message
-  end
-
-  attr_writer :verbose
-  def verbose?
-    !!@verbose
-  end
-
-  def context
-    @context ||= begin
-                   @ignore_errors = nil
-                   Context.new
-                 end
-  end
-
-  class Context
-    attr_reader :sockets, :c
-
-    def initialize
-      @c = ZMQ::Context.new
-      @sockets = []
-    end
-
-    def socket(zmq_type, options={})
-      Socket.new(c.socket(zmq_type)).tap do |socket|
-        sockets.push socket
-        if port = options[:connect]
-          socket.connect port
-        end
-        if port = options[:bind]
-          socket.bind port
-        end
-      end
-    end
-
-    def close(force: false)
-      sockets.each do |socket|
-        socket.setsockopt ZMQ::LINGER, 0
-      end if force
-      sockets.each(&:close)
-      Flatware::socket_error unless LibZMQ.zmq_term(c.context) == 0
-      Flatware.log "terminated context"
-    end
-  end
-
-  class Socket
-    attr_reader :socket
-
-    def initialize(socket)
-      @socket = socket
-    end
-
-    def setsockopt(*args)
-      socket.setsockopt(*args)
-    end
-
-    def name
-      socket.name
-    end
-
-    def send(message)
-      result = socket.send_string(Marshal.dump(message))
-      error if result == -1
-      Flatware.log "#@type #@port send #{message}"
-      message
-    end
-
-    def connect(port)
-      @type = 'connected'
-      @port = port
-      error unless socket.connect(port) == 0
-      Flatware.log "connect #@port"
-    end
-
-    def monitor
-      name = "inproc://monitor#{SecureRandom.hex(10)}"
-      LibZMQ.zmq_socket_monitor(socket.socket, name, ZMQ::EVENT_ALL)
-      Monitor.new(name)
-    end
-
-    class Monitor
-      def initialize(port)
-        @socket = Flatware.socket ZMQ::PAIR
-        @socket.connect port
-      end
-
-      def recv
-        bytes = @socket.recv marshal: false
-        data = LibZMQ::EventData.new FFI::MemoryPointer.from_string bytes
-        event[data.event]
-      end
-
-      private
-
-      def event
-        ZMQ.constants.select do |c|
-          c.to_s =~ /^EVENT/
-        end.map do |s|
-          {s => ZMQ.const_get(s)}
-        end.reduce(:merge).invert
-      end
-    end
-
-    def bind(port)
-      @type = 'bound'
-      @port = port
-      error unless socket.bind(port) == 0
-      Flatware.log "bind #@port"
-    end
-
-    def close
-      error unless socket.close == 0
-      Flatware.log "close #@type #@port"
-    end
-
-    def error
-      Flatware::socket_error name
-    end
-
-    def recv(block: true, marshal: true)
-      message = ''
-      if block
-       result = socket.recv_string(message)
-       error if result == -1
-      else
-        socket.recv_string(message, ZMQ::NOBLOCK)
-      end
-      if message != '' and marshal
-        message = Marshal.load(message)
-      end
-      Flatware.log "#@type #@port recv #{message}"
-      message
-    end
-  end
-end