buffet 1.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 05b4680ad4e35179ea117b6d6208096ae463eb51
+  data.tar.gz: 69c35e59adc7f62883427b7eea842966b06f32cc
+SHA512:
+  metadata.gz: 549dd260454181a04fbc16e92ce13e238d18e28d2aa4ebeaf05a4727204e30804e5452518b065a21ff05ac8826608417669accd93696ea24b9bb4c23c08d594f
+  data.tar.gz: ca3c1037f6b62ba78e7cf6ad5e4101d1795f22502dfdb33f1cc870566d0eab503a7476e24148f3ca7d6e2db3800e809024a03a17b662585a2aef9df98ef5112c

data/bin/buffet

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'buffet/cli'
+
+Buffet::CLI.new ARGV

data/lib/buffet/cli.rb

@@ -0,0 +1,39 @@
+require 'buffet'
+require 'optparse'
+
+module Buffet
+  class CLI
+    def initialize args
+      opts = OptionParser.new do |opts|
+        opts.banner = "Usage: buffet [options] [spec-files]"
+
+        opts.on('-c', '--config CONFIG',
+                'Use the specified CONFIG file') do |config_file|
+          Settings.settings_file = File.expand_path(config_file)
+        end
+
+        opts.on('-p', '--project PROJECT',
+                'Use the specified PROJECT name') do |project_name|
+          Settings.project_name = project_name
+        end
+
+        opts.on('-l', '--log LOGFILE',
+                'Write to log to LOGFILE, instead of default buffet.log') do |log|
+          Settings.log_file = log
+        end
+
+        opts.on('-v', '--version', 'Show version') do
+          puts "#{opts.program_name} #{VERSION}"
+          exit
+        end
+      end.parse!(args)
+
+      specs = Buffet.extract_specs_from(opts.empty? ? ['spec'] : opts)
+
+      runner = Runner.new
+      runner.run specs
+
+      exit 1 if runner.failed?
+    end
+  end
+end

data/lib/buffet/command_runner.rb

@@ -0,0 +1,23 @@
+require 'logger'
+require 'wopen3'
+
+module Buffet
+  class CommandRunner
+    def initialize logger = Logger.new(STDOUT)
+      @logger = logger
+    end
+
+    def run *command
+      start_time = Time.now
+      result = Wopen3.system *command
+      end_time = Time.now
+      @logger.info "\n" +
+        "command: #{command.join ' '}\n" +
+        "time: #{end_time - start_time}\n" +
+        "status: #{result.status}\n" +
+        "stdout:\n#{result.stdout}\n" +
+        "stderr:\n#{result.stderr}"
+      result
+    end
+  end
+end

data/lib/buffet/master.rb

