nitra 0.9.3 → 0.9.4

data/bin/nitra

@@ -1,47 +1,11 @@
 #!/usr/bin/env ruby
 
 require 'nitra'
-require 'optparse'
 
-nitra = Nitra.new
-
-OptionParser.new do |opts|
-  opts.banner = "Usage: nitra [options] [spec_filename [...]]"
-
-  opts.on("-c", "--cpus NUMBER", Integer, "Specify the number of CPUs to use, defaults to 4") do |n|
-    nitra.process_count = n
-  end
-
-  opts.on("-e", "--environment STRING", String, "The Rails environment to use, defaults to 'nitra'") do |environment|
-    nitra.environment = environment
-  end
-
-  opts.on("--load", "Load schema into database before running specs") do
-    nitra.load_schema = true
-  end
-
-  opts.on("--migrate", "Migrate database before running specs") do
-    nitra.migrate = true
-  end
-
-  opts.on("-q", "--quiet", "Quiet; don't display progress bar") do
-    nitra.quiet = true
-  end
-
-  opts.on("-p", "--print-failures", "Print failures immediately when they occur") do
-    nitra.print_failures = true
-  end
-
-  opts.on("--debug", "Print debug output") do
-    nitra.debug = true
-  end
-
-  opts.on_tail("-h", "--help", "Show this message") do
-    puts opts
-    exit
-  end
-end.parse!
-
-nitra.files = ARGV
-
-exit nitra.run
+configuration = Nitra::Configuration.new
+Nitra::CommandLine.new(configuration, ARGV)
+if configuration.slave_mode
+  Nitra::Slave::Server.new.run
+else
+  exit Nitra::Client.new(configuration, ARGV).run ? 0 : 1
+end

data/lib/nitra/channel.rb

@@ -0,0 +1,48 @@
+require 'yaml'
+
+class Nitra::Channel
+  ProtocolInvalidError = Class.new(StandardError)
+
+  attr_reader :rd, :wr
+  attr_accessor :raise_epipe_on_write_error
+
+  def initialize(rd, wr)
+    @rd = rd
+    @wr = wr
+  end
+
+  def self.pipe
+    c_rd, s_wr = IO.pipe
+    s_rd, c_wr = IO.pipe
+    [new(c_rd, c_wr), new(s_rd, s_wr)]
+  end
+
+  def self.read_select(channels)
+    fds = IO.select(channels.collect(&:rd))
+    fds.first.collect do |fd|
+      channels.detect {|c| c.rd == fd}
+    end
+  end
+
+  def close
+    rd.close
+    wr.close
+  end
+
+  def read
+    return unless line = rd.gets
+    if result = line.strip.match(/\ANITRA,(\d+)\z/)
+      data = rd.read(result[1].to_i)
+      YAML.load(data)
+    else
+      raise ProtocolInvalidError, "Expected nitra length line, got #{line.inspect}"
+    end
+  end
+
+  def write(data)
+    encoded = YAML.dump(data)
+    wr.write("NITRA,#{encoded.length}\n#{encoded}")
+  rescue Errno::EPIPE
+    raise if raise_epipe_on_write_error
+  end
+end

data/lib/nitra/client.rb

@@ -0,0 +1,43 @@
+class Nitra::Client
+  attr_reader :configuration, :files
+
+  def initialize(configuration, files = nil)
+    @configuration = configuration
+    @files = files
+    @columns = (ENV['COLUMNS'] || 120).to_i
+  end
+
+  def run
+    start_time = Time.now
+
+    master = Nitra::Master.new(configuration, files)
+    progress = master.run do |progress, data|
+      print_progress(progress)
+      if data && configuration.print_failures && data["failure_count"] != 0
+        puts unless configuration.quiet
+        puts "=== output for #{data["filename"]} #{'='*40}"
+        puts data["text"].gsub(/\n\n\n+/, "\n\n")
+      end
+    end
+
+    puts progress.output.gsub(/\n\n\n+/, "\n\n")
+
+    puts "\n#{progress.files_completed}/#{progress.file_count} files processed, #{progress.example_count} examples, #{progress.failure_count} failures"
+    puts "#{$aborted ? "Aborted after" : "Finished in"} #{"%0.1f" % (Time.now-start_time)} seconds" unless configuration.quiet
+
+    !$aborted && progress.files_completed == progress.file_count && progress.failure_count.zero?
+  end
+
+  protected
+  def print_progress(progress)
+    return if configuration.quiet
+
+    bar_length = @columns - 50
+    progress_factor = progress.files_completed / progress.file_count.to_f
+    length_completed = (progress_factor * bar_length).to_i
+    length_to_go = bar_length - length_completed
+    print "\r[#{"X" * length_completed}#{"." * length_to_go}] #{progress.files_completed}/#{progress.file_count} (#{"%0.1f%%" % (progress_factor*100)}) * #{progress.example_count} examples, #{progress.failure_count} failures\r"
+    puts if configuration.debug
+    $stdout.flush
+  end
+end

