specjour 0.7.0 → 2.0.0.rc1

data/lib/specjour/dispatcher.rb

@@ -1,170 +0,0 @@
-module Specjour
-  class Dispatcher
-    require 'dnssd'
-    Thread.abort_on_exception = true
-    include SocketHelper
-
-    attr_reader :project_alias, :managers, :manager_threads, :hosts, :options, :drb_connection_errors, :test_paths, :rsync_port
-    attr_accessor :worker_size, :project_path
-
-    def initialize(options = {})
-      Specjour.load_custom_hooks
-      @options = options
-      @project_path = options[:project_path]
-      @test_paths = options[:test_paths]
-      @worker_size = 0
-      @managers = []
-      @drb_connection_errors = Hash.new(0)
-      @rsync_port = options[:rsync_port]
-      @manager_threads = []
-    end
-
-    def start
-      abort("#{project_path} doesn't exist") unless File.directory?(project_path)
-      gather_managers
-      rsync_daemon.start
-      dispatch_work
-      if dispatching_tests?
-        printer.start
-      else
-        wait_on_managers
-      end
-      exit printer.exit_status
-    end
-
-    protected
-
-    def add_manager(manager)
-      set_up_manager(manager)
-      managers << manager
-      self.worker_size += manager.worker_size
-    end
-
-    def command_managers(&block)
-      managers.each do |manager|
-        manager_threads << Thread.new(manager, &block)
-      end
-    end
-
-    def dispatcher_uri
-      @dispatcher_uri ||= URI::Generic.build :scheme => "specjour", :host => local_ip, :port => printer.port
-    end
-
-    def dispatch_work
-      puts "Workers found: #{worker_size}"
-      managers.each do |manager|
-        puts "#{manager.hostname} (#{manager.worker_size})"
-      end
-      command_managers { |m| m.dispatch rescue DRb::DRbConnError }
-    end
-
-    def dispatching_tests?
-      worker_task == 'run_tests'
-    end
-
-    def fetch_manager(uri)
-      manager = DRbObject.new_with_uri(uri.to_s)
-      if !managers.include?(manager) && manager.available_for?(project_alias)
-        add_manager(manager)
-      end
-    rescue DRb::DRbConnError => e
-      drb_connection_errors[uri] += 1
-      Specjour.logger.debug "#{e.message}: couldn't connect to manager at #{uri}"
-      sleep(0.1) && retry if drb_connection_errors[uri] < 5
-    end
-
-    def fork_local_manager
-      puts "No listeners found on this machine, starting one..."
-      manager_options = {:worker_size => options[:worker_size], :registered_projects => [project_alias], :rsync_port => rsync_port}
-      manager = Manager.start_quietly manager_options
-      Process.detach manager.pid
-      fetch_manager(manager.drb_uri)
-      at_exit do
-        unless Specjour.interrupted?
-          Process.kill('TERM', manager.pid) rescue Errno::ESRCH
-        end
-      end
-    end
-
-    def gather_managers
-      puts "Looking for listeners..."
-      gather_remote_managers
-      fork_local_manager if local_manager_needed?
-      abort "No listeners found" if managers.size.zero?
-    end
-
-    def gather_remote_managers
-      replies = []
-      Timeout.timeout(1) do
-        DNSSD.browse!('_druby._tcp') do |reply|
-          replies << reply if reply.flags.add?
-        end
-        raise Timeout::Error
-      end
-    rescue Timeout::Error
-      replies.each {|r| resolve_reply(r)}
-    end
-
-    def local_manager_needed?
-      options[:worker_size] > 0 && no_local_managers?
-    end
-
-    def no_local_managers?
-      managers.none? {|m| m.local_ip == local_ip}
-    end
-
-    def printer
-      @printer ||= Printer.new
-    end
-
-    def project_alias
-      @project_alias ||= options[:project_alias] || project_name
-    end
-
-    def project_name
-      @project_name ||= File.basename(project_path)
-    end
-
-    def resolve_reply(reply)
-      Timeout.timeout(1) do
-        DNSSD.resolve!(reply.name, reply.type, reply.domain, flags=0, reply.interface) do |resolved|
-          Specjour.logger.debug "Bonjour discovered #{resolved.target}"
-          if resolved.text_record && resolved.text_record['version'] == Specjour::VERSION
-            resolved_ip = ip_from_hostname(resolved.target)
-            uri = URI::Generic.build :scheme => reply.service_name, :host => resolved_ip, :port => resolved.port
-            fetch_manager(uri)
-          else
-            puts "Found #{resolved.target} but its version doesn't match v#{Specjour::VERSION}. Skipping..."
-          end
-          break unless resolved.flags.more_coming?
-        end
-      end
-    rescue Timeout::Error
-    end
-
-    def rsync_daemon
-      @rsync_daemon ||= RsyncDaemon.new(project_path, project_name, rsync_port)
-    end
-
-    def set_up_manager(manager)
-      manager.project_name = project_name
-      manager.dispatcher_uri = dispatcher_uri
-      manager.test_paths = test_paths
-      manager.worker_task = worker_task
-      at_exit do
-        begin
-          manager.interrupted = Specjour.interrupted?
-        rescue DRb::DRbConnError
-        end
-      end
-    end
-
-    def wait_on_managers
-      manager_threads.each {|t| t.join; t.exit}
-    end
-
-    def worker_task
-      options[:worker_task] || 'run_tests'
-    end
-  end
-end