@@ -0,0 +1,320 @@
+require 'benchmark'
+require 'drb'
+require 'thread'
+require 'socket'
+
+module Buffet
+  class Master
+    attr_reader :failures, :stats, :slave_exceptions, :spurious_failures
+
+    def initialize project, slaves, specs, listener
+      @project = project
+      @slaves = slaves
+      @stats = { :examples => 0, :failures => 0, :pending => 0, :spurious_failures => 0 }
+      @slaves_stats = Hash[@slaves.map do |slave|
+        [slave.user_at_host, stats.dup.merge!(:slave => slave, :specs => [])]
+      end]
+      @slave_exceptions = {}
+      @max_slave_prepare_failures = [Settings.allowed_slave_prepare_failures,
+                                     @slaves.count - 1].min
+      @stats[:slaves] = @slaves_stats
+      @lock = Mutex.new
+      @condition = ConditionVariable.new
+      @failures = []
+      @spurious_failures = []
+      @specs = order_specs(specs)
+      @listener = listener
+      @halt_exception = nil
+
+      # How many times a particular spec file was queued
+      @spec_queue_count = Hash.new { |h, k| h[k] = 0 }
+
+      # Need this so when we get back an example result from a slave we can know
+      # which spec it is from. This prevents the wrong file from being reported
+      # in the case of shared examples.
+      @current_spec_for_slave = {}
+
+      # Store spec results on per spec per line basis
+      @spec_results = Hash.new { |h, k| h[k] = [] }
+    end
+
+    def order_specs(specs)
+      specs.map do |spec|
+        [`wc -l #{spec}`.to_i, spec]
+      end.sort.reverse.map(&:last)
+    end
+
+    def run
+      start_service
+
+      @stats[:total_time] = Benchmark.measure do
+        @threads = @slaves.map do |slave|
+          Thread.new do
+            run_worker slave
+          end
+        end
+
+        wait_for_workers
+      end.real
+
+      stop_service
+
+      process_spec_results
+    end
+
+    def run_worker slave
+      time = Benchmark.measure do
+        begin
+          prepare_slave slave
+        rescue CommandError => ex
+          slave_prepare_failed slave, ex
+        rescue Exception => ex
+          stop_run ex
+        else
+          begin
+            run_slave slave
+          rescue Exception => ex
+            stop_run ex
+          end
+        end
+      end.real
+
+      @lock.synchronize do
+        @slaves_stats[slave.name][:total_time] = time
+        @condition.signal # Tell master this slave is finished
+      end
+    end
+
+    def wait_for_workers
+      @threads.count.times do
+        @lock.synchronize do
+          @condition.wait(@lock)
+
+          raise @halt_exception if @halt_exception
+
+          if slave_exceptions.count > @max_slave_prepare_failures
+            raise 'Exceeded maximum number of allowed slave prepare failures'
+          end
+        end
+      end
+    end
+
+    def stop_run ex
+      @lock.synchronize do
+        @halt_exception = ex
+        @condition.signal # Alert master
+      end
+    end
+
+    def next_file_for(slave_name, previous_spec)
+      file = nil
+
+      @lock.synchronize do
+        if rerun_spec?(previous_spec)
+          @spec_queue_count[previous_spec] += 1
+          return previous_spec
+        else
+          if file = @specs.shift
+            @spec_queue_count[file] += 1
+            @current_spec_for_slave[slave_name] = file
+
+            @slaves_stats[slave_name][:specs] << file
+          end
+        end
+      end
+
+      if file
+        slave = nil
+        @lock.synchronize do
+          slave = @slaves_stats[slave_name][:slave]
+        end
+        @listener.spec_taken(slave, file)
+      end
+
+      file
+    end
+
+    def slave_prepare_failed slave, ex
+      @listener.slave_prepare_failed slave, ex
+
+      @lock.synchronize do
+        slave_exceptions[slave.name] = ex
+
+        @condition.signal # Alert master this slave failed
+      end
+    end
+
+    def example_passed(slave_name, details)
+      @lock.synchronize do
+        @spec_results[@current_spec_for_slave[slave_name]] << details
+      end
+
+      @listener.example_passed
+    end
+
+    def example_failed(slave_name, details)
+      @lock.synchronize do
+        @spec_results[@current_spec_for_slave[slave_name]] << details
+      end
+
+      @listener.example_failed
+    end
+
+    def example_pending slave_name, details
+     @lock.synchronize do
+       @stats[:examples] += 1
+       @stats[:pending] += 1
+       @slaves_stats[slave_name][:pending] += 1
+     end
+
+     @listener.example_pending
+    end
+
+  private
+
+    def server_uri
+      @drb_server.uri
+    end
+
+    def start_service
+      @drb_server = DRb.start_service("druby://#{ip}:0", self)
+    end
+
+    def stop_service
+      DRb.stop_service
+    end
+
+    def ip
+      result = Buffet.run! 'host `hostname -s`'
+      result.stdout.chomp.match(/((\d+\.){3}\d+)/)[1]
+    end
+
+    def prepare_slave slave
+      time = Benchmark.measure do
+        @project.sync_to slave
+
+        if Settings.has_prepare_script?
+          slave.execute_in_project "#{Settings.prepare_script} #{Buffet.user} #{@project.name}"
+        end
+
+        # Copy support files so they can be run on the remote machine
+        slave.scp File.dirname(__FILE__) + '/../../support',
+                  @project.support_dir_on_slave, :recurse => true
+      end.real
+      @lock.synchronize { @slaves_stats[slave.name][:prepare_time] = time }
+
+      @listener.slave_prepared slave
+    end
+
+    def run_slave slave
+      time = Benchmark.measure do
+        slave.execute_in_project([
+          Settings.worker_command,
+          server_uri,
+          slave.user_at_host,
+          Settings.framework,
+        ].join(' '))
+      end.real
+
+      @lock.synchronize { @slaves_stats[slave.name][:test_time] = time }
+
+      @listener.slave_finished slave
+    end
+
+    def rerun_spec?(spec)
+      spec && example_failed_last_run?(spec) && unconfirmed_failures(spec) > 0
+    end
+
+    def example_count(spec)
+      @spec_results[spec].count / @spec_queue_count[spec]
+    end
+
+    def example_failed_last_run?(spec)
+      (1..example_count(spec)).any? do |i|
+        @spec_results[spec][-i][:status] == :failed
+      end
+    end
+
+    def confirmed_failures(spec)
+      failure_counts_for_spec(spec).count do |failure_count|
+        failure_count >= Settings.failure_threshold
+      end
+    end
+
+    def unconfirmed_failures(spec)
+      failure_counts_for_spec(spec).count do |failure_count|
+        (1...Settings.failure_threshold).member?(failure_count)
+      end
+    end
+
+    # Returns an array of failure counts over all spec runs for each example
+    def failure_counts_for_spec(spec)
+      example_result_list = @spec_results[spec]
+      example_count = example_count(spec)
+
+      (0...example_count).map do |i|
+        example_result_list.select.
+                            with_index { |_, j| j % example_count == i }.
+                            count { |example_result| example_result[:status] == :failed }
+      end
+    end
+
+    def process_spec_results
+      @spec_results.each do |spec, example_results|
+        next if example_results.empty?  # Can legitimately happen when spec has no examples
+
+        slave_name = example_results.last[:slave_name]
+
+        spec_examples_count = example_count(spec)
+        @stats[:examples] += spec_examples_count
+        @slaves_stats[slave_name][:examples] += spec_examples_count
+
+        confirmed_failures = confirmed_failures(spec)
+        @stats[:failures] += confirmed_failures
+        @slaves_stats[slave_name][:failures] += confirmed_failures
+        @failures += confirmed_failure_results(spec)
+
+        spurious_failures = unconfirmed_failures(spec)
+        @stats[:spurious_failures] += spurious_failures
+        @slaves_stats[slave_name][:spurious_failures] += spurious_failures
+        @spurious_failures += spurious_failure_results(spec)
+      end
+    end
+
+    def confirmed_failure_results(spec)
+      failures = []
+
+      example_count = example_count(spec)
+
+      failure_counts_for_spec(spec).each_with_index do |count, index|
+        if count >= Settings.failure_threshold
+          # Find first failure for spec
+          failures << @spec_results[spec].
+            select.
+            with_index { |_, i| i % example_count == index }.
+            find { |example_result| example_result[:status] == :failed }
+        end
+      end
+
+      failures
+    end
+
+    def spurious_failure_results(spec)
+      spurious_failures = []
+
+      example_count = example_count(spec)
+
+      failure_counts_for_spec(spec).each_with_index do |count, index|
+        if (1...Settings.failure_threshold).member?(count)
+          # Find first failure for spec
+          spurious_failures << @spec_results[spec].
+            select.
+            with_index { |_, i| i % example_count == index }.
+            find { |example_result| example_result[:status] == :failed }
+        end
+      end
+
+      spurious_failures
+    end
+  end
+end