data/lib/nitra/command_line.rb

@@ -0,0 +1,54 @@
+require 'optparse'
+
+class Nitra::CommandLine
+  attr_reader :configuration
+
+  def initialize(configuration, argv)
+    @configuration = configuration
+
+    OptionParser.new(argv) do |opts|
+      opts.banner = "Usage: nitra [options] [spec_filename [...]]"
+
+      opts.on("-c", "--cpus NUMBER", Integer, "Specify the number of CPUs to use on the host, or if specified after a --slave, on the slave") do |n|
+        configuration.set_process_count n
+      end
+
+      opts.on("-e", "--environment STRING", String, "The Rails environment to use, defaults to 'nitra'") do |environment|
+        configuration.environment = environment
+      end
+
+      opts.on("--load", "Load schema into database before running specs") do
+        configuration.load_schema = true
+      end
+
+      opts.on("--migrate", "Migrate database before running specs") do
+        configuration.migrate = true
+      end
+
+      opts.on("-q", "--quiet", "Quiet; don't display progress bar") do
+        configuration.quiet = true
+      end
+
+      opts.on("-p", "--print-failures", "Print failures immediately when they occur") do
+        configuration.print_failures = true
+      end
+
+      opts.on("--slave CONNECTION_COMMAND", String, "Provide a command that executes \"nitra --slave-mode\" on another host") do |connection_command|
+        configuration.slaves << {:command => connection_command, :cpus => nil}
+      end
+
+      opts.on("--slave-mode", "Run in slave mode; ignores all other command-line options") do
+        configuration.slave_mode = true
+      end
+
+      opts.on("--debug", "Print debug output") do
+        configuration.debug = true
+      end
+
+      opts.on_tail("-h", "--help", "Show this message") do
+        puts opts
+        exit
+      end
+    end.parse!
+  end
+end

data/lib/nitra/configuration.rb

@@ -0,0 +1,22 @@
+class Nitra::Configuration
+  attr_accessor :load_schema, :migrate, :debug, :quiet, :print_failures, :fork_for_each_file
+  attr_accessor :process_count, :environment, :slaves, :slave_mode
+
+  def initialize
+    self.environment = "nitra"
+    self.fork_for_each_file = true
+    self.slaves = []
+  end
+
+  def calculate_default_process_count
+    self.process_count ||= Nitra::Utils.processor_count
+  end
+
+  def set_process_count(n)
+    if slaves.empty?
+      self.process_count = n
+    else
+      slaves.last[:cpus] = n
+    end
+  end
+end

data/lib/nitra/master.rb

@@ -0,0 +1,68 @@
+class Nitra::Master
+  attr_reader :configuration, :files
+
+  def initialize(configuration, files = nil)
+    @configuration = configuration
+    @files = files
+  end
+
+  def run
+    @files = Dir["spec/**/*_spec.rb"] if files.nil? || files.empty?
+    return if files.empty?
+
+    progress = Nitra::Progress.new
+    progress.file_count = @files.length
+    yield progress, nil
+
+    runners = []
+
+    if configuration.process_count > 0
+      client, runner = Nitra::Channel.pipe
+      fork do
+        runner.close
+        Nitra::Runner.new(configuration, client, "A").run
+      end
+      client.close
+      runners << runner
+    end
+
+    slave = Nitra::Slave::Client.new(configuration)
+    runners += slave.connect("")
+
+    while runners.length > 0
+      Nitra::Channel.read_select(runners).each do |channel|
+        if data = channel.read
+          case data["command"]
+          when "next"
+            channel.write "filename" => files.shift
+          when "result"
+            progress.files_completed += 1
+            progress.example_count += data["example_count"] || 0
+            progress.failure_count += data["failure_count"] || 0
+            progress.output << data["text"]
+            yield progress, data
+          when "debug"
+            if configuration.debug
+              puts "[DEBUG] #{data["text"]}"
+            end
+          when "stdout"
+            if configuration.debug
+              puts "STDOUT for #{data["process"]} #{data["filename"]}:\n#{data["text"]}" unless data["text"].empty?
+            end
+          end
+        else
+          runners.delete channel
+        end
+      end
+    end
+
+    debug "waiting for all children to exit..."
+    Process.waitall
+    progress
+  end
+
+  protected
+  def debug(*text)
+    puts "master: #{text.join}" if configuration.debug
+  end
+end

