specjour 0.4.1 → 0.5.0

data/lib/specjour/loader.rb

@@ -0,0 +1,129 @@
+module Specjour
+  class Loader
+    include Protocol
+    include Fork
+
+    attr_reader :test_paths, :printer_uri, :project_path, :task, :worker_size, :worker_pids, :quiet
+
+    def initialize(options = {})
+      @options = options
+      @printer_uri = options[:printer_uri]
+      @test_paths = options[:test_paths]
+      @worker_size = options[:worker_size]
+      @task = options[:task]
+      @quiet = options[:quiet]
+      @project_path = options[:project_path]
+      @worker_pids = []
+      Dir.chdir project_path
+      Specjour.load_custom_hooks
+    end
+
+    def start
+      load_app
+      Configuration.after_load.call
+      (1..worker_size).each do |index|
+        worker_pids << fork do
+          w = Worker.new(
+            :number => index,
+            :printer_uri => printer_uri,
+            :quiet => quiet
+          ).send(task)
+        end
+      end
+      Process.waitall
+    ensure
+      kill_worker_processes
+    end
+
+    def spec_files
+      @spec_files ||= file_collector(spec_paths) do |path|
+        if path == project_path
+          Dir["#{path}/spec/**/*_spec.rb"]
+        else
+          Dir["#{path}/**/*_spec.rb"]
+        end
+      end
+    end
+
+    def feature_files
+      @feature_files ||= file_collector(feature_paths) do |path|
+        if path == project_path
+          Dir["#{path}/features/**/*.feature"]
+        else
+          Dir["#{path}/**/*.feature"]
+        end
+      end
+    end
+
+    protected
+
+    def spec_paths
+      @spec_paths ||= test_paths.select {|p| p =~ /spec.*$/}
+    end
+
+    def feature_paths
+      @feature_paths ||= test_paths.select {|p| p =~ /features.*$/}
+    end
+
+    def file_collector(paths, &globber)
+      if spec_paths.empty? && feature_paths.empty?
+        globber[project_path]
+      else
+        paths.map do |path|
+          path = File.expand_path(path, project_path)
+          if File.directory?(path)
+            globber[path]
+          else
+            path
+          end
+        end.flatten.uniq
+      end
+    end
+
+    def load_app
+      share_examples if spec_files.any?
+      share_features if feature_files.any?
+    end
+
+    def share_examples
+      RSpec::Preloader.load spec_files
+      connection.send_message :tests=, filtered_examples
+    ensure
+      ::RSpec.reset
+    end
+
+    def share_features
+      Cucumber::Preloader.load
+      connection.send_message :tests=, feature_files
+    end
+
+    def filtered_examples
+      ::RSpec.world.example_groups.map do |g|
+        g.descendants.map do |gs|
+          gs.examples
+        end.flatten.map do |e|
+          "#{e.file_path}:#{e.metadata[:line_number]}"
+        end
+      end.flatten.uniq
+    end
+
+    def kill_worker_processes
+      if Specjour.interrupted?
+        Process.kill('INT', *worker_pids) rescue Errno::ESRCH
+      else
+        Process.kill('TERM', *worker_pids) rescue Errno::ESRCH
+      end
+    end
+
+    def connection
+      @connection ||= begin
+        at_exit { connection.disconnect }
+        printer_connection
+      end
+    end
+
+    def printer_connection
+      Connection.new URI.parse(printer_uri)
+    end
+  end
+end

data/lib/specjour/manager.rb

@@ -1,20 +1,18 @@
 module Specjour
   class Manager
     require 'dnssd'
-    require 'specjour/rspec'
-    require 'specjour/cucumber'
 
     include DRbUndumped
     include SocketHelper
+    include Fork
 
-    attr_accessor :project_name, :preload_spec, :preload_feature, :worker_task, :pid
-    attr_reader :worker_size, :dispatcher_uri, :registered_projects, :worker_pids, :options
+    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 = QuietFork.fork { manager.start }
-      sleep 0.2
+      manager.pid = Fork.fork_quietly { manager.start }
       manager
     end
 
@@ -23,8 +21,8 @@ module Specjour
       @worker_size = options[:worker_size]
       @worker_task = options[:worker_task]
       @registered_projects = options[:registered_projects]
-      @worker_pids = []
-      at_exit { kill_worker_processes }
+      @rsync_port = options[:rsync_port]
+      at_exit { kill_loader_process }
     end
 
     def available_for?(project_name)