data/lib/buffet/project.rb

@@ -0,0 +1,24 @@
+module Buffet
+  class Project
+    attr_accessor :name
+    attr_reader   :directory
+
+    def initialize directory
+      @name = File.basename directory
+      @directory = File.expand_path directory
+    end
+
+    def directory_on_slave
+      "#{Buffet.workspace_dir}/#{name}"
+    end
+
+    def support_dir_on_slave
+      "#{directory_on_slave}/.buffet"
+    end
+
+    def sync_to slave
+      slave.execute "mkdir -p #{directory_on_slave}"
+      slave.rsync directory + '/', directory_on_slave
+    end
+  end
+end

data/lib/buffet/runner.rb

@@ -0,0 +1,155 @@
+require 'buffet'
+require 'colorize'
+require 'fileutils'
+
+module Buffet
+  class Runner
+    def initialize
+      @project = Settings.project
+    end
+
+    def run specs = nil
+      @specs = specs
+      raise 'No specs found' if @specs.empty?
+
+      @slaves = Settings.slaves
+      raise 'No slaves defined in settings.yml' if @slaves.empty?
+
+      Buffet.logger.info "Starting Buffet test run"
+      puts "Running Buffet..."
+
+      run_tests
+      display_results
+    end
+
+    def slave_prepared slave
+      Buffet.logger.info "#{slave.name} prepared"
+    end
+
+    def slave_prepare_failed slave, exception
+      Buffet.logger.warn "#{slave.name} preparation failed: #{exception}"
+    end
+
+    def spec_taken slave, spec_file
+      Buffet.logger.info "#{slave.name} took #{spec_file}"
+    end
+
+    def example_passed
+      print '.'.green
+      STDOUT.flush
+    end
+
+    def example_failed
+      print 'F'.red
+      STDOUT.flush
+    end
+
+    def example_pending
+      print '*'.yellow
+      STDOUT.flush
+    end
+
+    def slave_finished slave
+      Buffet.logger.info "#{slave.name} finished"
+      gather_junit slave if !!Settings['gather_junit']
+    end
+
+    def failed?
+      @master.failures.any? || no_examples_run?
+    end
+
+    private
+
+    def run_tests
+      @master = Master.new @project, @slaves, @specs, self
+      @master.run
+    end
+
+    def display_results
+      results = []
+      results << "\n"
+
+      results << "Total Examples: #{@master.stats[:examples]}"
+      results << "Total Pending:  #{@master.stats[:pending]}"
+      results << "Total Failures: #{@master.stats[:failures]}"
+      results << "Total Spurious Failures: #{@master.stats[:spurious_failures]}"
+      results << "Buffet consumed in #{@master.stats[:total_time]} seconds"
+
+      if @master.failures.any?
+        results << '' << 'SPEC FAILURES:'.red
+        results << ('=' * 80).red
+        results << @master.failures.map do |failure|
+          example_details(failure)
+        end
+      elsif @master.spurious_failures.any?
+        results << '' << 'SPURIOUS FAILURES:'.yellow
+        results << ('-' * 80).yellow
+        results << @master.spurious_failures.map do |spurious_failure|
+          example_details(spurious_failure)
+        end
+      elsif no_examples_run?
+        results << '' << 'No examples were run!'.red
+      end
+
+      results << '' << 'SLAVE STATS:'
+      results << ('-' * 80)
+      @master.stats[:slaves].each do |slave_name, slave_stats|
+        results << "#{slave_name}:"
+
+        if @master.slave_exceptions[slave_name]
+          results << "\tFailed to prepare"
+          next
+        end
+
+        slave_stats.each do |key, value|
+          results << "\t#{key}: #{value}" unless [:slave, :specs].include?(key)
+        end
+
+        if slave_stats[:failures] > 0
+          results << "\tSpec order (use to help reproduce spurious failures):"
+          results << "\t  #{slave_stats[:specs].join("\n\t  ")}"
+        end
+      end
+
+      unless @master.slave_exceptions.empty?
+        results << '' << 'SLAVE PREPARATION_FAILURES'.yellow
+        results << ('-' * 80).yellow
+        results << @master.slave_exceptions.map do |slave, ex|
+          "#{slave}:\n".yellow +
+          "#{ex}" + (ex.backtrace ? ex.backtrace.join("\n") : 'No backtrace')
+        end
+      end
+
+      puts results
+    end
+
+    def example_details(details)
+      "#{details[:description]}\n".red +
+      "Slave: #{details[:slave_name]}\n" +
+      "Location: #{details[:location]}\n" +
+      "#{details[:message]}\n".yellow +
+      "#{details[:backtrace]}\n"
+    end
+
+    def no_examples_run?
+      @master.stats[:examples] - @master.stats[:pending] == 0
+    end
+
+    def gather_junit slave
+      # Jenkins tells us where we are running
+      workspace = ENV['WORKSPACE'] || './'
+      FileUtils.mkdir_p File.join(workspace, 'reports')
+
+      # Copy the junit results from the slave into reports/foo@bar/
+      # Configure jenkins to read reports/**/*.xml
+      Buffet.run! *%W[
+        rsync -aqz --delete
+        -e ssh
+        #{slave.user_at_host}:#{slave.project.directory_on_slave}/spec/reports/
+        #{workspace}/reports/#{slave.name}/
+      ]
+    rescue CommandError
+      Buffet.logger.warn "Failed to collect junit report from #{slave.name}"
+    end
+  end
+end