data/lib/specjour/manager.rb

@@ -1,174 +0,0 @@
-module Specjour
-  class Manager
-    require 'dnssd'
-
-    include DRbUndumped
-    include SocketHelper
-    include Fork
-
-    attr_accessor :test_paths, :project_name, :worker_task, :pid
-    attr_reader :worker_size, :dispatcher_uri, :registered_projects, :loader_pid, :options, :rsync_port
-
-    def self.start_quietly(options)
-      manager = new options.merge(:quiet => true)
-      manager.drb_uri
-      manager.pid = Fork.fork_quietly { manager.start }
-      manager
-    end
-
-    def initialize(options = {})
-      @options = options
-      @worker_size = options[:worker_size]
-      @worker_task = options[:worker_task]
-      @registered_projects = options[:registered_projects]
-      @rsync_port = options[:rsync_port]
-      Specjour.load_custom_hooks
-    end
-
-    def available_for?(project_name)
-      registered_projects ? registered_projects.include?(project_name) : false
-    end
-
-    def dispatcher_uri=(uri)
-      uri.host = ip_from_hostname(uri.host)
-      @dispatcher_uri = uri
-    end
-
-    def dispatch
-      suspend_bonjour do
-        sync
-        with_clean_env do
-          execute_before_fork
-          dispatch_loader
-        end
-      end
-    end
-
-    def drb_start
-      $PROGRAM_NAME = "specjour listen" if quiet?
-      DRb.start_service drb_uri.to_s, self
-      at_exit { DRb.stop_service }
-    end
-
-    def drb_uri
-      @drb_uri ||= begin
-        current_uri.scheme = "druby"
-        current_uri
-      end
-    end
-
-    def dispatch_loader
-      @loader_pid = fork do
-        exec_cmd = "load --printer-uri #{dispatcher_uri} --workers #{worker_size} --task #{worker_task} --project-path #{project_path}"
-        exec_cmd << " --test-paths #{test_paths.join(" ")}" if test_paths.any?
-        exec_cmd << " --log" if Specjour.log?
-        exec_cmd << " --quiet" if quiet?
-        specjour_path = $LOAD_PATH.detect {|l| l =~ %r(specjour[^/]*/lib$)}
-        bin_path = File.expand_path(File.join(specjour_path, "../bin"))
-        Kernel.exec({"RUBYLIB" => $LOAD_PATH.join(":")}, "#{bin_path}/specjour #{exec_cmd}")
-      end
-      Process.waitall
-    ensure
-      kill_loader_process if loader_pid
-    end
-
-    def in_project(&block)
-      Dir.chdir(project_path, &block)
-    end
-
-    def interrupted=(bool)
-      Specjour.interrupted = bool
-      kill_loader_process if loader_pid
-    end
-
-    def kill_loader_process
-      if Specjour.interrupted?
-        Process.kill('INT', loader_pid) rescue Errno::ESRCH
-      else
-        Process.kill('TERM', loader_pid) rescue Errno::ESRCH
-      end
-      @loader_pid = nil
-    end
-
-    def pid
-      @pid || Process.pid
-    end
-
-    def project_path
-      File.expand_path(project_name, File.realpath('/tmp'))
-    end
-
-    def start
-      drb_start
-      bonjour_announce
-      at_exit { stop_bonjour }
-      DRb.thread.join
-    end
-
-    def quiet?
-      options.has_key? :quiet
-    end
-
-    def sync
-      cmd "rsync #{Specjour::Configuration.rsync_options} --port=#{rsync_port} #{dispatcher_uri.host}::#{project_name} #{project_path}"
-    end
-
-    protected
-
-    def bonjour_announce
-      projects = registered_projects.join(", ")
-      puts "Workers ready: #{worker_size}"
-      puts "Listening for #{projects}"
-      unless quiet?
-        text = DNSSD::TextRecord.new
-        text['version'] = Specjour::VERSION
-        bonjour_service.register "specjour_manager_#{projects}_#{Process.pid}", "_#{drb_uri.scheme}._tcp", domain=nil, drb_uri.port, host=nil, text
-      end
-    end
-
-    def bonjour_service
-      @bonjour_service ||= DNSSD::Service.new
-    end
-
-    def cmd(command)
-      Specjour.benchmark(command) do
-        system *command.split
-      end
-    end
-
-    def execute_before_fork
-      Specjour.benchmark("before_fork") do
-        in_project do
-          Specjour.load_custom_hooks
-          Configuration.before_fork.call
-        end
-      end
-    end
-
-    def stop_bonjour
-      bonjour_service.stop if bonjour_service && !bonjour_service.stopped?
-      @bonjour_service = nil
-    end
-
-    def suspend_bonjour(&block)
-      stop_bonjour
-      block.call
-      bonjour_announce
-    end
-
-    def with_clean_env
-      if defined?(Bundler)
-        Bundler.with_clean_env do
-          if ENV['RUBYOPT']
-            opts = ENV['RUBYOPT'].split(" ").delete_if {|opt| opt =~ /bundler/}
-            ENV['RUBYOPT'] = opts.join(" ")
-          end
-          yield
-        end
-      else
-        yield
-      end
-    end
-
-  end
-end