data/lib/nitra/progress.rb

@@ -0,0 +1,8 @@
+class Nitra::Progress
+  attr_accessor :file_count, :files_completed, :example_count, :failure_count, :output
+
+  def initialize
+    @file_count = @files_completed = @example_count = @failure_count = 0
+    @output = ""
+  end
+end

data/lib/nitra/runner.rb

@@ -0,0 +1,127 @@
+require 'stringio'
+
+class Nitra::Runner
+  attr_reader :configuration, :server_channel, :runner_id
+
+  def initialize(configuration, server_channel, runner_id)
+    @configuration = configuration
+    @server_channel = server_channel
+    @runner_id = runner_id
+
+    configuration.calculate_default_process_count
+    server_channel.raise_epipe_on_write_error = true
+  end
+
+  def run
+    ENV["RAILS_ENV"] = configuration.environment
+
+    initialise_database
+
+    load_rails_environment
+
+    pipes = start_workers
+
+    trap("SIGTERM") { $aborted = true }
+    trap("SIGINT") { $aborted = true }
+
+    hand_out_files_to_workers(pipes)
+  rescue Errno::EPIPE
+  ensure
+    trap("SIGTERM", "DEFAULT")
+    trap("SIGINT", "DEFAULT")
+  end
+
+  protected
+  def initialise_database
+    if configuration.load_schema
+      configuration.process_count.times do |index|
+        debug "initialising database #{index+1}..."
+        ENV["TEST_ENV_NUMBER"] = (index + 1).to_s
+        output = `bundle exec rake db:drop db:create db:schema:load 2>&1`
+        server_channel.write("command" => "stdout", "process" => "db:schema:load", "text" => output)
+      end
+    end
+
+    if configuration.migrate
+      configuration.process_count.times do |index|
+        debug "migrating database #{index+1}..."
+        ENV["TEST_ENV_NUMBER"] = (index + 1).to_s
+        output = `bundle exec rake db:migrate 2>&1`
+        server_channel.write("command" => "stdout", "process" => "db:migrate", "text" => output)
+      end
+    end
+  end
+
+  def load_rails_environment
+    debug "loading rails environment..."
+
+    ENV["TEST_ENV_NUMBER"] = "1"
+
+    output = Nitra::Utils.capture_output do
+      require 'spec/spec_helper'
+    end
+
+    server_channel.write("command" => "stdout", "process" => "rails initialisation", "text" => output)
+
+    ActiveRecord::Base.connection.disconnect!
+  end
+
+  def start_workers
+    (0...configuration.process_count).collect do |index|
+      Nitra::Worker.new(runner_id, index, configuration).fork_and_run
+    end
+  end
+
+  def hand_out_files_to_workers(pipes)
+    while !$aborted && pipes.length > 0
+      Nitra::Channel.read_select(pipes).each do |worker_channel|
+        unless data = worker_channel.read
+          pipes.delete worker_channel
+          debug "worker #{worker_channel} unexpectedly died."
+          next
+        end
+
+        case data['command']
+        when "debug", "stdout"
+          server_channel.write(data)
+
+        when "result"
+          if m = data['text'].match(/(\d+) examples?, (\d+) failure/)
+            example_count = m[1].to_i
+            failure_count = m[2].to_i
+          end
+
+          stripped_data = data['text'].gsub(/^[.FP*]+$/, '').gsub(/\nFailed examples:.+/m, '').gsub(/^Finished in.+$/, '').gsub(/^\d+ example.+$/, '').gsub(/^No examples found.$/, '').gsub(/^Failures:$/, '')
+
+          server_channel.write(
+            "command"       => "result",
+            "filename"      => data["filename"],
+            "return_code"   => data["return_code"],
+            "example_count" => example_count,
+            "failure_count" => failure_count,
+            "text"          => stripped_data)
+
+        when "ready"
+          server_channel.write("command" => "next")
+          next_file = server_channel.read.fetch("filename")
+
+          if next_file
+            debug "sending #{next_file} to channel #{worker_channel}"
+            worker_channel.write "command" => "process", "filename" => next_file
+          else
+            debug "sending close message to channel #{worker_channel}"
+            worker_channel.write "command" => "close"
+            pipes.delete worker_channel
+          end
+        end
+      end
+    end
+  end
+
+  def debug(*text)
+    server_channel.write(
+      "command" => "debug",
+      "text" => "runner #{runner_id}: #{text.join}"
+    ) if configuration.debug
+  end
+end