data/lib/buffet/settings.rb

@@ -0,0 +1,90 @@
+require 'yaml'
+
+module Buffet
+  class Settings
+    DEFAULT_LOG_FILE            = 'buffet.log'
+    DEFAULT_SETTINGS_FILE       = 'buffet.yml'
+    DEFAULT_PREPARE_SCRIPT      = 'bin/before-buffet-run'
+    DEFAULT_EXCLUDE_FILTER_FILE = '.buffet-exclude-filter'
+
+    class << self
+      def settings_file=(settings_file)
+        @settings_file = settings_file
+        reset!
+      end
+
+      def settings_file
+        @settings_file || DEFAULT_SETTINGS_FILE
+      end
+
+      def [](name)
+        @settings ||= load_file(settings_file)
+        @settings[name]
+      end
+
+      def slaves
+        @slaves ||= self['slaves'].map do |slave_hash|
+          Slave.new slave_hash['user'], slave_hash['host'], project
+        end
+      end
+
+      def allowed_slave_prepare_failures
+        self['allowed_slave_prepare_failures'] || 0
+      end
+
+      def worker_command
+        self['worker_command'] || '.buffet/buffet-worker'
+      end
+
+      def log_file=(log)
+        @log_file = log
+      end
+
+      def log_file
+        @log_file || self['log_file'] || DEFAULT_LOG_FILE
+      end
+
+      def project_name=(project_name)
+        project.name = project_name
+      end
+
+      def project
+        @project ||= Project.new Dir.pwd
+      end
+
+      def framework
+        self['framework'].upcase || 'RSPEC1'
+      end
+
+      def prepare_script
+        self['prepare_script'] || DEFAULT_PREPARE_SCRIPT
+      end
+
+      def has_prepare_script?
+        self['prepare_script'] || File.exist?(DEFAULT_PREPARE_SCRIPT)
+      end
+
+      def exclude_filter_file
+        self['exclude_filter_file'] || DEFAULT_EXCLUDE_FILTER_FILE
+      end
+
+      def has_exclude_filter_file?
+        self['exclude_filter_file'] || File.exist?(DEFAULT_EXCLUDE_FILTER_FILE)
+      end
+
+      def failure_threshold
+        self['failure_threshold'] || 2
+      end
+
+      def reset!
+        @settings = nil
+      end
+
+    private
+
+      def load_file file
+        @settings = YAML.load_file file
+      end
+    end
+  end
+end