@@ -39,8 +37,10 @@ module Specjour
     def dispatch
       suspend_bonjour do
         sync
-        execute_before_fork
-        dispatch_workers
+        with_clean_env do
+          execute_before_fork
+          dispatch_loader
+        end
       end
     end
 
@@ -57,14 +57,21 @@ module Specjour
       end
     end
 
-    def dispatch_workers
-      worker_pids.clear
-      (1..worker_size).each do |index|
-        worker_pids << fork do
-          exec "specjour work #{worker_options(index)}"
-        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?
+        exec_ruby = "Specjour::CLI.start(#{exec_cmd.split(' ').inspect})"
+        load_path = ''
+        $LOAD_PATH.each {|p| load_path << "-I#{p} " if p =~ /specjour/}
+        exec_cmd = "ruby #{load_path} -rspecjour -e '#{exec_ruby}'"
+        exec exec_cmd
       end
       Process.waitall
+    ensure
+      kill_loader_process
     end
 
     def in_project(&block)
@@ -73,13 +80,14 @@ module Specjour
 
     def interrupted=(bool)
       Specjour.interrupted = bool
+      kill_loader_process
     end
 
-    def kill_worker_processes
+    def kill_loader_process
       if Specjour.interrupted?
-        Process.kill('INT', *worker_pids) rescue Errno::ESRCH
+        Process.kill('INT', loader_pid) rescue Errno::ESRCH
       else
-        Process.kill('TERM', *worker_pids) rescue Errno::ESRCH
+        Process.kill('TERM', loader_pid) rescue Errno::ESRCH
       end
     end
 
@@ -93,9 +101,8 @@ module Specjour
 
     def start
       drb_start
-      puts "Workers ready: #{worker_size}."
-      puts "Listening for #{registered_projects.join(', ')}"
       bonjour_announce
+      at_exit { stop_bonjour }
       DRb.thread.join
     end
 
@@ -104,16 +111,20 @@ module Specjour
     end
 
     def sync
-      unless cmd "rsync -aL --delete --port=8989 #{dispatcher_uri.host}::#{project_name} #{project_path}"
-        raise Error, "Rsync Failed."
-      end
+      cmd "rsync -aL --delete --ignore-errors --port=#{rsync_port} #{dispatcher_uri.host}::#{project_name} #{project_path}"
+      puts "rsync complete"
     end
 
     protected
 
     def bonjour_announce
+      projects = registered_projects.join(", ")
+      puts "Workers ready: #{worker_size}"
+      puts "Listening for #{projects}"
       unless quiet?
-        bonjour_service.register "specjour_manager_#{object_id}", "_#{drb_uri.scheme}._tcp", nil, drb_uri.port
+        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
 
@@ -134,7 +145,7 @@ module Specjour
     end
 
     def stop_bonjour
-      bonjour_service.stop
+      bonjour_service.stop if bonjour_service && !bonjour_service.stopped?
       @bonjour_service = nil
     end
 
@@ -144,13 +155,18 @@ module Specjour
       bonjour_announce
     end
 
-    def worker_options(index)
-      exec_options = "--project-path #{project_path} --printer-uri #{dispatcher_uri} --number #{index} --task #{worker_task}"
-      exec_options << " --preload-spec #{preload_spec}" if preload_spec
-      exec_options << " --preload-feature #{preload_feature}" if preload_feature
-      exec_options << " --log" if Specjour.log?
-      exec_options << " --quiet" if quiet?
-      exec_options
+    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/printer.rb

@@ -1,52 +1,78 @@
 module Specjour
-  require 'specjour/rspec'
-  require 'specjour/cucumber'
 
-  class Printer < GServer
+  class Printer
     include Protocol
     RANDOM_PORT = 0
 
-    def self.start(specs_to_run)
-      new(specs_to_run).start
-    end
-
-    attr_accessor :worker_size, :specs_to_run, :completed_workers, :disconnections, :profiler
+    attr_reader :port, :clients
+    attr_accessor :tests_to_run, :example_size, :examples_complete, :profiler
 
-    def initialize(specs_to_run)
-      super(
-        port = RANDOM_PORT,
-        host = "0.0.0.0",
-        max_connections = 100,
-        stdlog = $stderr,
-        audit = true,
-        debug = true
-      )
-      @completed_workers = 0
-      @disconnections = 0
+    def initialize
+      @host = "0.0.0.0"
+      @server_socket = TCPServer.new(@host, RANDOM_PORT)
+      @port = @server_socket.addr[1]
       @profiler = {}