data/lib/nitra/slave.rb

@@ -0,0 +1,71 @@
+module Nitra::Slave
+  class Client
+    attr_reader :configuration
+
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    def connect(runner_id_base)
+      runner_id = "#{runner_id_base}A"
+
+      @configuration.slaves.collect do |slave_details|
+        runner_id = runner_id.succ
+        connect_host(slave_details, runner_id)
+      end.compact
+    end
+
+    protected
+    def connect_host(slave_details, runner_id)
+      client, server = Nitra::Channel.pipe
+
+      puts "Starting slave runner #{runner_id} with command '#{slave_details[:command]}'" if configuration.debug
+
+      pid = fork do
+        server.close
+        $stdin.reopen(client.rd)
+        $stdout.reopen(client.wr)
+        $stderr.reopen(client.wr)
+        exec slave_details[:command]
+      end
+      client.close
+
+      slave_config = configuration.dup
+      slave_config.process_count = slave_details.fetch(:cpus)
+
+      server.write(
+        "command" => "configuration",
+        "runner_id" => runner_id,
+        "configuration" => slave_config)
+      response = server.read
+
+      if response["command"] == "connected"
+        puts "Connection to slave runner #{runner_id} successful" if configuration.debug
+        server
+      else
+        $stderr.puts "Connection to slave runner #{runner_id} FAILED with message: #{response.inspect}"
+        Process.kill("KILL", pid)
+        nil
+      end
+    end
+  end
+
+  class Server
+    attr_reader :channel
+
+    def run
+      @channel = Nitra::Channel.new($stdin, $stdout)
+
+      response = @channel.read
+      unless response && response["command"] == "configuration"
+        puts "handshake failed"
+        exit 1
+      end
+
+      @channel.write("command" => "connected")
+
+      runner = Nitra::Runner.new(response["configuration"], channel, response["runner_id"])
+      runner.run
+    end
+  end
+end

data/lib/nitra/utils.rb

@@ -0,0 +1,31 @@
+class Nitra::Utils
+  # The following taken and modified from the 'parallel' gem.
+  # Licensed under the MIT licence, copyright Michael Grosser.
+  def self.processor_count
+    @processor_count ||= case `uname`
+    when /darwin/i
+      (`which hwprefs` != '' ? `hwprefs thread_count` : `sysctl -n hw.ncpu`).to_i
+    when /linux/i
+      `grep -c processor /proc/cpuinfo`.to_i
+    when /freebsd/i
+      `sysctl -n hw.ncpu`.to_i
+    when /solaris2/i
+      `psrinfo -p`.to_i # this is physical cpus afaik
+    else
+      1
+    end
+  end
+
+  def self.capture_output
+    old_stdout = $stdout
+    old_stderr = $stderr
+    $stdout = $stderr = io = StringIO.new
+    begin
+      yield
+    ensure
+      $stdout = old_stdout
+      $stderr = old_stderr
+    end
+    io.string
+  end
+end

data/lib/nitra/worker.rb