data/lib/specjour/rspec/distributed_formatter.rb

@@ -1,50 +0,0 @@
-module Specjour::RSpec
-  class DistributedFormatter < Specjour::Configuration.rspec_formatter.call
-
-    def metadata_for_examples
-      examples.map do |example|
-        metadata = example.metadata
-        {
-          :execution_result => marshalable_execution_result(example.execution_result),
-          :description      => metadata[:description],
-          :file_path        => metadata[:file_path],
-          :full_description => metadata[:full_description],
-          :line_number      => metadata[:line_number],
-          :location         => metadata[:location]
-        }
-      end
-    end
-
-    def noop(*args)
-    end
-    alias dump_pending noop
-    alias dump_failures noop
-    alias start_dump noop
-    alias message noop
-
-    def color_enabled?
-      true
-    end
-
-    def dump_summary(*args)
-      output.send_message :rspec_summary=, metadata_for_examples
-    end
-
-    def close
-      examples.clear
-      super
-    end
-
-    protected
-
-    def marshalable_execution_result(execution_result)
-      if exception = execution_result[:exception]
-        execution_result[:exception] = MarshalableException.new(exception)
-      end
-      execution_result[:started_at] = Time.at(execution_result[:started_at])
-      execution_result[:finished_at] = Time.at(execution_result[:finished_at])
-      execution_result
-    end
-
-  end
-end

data/lib/specjour/rspec/final_report.rb