-      self.specs_to_run = run_order(specs_to_run)
+      @clients = {}
+      @tests_to_run = []
+      @example_size = 0
+      self.examples_complete = 0
+    end
+
+    def start
+      fds = [@server_socket]
+      catch(:stop) do
+        while true
+          reads = select(fds).first
+          reads.each do |socket_being_read|
+            if socket_being_read == @server_socket
+              client_socket = @server_socket.accept
+              fds << client_socket
+              clients[client_socket] = Connection.wrap(client_socket)
+            elsif socket_being_read.eof?
+              socket_being_read.close
+              fds.delete(socket_being_read)
+              clients.delete(socket_being_read)
+              disconnecting
+            else
+              serve(clients[socket_being_read])
+            end
+          end
+        end
+      end
+    ensure
+      stopping
+      fds.each {|c| c.close}
+    end
+
+    def exit_status
+      reporters.all? {|r| r.exit_status == true}
     end
 
+    protected
+
     def serve(client)
-      client = Connection.wrap client
-      client.each(TERMINATOR) do |data|
-        process load_object(data), client
+      data = load_object(client.gets(TERMINATOR))
+      case data
+      when String
+        $stdout.print data
+        $stdout.flush
+      when Array
+        send data.first, *(data[1..-1].unshift(client))
       end
     end
 
     def ready(client)
-      synchronize do
-        client.print specs_to_run.shift
-        client.flush
-      end
+      client.print tests_to_run.shift
+      client.flush
     end
 
     def done(client)
-      self.completed_workers += 1
+      self.examples_complete += 1
     end
 
-    def exit_status
-      reporters.all? {|r| r.exit_status == true}
+    def tests=(client, tests)
+      self.tests_to_run = run_order(tests_to_run | tests)
+      self.example_size = tests_to_run.size
     end
 
     def rspec_summary=(client, summary)
@@ -62,39 +88,18 @@ module Specjour
       self.profiler[test] = time
     end
 
-    protected
-
-    def disconnecting(client_port)
-      synchronize { self.disconnections += 1 }
-      if disconnections == worker_size
-        shutdown
-        stop unless Specjour.interrupted?
-      end
-    end
-
-    def log(msg)
-      # noop
-    end
-
-    def error(exception)
-      Specjour.logger.debug "#{exception.inspect}\n#{exception.backtrace.join("\n")}"
-    end
-
-    def process(message, client)
-      if message.is_a?(String)
-        $stdout.print message
-        $stdout.flush
-      elsif message.is_a?(Array)
-        send(message.first, client, *message[1..-1])
+    def disconnecting
+      if (examples_complete == example_size || clients.empty?)
+        throw(:stop)
       end
     end
 
-    def run_order(specs_to_run)
+    def run_order(tests)
       if File.exist?('.specjour/performance')
-        ordered_specs = File.readlines('.specjour/performance').map {|l| l.chop.split(':')[1]}
-        (specs_to_run - ordered_specs) | (ordered_specs & specs_to_run)
+        ordered_tests = File.readlines('.specjour/performance').map {|l| l.chop.split(':', 2)[1]}
+        (tests - ordered_tests) | (ordered_tests & tests)
       else
-        specs_to_run
+        tests
       end
     end
 
@@ -120,29 +125,21 @@ module Specjour
 
     def stopping
       summarize_reports
-      warn_if_workers_deserted
       record_performance unless Specjour.interrupted?
+      print_missing_tests if tests_to_run.any?
     end
 
     def summarize_reports
       reporters.each {|r| r.summarize}
     end
 
-    def synchronize(&block)
-      @connectionsMutex.synchronize &block
+    def print_missing_tests
+      puts "*" * 60
+      puts "Oops! The following tests were not run:"
+      puts "*" * 60
+      puts tests_to_run
+      puts "*" * 60
     end
 
-    def warn_if_workers_deserted
-      if disconnections != completed_workers && !Specjour.interrupted?
-        puts
-        puts workers_deserted_message
-      end
-    end
-
-    def workers_deserted_message
-      data = "* ERROR: NOT ALL WORKERS COMPLETED PROPERLY *"
-      filler = "*" * data.size
-      [filler, data, filler].join "\n"
-    end
   end
 end

data/lib/specjour/rspec/distributed_formatter.rb

@@ -31,7 +31,7 @@ module Specjour::RSpec
     end
 
     def close
-      @examples = []
+      examples.clear
       super
     end
 