data/lib/buffet/slave.rb

@@ -0,0 +1,48 @@
+module Buffet
+  class Slave
+    attr_reader :user, :host, :project
+
+    def initialize user, host, project
+      @user = user
+      @host = host
+      @project = project
+    end
+
+    def rsync src, dest
+      Buffet.run! 'rsync', '-aqz', '--delete',
+                  '--delete-excluded', rsync_exclude_flags,
+                  '-e', 'ssh', src, "#{user_at_host}:#{dest}"
+    end
+
+    def scp src, dest, options = {}
+      args = [src, "#{user_at_host}:#{dest}"]
+      args.unshift '-r' if options[:recurse]
+      Buffet.run! 'scp', *args
+    end
+
+    def execute_in_project command
+      execute "cd #{@project.directory_on_slave} && #{command}"
+    end
+
+    def execute command
+      Buffet.run! 'ssh', "#{user_at_host}", command
+    end
+
+    def name
+      user_at_host
+    end
+
+    def user_at_host
+      "#{@user}@#{@host}"
+    end
+
+    private
+
+    def rsync_exclude_flags
+      if Settings.has_exclude_filter_file?
+        exclude_flags = "--exclude-from=#{Settings.exclude_filter_file}"
+      end
+      exclude_flags || ''
+    end
+  end
+end