@@ -0,0 +1,128 @@
+require 'stringio'
+require 'tempfile'
+
+class Nitra::Worker
+  attr_reader :runner_id, :worker_number, :configuration, :channel
+
+  def initialize(runner_id, worker_number, configuration)
+    @runner_id = runner_id
+    @worker_number = worker_number
+    @configuration = configuration
+  end
+
+  def fork_and_run
+    client, server = Nitra::Channel.pipe
+
+    fork do
+      server.close
+      @channel = client
+      run
+    end
+
+    client.close
+    server
+  end
+
+  protected
+  def run
+    trap("SIGTERM") { Process.kill("SIGKILL", Process.pid) }
+    trap("SIGINT") { Process.kill("SIGKILL", Process.pid) }
+
+    debug "started"
+
+    ENV["TEST_ENV_NUMBER"] = (worker_number + 1).to_s
+
+    # Find the database config for this TEST_ENV_NUMBER and manually initialise a connection.
+    database_config = YAML.load(ERB.new(IO.read("#{Rails.root}/config/database.yml")).result)[ENV["RAILS_ENV"]]
+    ActiveRecord::Base.establish_connection(database_config)
+    Rails.cache.reset if Rails.cache.respond_to?(:reset)
+
+    # RSpec doesn't like it when you change the IO between invocations.  So we make one object and flush it
+    # after every invocation.
+    io = StringIO.new
+
+    # When rspec processes the first spec file, it does initialisation like loading in fixtures into the
+    # database.  If we're forking for each file, we need to initialise first so it doesn't try to initialise
+    # for every single file.
+    if configuration.fork_for_each_file
+      debug "running empty spec to make rspec run its initialisation"
+      file = Tempfile.new("nitra")
+      begin
+        file.write("require 'spec_helper'; describe('nitra preloading') { it('preloads the fixtures') { 1.should == 1 } }\n")
+        file.close
+        output = Nitra::Utils.capture_output do
+          RSpec::Core::CommandLine.new(["-f", "p", file.path]).run(io, io)
+        end
+        channel.write("command" => "stdout", "process" => "init rspec", "text" => output) unless output.empty?
+      ensure
+        file.close unless file.closed?
+        file.unlink
+      end
+      RSpec.reset
+      io.string = ""
+    end
+
+    # Loop until our master tells us we're finished.
+    loop do
+      debug "announcing availability"
+      channel.write("command" => "ready")
+
+      debug "waiting for next job"
+      data = channel.read
+      if data.nil? || data["command"] == "close"
+        debug "channel closed, exiting"
+        exit
+      end
+
+      filename = data.fetch("filename").chomp
+      debug "starting to process #{filename}"
+
+      perform_rspec_for_filename = lambda do
+        begin
+          result = RSpec::Core::CommandLine.new(["-f", "p", filename]).run(io, io)
+        rescue LoadError
+          io << "\nCould not load file #{filename}\n\n"
+          result = 1
+        end
+
+        channel.write("command" => "result", "filename" => filename, "return_code" => result.to_i, "text" => io.string)
+      end
+
+      if configuration.fork_for_each_file
+        rd, wr = IO.pipe
+        pid = fork do
+          rd.close
+          $stdout.reopen(wr)
+          $stderr.reopen(wr)
+          perform_rspec_for_filename.call
+        end
+        wr.close
+        stdout_buffer = ""
+        loop do
+          IO.select([rd])
+          text = rd.read
+          break if text.nil? || text.length.zero?
+          stdout_buffer << text
+        end
+        rd.close
+        Process.wait(pid) if pid
+      else
+        stdout_buffer = Nitra::Utils.capture_output do
+          perform_rspec_for_filename.call
+        end
+        io.string = ""
+        RSpec.reset
+      end
+      channel.write("command" => "stdout", "process" => "rspec", "filename" => filename, "text" => stdout_buffer) unless stdout_buffer.empty?
+
+      debug "#{filename} processed"
+    end
+  end
+
+  def debug(*text)
+    channel.write(
+      "command" => "debug",
+      "text" => "worker #{runner_id}.#{worker_number}: #{text.join}"
+    ) if configuration.debug
+  end
+end

data/lib/nitra.rb