data/lib/specjour/rspec/final_report.rb

@@ -42,11 +42,11 @@ module Specjour::RSpec
     end
 
     def pending_examples
-      ::RSpec.world.find(examples, :execution_result => { :status => 'pending' })
+      examples.select {|e| e.execution_result[:status] == 'pending'}
     end
 
     def failed_examples
-      ::RSpec.world.find(examples, :execution_result => { :status => 'failed' })
+      examples.select {|e| e.execution_result[:status] == 'failed'}
     end
 
     def formatter

data/lib/specjour/rspec/marshalable_exception.rb

@@ -11,5 +11,9 @@ module Specjour::RSpec
     def class
       @class ||= OpenStruct.new :name => class_name
     end
+
+    def pending_fixed?
+      false
+    end
   end
 end

data/lib/specjour/rspec/preloader.rb

@@ -1,8 +1,13 @@
 class Specjour::RSpec::Preloader
-  def self.load(spec_file)
-    $LOAD_PATH.unshift File.join(Dir.pwd, 'spec')
-    require spec_file
-  ensure
-    $LOAD_PATH.shift
+  def self.load(paths=[])
+    require './spec/spec_helper'
+    load_spec_files paths
+  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,12 +1,13 @@
 module Specjour::RSpec::Runner
+  ::RSpec::Core::Runner::AT_EXIT_HOOK_BACKTRACE_LINE.replace "#{__FILE__}:#{__LINE__ + 3}:in `run'"
   def self.run(spec, output)
-    reset
     args = ['--format=Specjour::RSpec::DistributedFormatter', spec]
-    ::RSpec::Core::Runner.run_in_process args, $stderr, output
-  end
-
-  def self.reset
-    ::RSpec.world.instance_variable_set(:@example_groups, [])
-    ::RSpec.configuration.instance_variable_set(:@formatter, nil)
+    ::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.rb

@@ -11,11 +11,6 @@ module Specjour
     require 'specjour/rspec/shared_example_group_ext'
 
     ::RSpec::Core::Runner.disable_autorun!
-
-    def self.wants_to_quit
-      if defined?(::RSpec) && ::RSpec.respond_to?(:wants_to_quit=)
-        ::RSpec.wants_to_quit = true
-      end
-    end
+    ::RSpec::Core::Runner.class_eval "def self.trap_interrupt;end"
   end
 end

data/lib/specjour/rsync_daemon.rb

@@ -5,15 +5,16 @@ module Specjour
 
     # Corresponds to the version of specjour that changed the configuration
     # file.
-    CONFIG_VERSION = "0.3.0.rc8".freeze
+    CONFIG_VERSION = "0.5.0".freeze
     CONFIG_FILE_NAME = "rsyncd.conf"
     PID_FILE_NAME = "rsyncd.pid"
 
-    attr_reader :project_path, :project_name
+    attr_reader :project_path, :project_name, :port
 
-    def initialize(project_path, project_name)
+    def initialize(project_path, project_name, port)
       @project_path = project_path
       @project_name = project_name
+      @port = port
     end
 
     def config_directory
@@ -35,11 +36,12 @@ module Specjour
     end
 
     def start
+      Kernel.at_exit { stop }
       write_config
       Dir.chdir(project_path) do
         Kernel.system *command
+        sleep 0.1
       end
-      Kernel.at_exit { stop }
     end
 
     def stop
@@ -52,7 +54,7 @@ module Specjour
     protected
 
     def command
-      ["rsync", "--daemon", "--config=#{config_file}", "--port=8989"]
+      ["rsync", "--daemon", "--config=#{config_file}", "--port=#{port}"]
     end
 
     def check_config_version
@@ -92,7 +94,7 @@ remove it, and re-run the dispatcher to generate the new config file.
 # $ #{(command | ['--no-detach']).join(' ')}
 #
 # Rsync with the following command:
-# $ rsync -a --port=8989 #{hostname}::#{project_name} /tmp/#{project_name}
+# $ rsync -a --port=#{port} #{hostname}::#{project_name} /tmp/#{project_name}
 #
 use chroot = no
 timeout = 20
@@ -101,7 +103,8 @@ pid file = ./.specjour/#{PID_FILE_NAME}
 
 [#{project_name}]
   path = .
-  exclude = .git* .specjour/rsync* doc tmp/* log
+  include = tmp/cache/
+  exclude = .git* .specjour/rsync* doc/* tmp/* log/*
       CONFIG
     end
   end