data/lib/buffet/version.rb

@@ -0,0 +1,3 @@
+module Buffet
+  VERSION = '1.3.0'
+end

data/lib/buffet.rb

@@ -0,0 +1,64 @@
+require 'fileutils'
+require 'find'
+require 'logger'
+require 'pathname'
+
+module Buffet
+  autoload :CommandRunner, 'buffet/command_runner'
+  autoload :Master, 'buffet/master'
+  autoload :Project, 'buffet/project'
+  autoload :Runner, 'buffet/runner'
+  autoload :Settings, 'buffet/settings'
+  autoload :Slave, 'buffet/slave'
+
+  class CommandError < StandardError; end
+
+  def self.log_dir
+    @log_dir ||= Pathname.new(ENV['HOME']) + '.buffet/log'
+  end
+
+  def self.log_file
+    Settings.log_file
+  end
+
+  def self.logger
+    @logger ||= begin
+      FileUtils.mkdir_p log_dir
+      Logger.new log_dir + log_file
+    end
+  end
+
+  def self.runner
+    @runner ||= CommandRunner.new logger
+  end
+
+  def self.run! *command
+    result = runner.run *command
+    unless result.success?
+      message = "`#{command.join(' ')}` exited with non-zero status: #{result.status}"
+      message += "\nSTDOUT: #{result.stdout}" unless result.stdout.empty?
+      message += "\nSTDERR: #{result.stderr}" unless result.stderr.empty?
+      raise CommandError.new(message)
+    end
+    result
+  end
+
+  # Given a set of files/directories, return all spec files contained
+  def self.extract_specs_from files
+    specs = []
+    files.each do |spec_file|
+      Find.find(spec_file) do |f|
+        specs << f if f.match /_spec\.rb$/
+      end
+    end
+    specs.uniq
+  end
+
+  def self.workspace_dir
+    ".buffet/workspaces/#{user}" # Relative to home directory
+  end
+
+  def self.user
+    @user ||= `whoami`.chomp
+  end
+end

data/support/buffet-worker

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+require 'drb'
+require 'fileutils'
+
+if File.exist? 'Gemfile'
+  require 'rubygems'
+  require 'bundler/setup'
+end
+
+# NOTE: ARGV is used by the spec runner. If I leave the drb server address
+# in ARGV, rspec will think it's an argument to the test runner.
+buffet_server = DRbObject.new_with_uri(ARGV.shift)
+slave_name = ARGV.shift
+framework = ARGV.shift
+
+FileUtils.mkdir_p('./tmp')
+
+if framework == 'RSPEC1'
+  require 'spec'
+  require 'spec/runner/command_line'
+  require File.expand_path('rspec1_formatter', File.dirname(__FILE__))
+
+  Spec::Runner::Formatter::AugmentedTextFormatter.configure buffet_server, slave_name
+
+  while file = buffet_server.next_file_for(slave_name)
+    # RSpec1 closes stderr/out after each run, so we reopen them each time
+    outlog = File.open('./tmp/buffet.out.log', 'a')
+    errlog = File.open('./tmp/buffet.error.log', 'a')
+
+    Spec::Runner::CommandLine.run(
+      Spec::Runner::OptionParser.parse(
+        ['--format', 'Spec::Runner::Formatter::AugmentedTextFormatter', file],
+        errlog,
+        outlog
+      )
+    )
+  end
+else
+  require 'rspec'
+  require File.expand_path('rspec2_formatter', File.dirname(__FILE__))
+
+  begin
+    require 'ci/reporter/rspec'
+    use_ci_reporter = true
+  rescue LoadError
+  end
+
+  RSpec::Core::Formatters::AugmentedTextFormatter.configure buffet_server, slave_name
+  RSpec::Core::Runner.disable_autorun!
+  rspec_opts = ['--format', 'RSpec::Core::Formatters::AugmentedTextFormatter']
+  rspec_opts += ['--format', 'CI::Reporter::RSpec'] if use_ci_reporter
+
+  while file = buffet_server.next_file_for(slave_name, file)
+    RSpec::Core::CommandLine.new(rspec_opts.dup << file).
+      run($stderr, $stdout)
+    RSpec.world.example_groups.clear
+  end
+end