@@ -1,73 +0,0 @@
-module Specjour::RSpec
-  class FinalReport
-    attr_reader :examples
-    attr_reader :duration
-
-    def initialize
-      @examples = []
-      @duration = 0.0
-      ::RSpec.configuration.color_enabled = true
-      ::RSpec.configuration.output_stream = $stdout
-    end
-
-    def add(data)
-      if data.respond_to?(:has_key?) && data.has_key?(:duration)
-        self.duration = data[:duration]
-      else
-        metadata_for_examples(data)
-      end
-    end
-
-    def duration=(value)
-      @duration = value.to_f if duration < value.to_f
-    end
-
-    def exit_status
-      formatter.failed_examples.empty?
-    end
-
-    def metadata_for_examples(metadata_collection)
-      examples.concat(
-        metadata_collection.map do |partial_metadata|
-          example = ::RSpec::Core::Example.allocate
-          example.instance_variable_set(:@example_group_class,
-            OpenStruct.new(:metadata => {}, :ancestors => [], :parent_groups => [])
-          )
-          metadata = ::RSpec::Core::Metadata.new
-          metadata.merge! partial_metadata
-          example.instance_variable_set(:@metadata, metadata)
-          example
-        end
-      )
-    end
-
-    def pending_examples
-      examples.select {|e| e.execution_result[:status] == 'pending'}
-    end
-
-    def failed_examples
-      examples.select {|e| e.execution_result[:status] == 'failed'}
-    end
-
-    def formatter
-      @formatter ||= new_progress_formatter
-    end
-
-    def summarize
-      if examples.size > 0
-        formatter.start_dump
-        formatter.dump_pending
-        formatter.dump_failures
-        formatter.dump_summary(duration, examples.size, failed_examples.size, pending_examples.size)
-      end
-    end
-
-    protected
-    def new_progress_formatter
-      new_formatter = ::RSpec::Core::Formatters::ProgressFormatter.new($stdout)
-      new_formatter.instance_variable_set(:@failed_examples, failed_examples)
-      new_formatter.instance_variable_set(:@pending_examples, pending_examples)
-      new_formatter
-    end
-  end
-end

data/lib/specjour/rspec/marshalable_exception.rb

@@ -1,19 +0,0 @@
-module Specjour::RSpec
-  class MarshalableException
-    attr_accessor :message, :backtrace, :class_name
-
-    def initialize(exception)
-      self.class_name = exception.class.name
-      self.message = exception.message
-      self.backtrace = exception.backtrace
-    end
-
-    def class
-      @class ||= OpenStruct.new :name => class_name
-    end
-
-    def pending_fixed?
-      false
-    end
-  end
-end

data/lib/specjour/rspec/preloader.rb

@@ -1,15 +0,0 @@
-class Specjour::RSpec::Preloader
-  def self.load(paths=[])
-    Specjour.benchmark("Loading RSpec environment") do
-      require File.expand_path('spec/spec_helper', Dir.pwd)
-      load_spec_files paths
-    end
-  end
-
-  def self.load_spec_files(paths)
-    options = ::RSpec::Core::ConfigurationOptions.new(paths)
-    options.parse_options
-    options.configure ::RSpec.configuration
-    ::RSpec.configuration.load_spec_files
-  end
-end

data/lib/specjour/rspec/runner.rb

@@ -1,14 +0,0 @@
-module Specjour::RSpec::Runner
-  ::RSpec.configuration.backtrace_clean_patterns << %r(lib/specjour/)
-
-  def self.run(spec, output)
-    args = ['--format=Specjour::RSpec::DistributedFormatter', spec]
-    ::RSpec::Core::Runner.run args, $stderr, output
-  ensure
-    ::RSpec.configuration.filter_manager = ::RSpec::Core::FilterManager.new
-    ::RSpec.world.filtered_examples.clear
-    ::RSpec.world.inclusion_filter.clear
-    ::RSpec.world.exclusion_filter.clear
-    ::RSpec.world.send(:instance_variable_set, :@line_numbers, nil)
-  end
-end

data/lib/specjour/rspec/shared_example_group_ext.rb

@@ -1,9 +0,0 @@
-RSpec::Core::SharedExampleGroup.class_eval do
-
-  def ensure_shared_example_group_name_not_taken(name)
-    if RSpec.world.shared_example_groups.has_key?(name)
-      Specjour.logger.debug "Shared example group '#{name}' already exists"
-    end
-  end
-
-end

data/lib/specjour/rspec.rb

@@ -1,17 +0,0 @@
-module Specjour
-  module RSpec
-    require 'rspec/core'
-    require 'rspec/core/formatters/progress_formatter'
-
-    require 'specjour/rspec/marshalable_exception'
-    require 'specjour/rspec/preloader'
-    require 'specjour/rspec/distributed_formatter'
-    require 'specjour/rspec/final_report'
-    require 'specjour/rspec/runner'
-    require 'specjour/rspec/shared_example_group_ext'
-
-    ::RSpec::Core::Runner.disable_autorun!
-    ::RSpec::Core::Runner.class_eval "def self.trap_interrupt;end"
-    ::RSpec.class_eval "def self.reset; world.reset; configuration.reset; end"
-  end
-end