@@ -1,240 +1,13 @@
-require 'stringio'
-require 'tempfile'
-
-class Nitra
-  attr_accessor :load_schema, :migrate, :debug, :quiet, :print_failures, :fork_for_each_file
-  attr_accessor :files
-  attr_accessor :process_count, :environment
-
-  def initialize
-    self.process_count = 4
-    self.environment = "nitra"
-    self.fork_for_each_file = true
-  end
-
-  def run
-    start_time = Time.now
-    ENV["RAILS_ENV"] = environment
-
-    initialise_database
-
-    load_rails_environment
-
-    pipes = fork_workers
-
-    self.files = Dir["spec/**/*_spec.rb"] if files.nil? || files.empty?
-    return if files.empty?
-
-    trap("SIGTERM") { $aborted = true }
-    trap("SIGINT") { $aborted = true }
-
-    return_code, result = hand_out_files_to_workers(files, pipes)
-
-    trap("SIGTERM", "DEFAULT")
-    trap("SIGINT", "DEFAULT")
-
-    print_result(result)
-    puts "\n#{$aborted ? "Aborted after" : "Finished in"} #{"%0.1f" % (Time.now-start_time)} seconds" unless quiet
-
-    $aborted ? 255 : return_code
-  end
-
-  protected
-  def print_result(result)
-    puts result.gsub(/\n\n\n+/, "\n\n")
-  end
-
-  def print_progress
-    unless quiet
-      bar_length = @columns - 50
-      progress = @files_completed / @file_count.to_f
-      length_completed = (progress * bar_length).to_i
-      length_to_go = bar_length - length_completed
-      print "[#{"X" * length_completed}#{"." * length_to_go}] #{@files_completed}/#{@file_count} (#{"%0.1f%%" % (progress*100)}) * #{@example_count} examples, #{@failure_count} failures\r"
-    end
-  end
-
-  def initialise_database
-    if load_schema
-      process_count.times do |index|
-        puts "initialising database #{index+1}..." unless quiet
-        ENV["TEST_ENV_NUMBER"] = (index + 1).to_s
-        system("bundle exec rake db:drop db:create db:schema:load")
-      end
-    end
-
-    if migrate
-      process_count.times do |index|
-        puts "migrating database #{index+1}..." unless quiet
-        ENV["TEST_ENV_NUMBER"] = (index + 1).to_s
-        system("bundle exec rake db:migrate")
-      end
-    end
-  end
-
-  def load_rails_environment
-    puts "loading rails environment..." if debug
-
-    ENV["TEST_ENV_NUMBER"] = "1"
-
-    require 'spec/spec_helper'
-
-    ActiveRecord::Base.connection.disconnect!
-  end
-
-  def fork_workers
-    (0...process_count).collect do |index|
-      server_sender_pipe = IO.pipe
-      client_sender_pipe = IO.pipe
-
-      fork do
-        trap("SIGTERM") { Process.kill("SIGKILL", Process.pid) }
-        trap("SIGINT") { Process.kill("SIGKILL", Process.pid) }
-
-        server_sender_pipe[1].close
-        client_sender_pipe[0].close
-        rd = server_sender_pipe[0]
-        wr = client_sender_pipe[1]
-
-        ENV["TEST_ENV_NUMBER"] = (index + 1).to_s
-
-        # Find the database config for this TEST_ENV_NUMBER and manually initialise a connection.
-        database_config = YAML.load(ERB.new(IO.read("#{Rails.root}/config/database.yml")).result)[ENV["RAILS_ENV"]]
-        ActiveRecord::Base.establish_connection(database_config)
-        Rails.cache.reset if Rails.cache.respond_to?(:reset)
-
-        # RSpec doesn't like it when you change the IO between invocations.  So we make one object and flush it
-        # after every invocation.
-        io = StringIO.new
-
-        # When rspec processes the first spec file, it does initialisation like loading in fixtures into the
-        # database.  If we're forking for each file, we need to initialise first so it doesn't try to initialise
-        # for every single file.
-        if fork_for_each_file
-          puts "running empty spec to make rspec run its initialisation" if debug
-          file = Tempfile.new("nitra")
-          begin
-            file.write("require 'spec_helper'; describe('nitra preloading') { it('preloads the fixtures') { 1.should == 1 } }\n")
-            file.close
-            RSpec::Core::CommandLine.new(["-f", "p", file.path]).run(io, io)
-          ensure
-            file.close unless file.closed?
-            file.unlink
-          end
-          RSpec.reset
-          io.string = ""
-        end
-
-        # OK, we're good to receive requests.  Tell our master.
-        puts "announcing availability" if debug
-        wr.write("0,0\n")
-
-        # Loop until our master tells us we're finished.
-        loop do
-          puts "#{index} waiting for next job" if debug
-          filename = rd.gets
-          exit if filename.blank?
-          filename = filename.chomp
-          puts "#{index} starting to process #{filename}" if debug
-
-          perform_rspec_for_filename = lambda do
-            begin
-              result = RSpec::Core::CommandLine.new(["-f", "p", filename]).run(io, io)
-            rescue LoadError
-              io << "\nCould not load file #{filename}\n\n"
-              result = 1
-            end
-
-            wr.write("#{result.to_i},#{io.string.length}\n#{io.string}")
-          end
-
-          if fork_for_each_file
-            pid = fork(&perform_rspec_for_filename)
-            Process.wait(pid) if pid
-          else
-            perform_rspec_for_filename.call
-            io.string = ""
-            RSpec.reset
-          end
-
-          puts "#{index} #{filename} processed" if debug
-        end
-      end
-
-      server_sender_pipe[0].close
-      client_sender_pipe[1].close
-      [client_sender_pipe[0], server_sender_pipe[1]]
-    end
-  end
-
-  def hand_out_files_to_workers(files, pipes)
-    puts "Running rspec on #{files.length} files spread across #{process_count} processes\n\n" unless quiet
-
-    @columns = (ENV['COLUMNS'] || 120).to_i
-    @file_count = files.length
-    @files_completed = 0
-    @example_count = 0
-    @failure_count = 0
-
-    result = ""
-    worst_return_code = 0
-    readers = pipes.collect(&:first)
-
-    while !$aborted && readers.length > 0
-      print_progress
-      fds = IO.select(readers)
-      fds.first.each do |fd|
-        unless value = fd.gets
-          readers.delete(fd)
-          worst_return_code = 255
-          if readers.empty?
-            puts "Worker unexpectedly died.  No more workers to run specs - dying."
-          else
-            puts "Worker unexpectedly died.  Trying to continue with fewer workers."
-          end
-          break
-        end
-
-        return_code, length = value.split(",")
-        worst_return_code = return_code.to_i if worst_return_code < return_code.to_i
-
-        if length.to_i > 0
-          data = fd.read(length.to_i)
-
-          @files_completed += 1
-          failure_count = 0
-
-          if m = data.match(/(\d+) examples?, (\d+) failure/)
-            @example_count += m[1].to_i
-            failure_count += m[2].to_i
-          end
-
-          @failure_count += failure_count
-          stripped_data = data.gsub(/^[.FP*]+$/, '').gsub(/\nFailed examples:.+/m, '').gsub(/^Finished in.+$/, '').gsub(/^\d+ example.+$/, '').gsub(/^No examples found.$/, '').gsub(/^Failures:$/, '')
-
-          if print_failures && failure_count > 0
-            print_result(stripped_data)
-          else
-            result << stripped_data
-          end
-        else
-          puts "ZERO LENGTH" if debug
-        end
-
-        wr = pipes.detect {|rd, wr| rd == fd}[1]
-        if files.length.zero?
-          wr.puts ""
-          readers.delete(fd)
-        else
-          puts "master is sending #{files.first} to fd #{wr}" if debug
-          wr.puts files.shift
-        end
-      end
-    end
-
-    print_progress
-    puts "" unless quiet
-
-    [worst_return_code, result]
-  end
+module Nitra
 end
+
+require 'nitra/channel'
+require 'nitra/client'
+require 'nitra/command_line'
+require 'nitra/configuration'
+require 'nitra/master'
+require 'nitra/progress'
+require 'nitra/runner'
+require 'nitra/slave'
+require 'nitra/utils'
+require 'nitra/worker'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: nitra
 version: !ruby/object:Gem::Version 
-  hash: 61
+  hash: 51
   prerelease: 
   segments: 
   - 0
   - 9
-  - 3
-  version: 0.9.3
+  - 4
+  version: 0.9.4
 platform: ruby
 authors: 
 - Roger Nesbitt
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-06-07 00:00:00 +12:00
+date: 2012-06-08 00:00:00 +12:00
 default_executable: 
 dependencies: []
 
@@ -31,6 +31,16 @@ files:
 - README
 - lib/nitra.rb
 - bin/nitra
+- lib/nitra/channel.rb
+- lib/nitra/client.rb
+- lib/nitra/command_line.rb
+- lib/nitra/configuration.rb
+- lib/nitra/master.rb
+- lib/nitra/progress.rb
+- lib/nitra/runner.rb
+- lib/nitra/slave.rb
+- lib/nitra/utils.rb
+- lib/nitra/worker.rb
 has_rdoc: true
 homepage: 
 licenses: []