data/support/rspec1_formatter.rb

@@ -0,0 +1,44 @@
+require 'spec/runner/formatter/base_text_formatter'
+
+module Spec
+  module Runner
+    module Formatter
+      class AugmentedTextFormatter < BaseTextFormatter
+        def self.configure buffet_server, slave_name
+          @@buffet_server = buffet_server
+          @@slave_name = slave_name
+        end
+
+        def example_passed example_proxy
+          super
+          @@buffet_server.example_passed(@@slave_name, {
+            :description => example_proxy.description,
+            :location    => example_proxy.location,
+            :slave_name  => @@slave_name,
+          })
+        end
+
+        def example_failed example_proxy, counter, failure
+          super
+          @@buffet_server.example_failed(@@slave_name, {
+            :backtrace   => failure.exception.backtrace.join("\n"),
+            :description => failure.header,
+            :location    => example_proxy.location,
+            :message     => failure.exception.message,
+            :slave_name  => @@slave_name,
+          })
+        end
+
+        def example_pending example, message, deprecated_pending_location=nil
+          super
+          @@buffet_server.example_pending(@@slave_name, {
+            :description => example.description,
+            :location    => example.location,
+            :message     => message,
+            :slave_name  => @@slave_name,
+          })
+        end
+      end
+    end
+  end
+end

data/support/rspec2_formatter.rb

@@ -0,0 +1,59 @@
+require 'rspec/core/formatters/base_text_formatter'
+
+module RSpec
+  module Core
+    module Formatters
+      class AugmentedTextFormatter < BaseTextFormatter
+        def initialize(output)
+          super(output)
+        end
+
+        def self.configure buffet_server, slave_name
+          @@buffet_server = buffet_server
+          @@slave_name = slave_name
+        end
+
+        def example_passed example
+          super
+
+          @@buffet_server.example_passed(@@slave_name, {
+            :description => example.description,
+            :location    => example.location,
+            :status      => :passed,
+            :slave_name  => @@slave_name,
+          })
+        end
+
+        def example_failed example
+          super
+          exception = example.metadata[:execution_result][:exception]
+          backtrace = format_backtrace(exception.backtrace, example).join("\n")
+
+          location = example.location
+          if shared_group = find_shared_group(example)
+            location += "\nShared example group called from " +
+              backtrace_line(shared_group.metadata[:example_group][:location])
+          end
+
+          @@buffet_server.example_failed(@@slave_name, {
+            :description => example.description,
+            :backtrace   => backtrace,
+            :message     => exception.message,
+            :location    => location,
+            :status      => :failed,
+            :slave_name  => @@slave_name,
+          })
+        end
+
+        def example_pending example
+          super
+          @@buffet_server.example_pending(@@slave_name, {
+            :description => example.description,
+            :location    => example.location,
+            :slave_name  => @@slave_name,
+          })
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: buffet
+version: !ruby/object:Gem::Version
+  version: 1.3.0
+platform: ruby
+authors:
+- Causes Engineering
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: wopen3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mkdtemp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Buffet distributes RSpec test cases over multiple machines.
+email:
+- eng@causes.com
+- grant@causes.com
+- shane@causes.com
+executables:
+- buffet
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/buffet.rb
+- lib/buffet/cli.rb
+- lib/buffet/command_runner.rb
+- lib/buffet/master.rb
+- lib/buffet/project.rb
+- lib/buffet/runner.rb
+- lib/buffet/settings.rb
+- lib/buffet/slave.rb
+- lib/buffet/version.rb
+- support/buffet-worker
+- support/rspec1_formatter.rb
+- support/rspec2_formatter.rb
+- bin/buffet
+homepage: http://github.com/causes/buffet
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.2
+signing_key: 
+specification_version: 4
+summary: Distributed testing framework for Ruby, Rails and RSpec
+test_files: []
+has_rdoc: