specjour 0.7.0 → 2.0.0.rc1

data/lib/specjour/printer.rb

@@ -1,82 +1,243 @@
 module Specjour
-
   class Printer
-    include Protocol
-    RANDOM_PORT = 0
+    require 'dnssd'
+
+    include Logger
+    include SocketHelper
 
-    attr_reader :port, :clients
-    attr_accessor :tests_to_run, :example_size, :examples_complete, :profiler
+    attr_reader :host, :port, :clients
+    attr_accessor :tests_to_run, :test_paths, :example_size, :examples_complete, :profiler, :machines
 
-    def initialize
+    Thread.abort_on_exception = true
+
+    def initialize(options={})
+      @options = options
       @host = "0.0.0.0"
-      @server_socket = TCPServer.new(@host, RANDOM_PORT)
-      @port = @server_socket.addr[1]
       @profiler = {}
       @clients = {}
       @tests_to_run = []
+      @test_paths = options[:test_paths]
       @example_size = 0
+      @machines = []
+      @send_threads = []
+      @bonjour_service = nil
+      @mutex = Mutex.new
+      @running = false
+      @output = options[:output] || $stdout
+      @loader_clients = []
       self.examples_complete = 0
+      set_paths
+      Specjour.configuration.printer_port ||= SocketHelper.new_uri.port
+    end
+
+    def set_paths
+      paths = test_paths.map {|tp| Pathname.new(tp).expand_path}
+      if paths.any?
+        paths.each do |p|
+          pn = Pathname.new(p)
+          abort("Request test path: #{p} does not exist") unless pn.exist?
+        end
+        @project_path = Pathname.new(find_project_base_dir(paths.first.to_s))
+      else
+        @project_path = Pathname.new(Dir.pwd)
+      end
+      if paths.size == 1 and paths.first == project_path
+        @test_paths = []
+      else
+        @test_paths = paths
+      end
+      @test_paths = @test_paths.map do |path|
+        test_path = path.relative_path_from(project_path)
+        abort("Test path #{test_path} doesn't exist") unless test_path.exist?
+        test_path.to_s
+      end
+      if !project_path.exist?
+        abort("Project path #{project_path} doesn't exist")
+      end
+    end
+
+    def announce
+      @output.puts("Looking for listeners...")
+      text = DNSSD::TextRecord.new
+      text['version'] = Specjour::VERSION
+      text['project_alias'] = Specjour.configuration.project_aliases.first
+      @bonjour_service = DNSSD.register "#{hostname}".tr(".","-"), "_specjour._tcp", domain=nil, Specjour.configuration.printer_port, text
+    end
+
+    def start_rsync
+      rsync_daemon.start
+    end
+
+    def rsync_daemon
+      @rsync_daemon ||= RsyncDaemon.new(project_path.to_s, project_name, Specjour.configuration.rsync_port)
+    end
+
+    def running?
+      @mutex.synchronize do
+        @running
+      end
     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
+      @running = true
+      @server_socket ||= TCPServer.new(@host, Specjour.configuration.printer_port)
+      debug "server socket #{@host}:#{Specjour.configuration.printer_port}"
+      done_reader, @done_writer = IO.pipe
+      while running? do
+        debug "loop going to select #{running?}"
+        result = select([@server_socket, done_reader], [], [])
+        reads = result.first
+        reads.each do |socket_being_read|
+          if socket_being_read == @server_socket
+            debug "adding connection"
+            client_socket = @server_socket.accept
+            client_socket = Connection.wrap(client_socket)
+            @send_threads << Thread.new(client_socket) { |sock| serve(sock) }
+          elsif socket_being_read == @done_writer
+            debug "breaking on done socket"
+            break
           end
         end
       end
+      done_reader.close
+      @done_writer.close
+    rescue => error
+      $stderr.puts "Server got an error #{error.inspect} #{error.backtrace.join("\n")}"
     ensure
+      @loader_clients.each do |client|
+        if Specjour.interrupted?
+          client.send_server_done("INT")
+        else
+          client.send_server_done("TERM")
+        end
+      end
+      @server_socket.close
       stopping
-      fds.each {|c| c.close}
+      exit exit_status
     end
 
     def exit_status
-      reporters.all? {|r| r.exit_status == true}
+      if Specjour.interrupted?
+        2
+      else
+        statuses = Specjour.plugin_manager.send_task(:exit_status, Specjour.configuration.formatter)
+        plugin_status = statuses.detect {|s| !s.nil?}
+        plugin_status.nil? ? Specjour.configuration.formatter.exit_status : plugin_status
+      end
+    end
+
+    def uri
+      @uri ||= URI::Generic.build host: host, port: port
+    end
+
+    def project_name
+      options[:project_alias] || project_path.basename.to_s
+    end
+
+    def project_path
+      @project_path
     end
 
     protected
 
     def serve(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))
+      debug "serving #{client.inspect}"
+      loop do
+        if client.eof?
+          debug "client eof"
+          client.disconnect
+          disconnecting
+          break
+        end
+        debug "socket about to read data #{client.inspect}"
+        data = client.recv_data
+        command = data[:command]
+        case command
+        when "add_to_profiler"
+          add_to_profiler(*data[:args])
+        when "done"
+          done(*data[:args])
+        when "next_test"
+          client.send_data next_test(*data[:args])
+        when "ready"
+          @mutex.synchronize do
+            @loader_clients |= [client]
+          end
+          client.send_data ready(*data[:args])
+        when "register_tests"
+          register_tests(*data[:args])
+        when "report_test"
+          report_test(*data[:args])
+        when "error"
+          unexpected_error(*data[:args])
+        else
+          raise Error.new("COMMAND NOT FOUND: #{command}")
+        end
+        IO.select([client.socket])
+      end
+    end
+
+    def done
+      @mutex.synchronize do
+        self.examples_complete += 1
+      end
+    end
+
+    def next_test
+      @mutex.synchronize do
+        log "test size: #{tests_to_run.size}"
+        if tests_to_run.size == example_size
+          Specjour.configuration.formatter.start_time = Specjour::Time.now
+        end
+        tests_to_run.shift
+      end
+    end
+
+    def ready(info)
+      @output.puts "Found #{info[:hostname]}(#{info[:worker_size]})"
+      {
+        project_name: project_name,
+        project_path: project_path.to_s,
+        test_paths: test_paths
+      }
+    end
+
+    def register_tests(tests)
+      @mutex.synchronize do
+        if example_size == 0
+          self.tests_to_run = run_order(tests)
+          self.example_size = tests_to_run.size
+        end
       end
     end
 
-    def ready(client)
-      client.print tests_to_run.shift
-      client.flush
+    def report_test(test)
+      @mutex.synchronize do
+        Specjour.configuration.formatter.report_test(test)
+      end
     end
 
-    def done(client)
-      self.examples_complete += 1
+    def unexpected_error(message)
+      @output.puts message
     end
 
-    def tests=(client, tests)
-      if tests_to_run.empty?
-        self.tests_to_run = run_order(tests)
-        self.example_size = tests_to_run.size
+    def find_project_base_dir(directory)
+      dirs = Dir["#{directory}/Rakefile"]
+      if dirs.any?
+        File.dirname dirs.first
+      else
+        find_project_base_dir(File.dirname(directory))
       end
     end
 
+    def options
+      {}
+    end
+
+    def machines=(client, machines)
+      @machines = machines
+    end
+
     def rspec_summary=(client, summary)
       rspec_report.add(summary)
     end
@@ -85,23 +246,30 @@ module Specjour
       cucumber_report.add(summary)
     end
 
-    def add_to_profiler(client, args)
-      test, time = *args
-      self.profiler[test] = time
+    def add_to_profiler(test, time, host)
+      @mutex.synchronize do
+        self.profiler[test] = [time, host]
+      end
     end
 
     def disconnecting
-      if clients.empty?
-        throw(:stop)
+      @mutex.synchronize do
+        debug "DISCONNECT #{@running} #{example_size} #{examples_complete}"
+        if @running && examples_complete == example_size
+          @running = false
+          debug "writing done"
+          @done_writer.write("DONE")
+          debug "done with writer"
+        end
       end
     end
 
     def run_order(tests)
       if File.exist?('.specjour/performance')
-        ordered_tests = File.readlines('.specjour/performance').map {|l| l.chop.split(':', 2)[1]}
-        (tests - ordered_tests) | (ordered_tests & tests)
+        ordered_tests = File.readlines('.specjour/performance').map {|l| l.chop.split(':')[1]}
+        ordered_tests & tests | tests
       else
-        tests
+        tests.sort
       end
     end
 
@@ -113,40 +281,40 @@ module Specjour
       @cucumber_report ||= Cucumber::FinalReport.new
     end
 
+    # "test.rb" => [1.12, "host.local[2]"]
     def record_performance
       File.open('.specjour/performance', 'w') do |file|
-        ordered_specs = profiler.to_a.sort_by {|a| -a[1].to_f}.map do |test, time|
-          file.puts "%6f:%s" % [time, test]
+        ordered_specs = profiler.to_a.sort_by {|test, data| -data[0].to_f}.map do |test, data|
+          file.puts "%6f:%s:%s" % [data[0], test, data[1]]
         end
       end
     end
 
-    def reporters
-      [@rspec_report, @cucumber_report].compact
-    end
-
     def stopping
-      summarize_reports
+      Specjour.configuration.formatter.set_end_time!
+      @bonjour_service.stop
+
+      Specjour.plugin_manager.send_task(:before_print_summary, Specjour.configuration.formatter)
+      Specjour.configuration.formatter.print_summary
+
       unless Specjour.interrupted?
         record_performance
         print_missing_tests if missing_tests?
       end
-    end
 
-    def summarize_reports
-      reporters.each {|r| r.summarize}
+      Specjour.plugin_manager.send_task(:after_print_summary, Specjour.configuration.formatter)
     end
 
     def missing_tests?
-      tests_to_run.any? || examples_complete != example_size
+      examples_complete != example_size && tests_to_run.any?
     end
 
     def print_missing_tests
-      puts "*" * 60
-      puts "Oops! The following tests were not run:"
-      puts "*" * 60
-      puts tests_to_run
-      puts "*" * 60
+      @output.puts "*" * 60
+      @output.puts "Oops! The following tests were not run:"
+      @output.puts "*" * 60
+      @output.puts tests_to_run
+      @output.puts "*" * 60
     end
 
   end

data/lib/specjour/protocol.rb

@@ -1,14 +1,21 @@
 module Specjour
   module Protocol
-    TERMINATOR = "|ruojceps|"
-    TERMINATOR_REGEXP = /#{TERMINATOR}$/
+    require 'json'
 
-    def dump_object(data)
-      Marshal.dump(data) << TERMINATOR
+    def recv_data
+      bytes = socket.gets.to_i
+      string = socket.read(bytes)
+      debug "recv_string #{bytes} #{string.inspect} #{socket.inspect}"
+      if !string.empty?
+        Marshal.load(string)
+      end
     end
 
-    def load_object(data)
-      Marshal.load(data.sub(TERMINATOR_REGEXP, ''))
+    def send_data(data)
+      mdata = Marshal.dump(data)
+      debug "send_data: #{mdata.bytesize} #{mdata.inspect} #{socket.inspect}"
+      socket.puts  mdata.bytesize
+      socket.write mdata
     end
   end
 end

data/lib/specjour/rspec_formatter.rb

@@ -0,0 +1,17 @@
+module Specjour
+  require 'rspec/core/formatters/json_formatter'
+
+  class RspecFormatter < ::RSpec::Core::Formatters::JsonFormatter
+    def hostname
+      @hostname ||= Socket.gethostname
+    end
+
+    def close(_notification=nil)
+      @output_hash[:examples].each do |e|
+        e[:hostname] = hostname
+        e[:worker_number] = ENV["TEST_ENV_NUMBER"]
+        @output.report_test(e)
+      end
+    end
+  end
+end

data/lib/specjour/rsync_daemon.rb

@@ -2,6 +2,7 @@ module Specjour
   class RsyncDaemon
     require 'fileutils'
     include SocketHelper
+    include Logger
 
     # Corresponds to the version of specjour that changed the configuration
     # file.
@@ -40,13 +41,15 @@ module Specjour
       write_config
       Dir.chdir(project_path) do
         Kernel.system *command
+        rsync_pid = $?.pid
         sleep 0.1
       end
     end
 
     def stop
-      if pid
-        Process.kill("KILL", pid)
+      if process_id = pid
+        log("#{self.class.name} Shutting down")
+        Process.kill("KILL", process_id) rescue nil
         FileUtils.rm(pid_file)
       end
     end
@@ -94,7 +97,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=#{port} #{hostname}::#{project_name} /tmp/#{project_name}
+# $ rsync -a --port=#{port} #{hostname}::#{project_name} #{Specjour.configuration.tmp_path}/#{project_name}
 #
 use chroot = no
 timeout = 20

data/lib/specjour/socket_helper.rb

@@ -2,6 +2,28 @@ module Specjour
   module SocketHelper
     Socket.do_not_reverse_lookup = true
 
+    def connection
+      return @connection if connection?
+      @connection = Connection.new Specjour.configuration.printer_uri
+      @connection.connect
+      @connection
+    end
+
+    def connection?
+      !@connection.nil?
+    end
+
+    def remove_connection
+      connection.disconnect if connection?
+      @connection = nil
+    end
+
+    module_function
+
+    def new_uri
+      URI::Generic.build :host => faux_server[2], :port => faux_server[1]
+    end
+
     def ip_from_hostname(hostname)
       Socket.getaddrinfo(hostname, nil, Socket::AF_INET, Socket::SOCK_STREAM).first.fetch(3)
     rescue SocketError
@@ -9,23 +31,17 @@ module Specjour
     end
 
     def hostname
-      @hostname ||= Socket.gethostname
+      Socket.gethostname
     end
 
     def local_ip
-      @local_ip ||= UDPSocket.open {|s| s.connect('74.125.224.103', 1); s.addr.last }
-    end
-
-    def current_uri
-      @current_uri ||= new_uri
+      UDPSocket.open {|s| s.connect('74.125.224.103', 1); s.addr.last }
     end
 
-    def new_uri
-      URI::Generic.build :host => faux_server[2], :port => faux_server[1]
+    def remote_ip?(ip)
+      Socket.ip_address_list.detect {|a| a.ip_address == ip}.nil?
     end
 
-    protected
-
     def faux_server
       server = TCPServer.new('0.0.0.0', nil)
       server.addr

data/lib/specjour/worker.rb

@@ -1,99 +1,73 @@
 module Specjour
 
   class Worker
+    include Logger
     include Protocol
     include SocketHelper
-    attr_accessor :printer_uri
-    attr_reader :number
+    attr_reader :number, :options
 
     def initialize(options = {})
+      Specjour.trap_interrupt_with_exit
       ARGV.replace []
-      $stdout = StringIO.new if options[:quiet]
+      @options = options
       @number = options[:number].to_i
-      self.printer_uri = options[:printer_uri]
-      set_env_variables
-      Specjour.load_custom_hooks
-    end
-
-    def printer_uri=(val)
-      @printer_uri = URI.parse(val)
+      Specjour.configuration.worker_number = number
+      ENV['TEST_ENV_NUMBER'] = Specjour.configuration.worker_number.to_s
     end
 
     def prepare
-      Configuration.prepare.call
+      Specjour.configuration.prepare.call
     end
 
     def run_tests
-      Configuration.after_fork.call
-      run_times = Hash.new(0)
+      log "Worker running tests"
+
+      Specjour.plugin_manager.send_task(:before_suite)
 
       while test = connection.next_test
         print_status(test)
-        time = Benchmark.realtime { run_test test }
+        time = Benchmark.realtime do
+          Specjour.plugin_manager.send_task(:run_test, test)
+        end
         profile(test, time)
-        run_times[test_type(test)] += time
-        connection.send_message(:done)
+        connection.done
       end
 
-      send_run_times(run_times)
+      Specjour.plugin_manager.send_task(:after_suite)
+
+    rescue StandardError, ScriptError => e
+      $stderr.puts "RESCUED #{e.message}"
+      $stderr.puts e.backtrace
+      connection.error(e)
     ensure
-      connection.disconnect
+      remove_connection
+      log "Worker disconnecting #{Process.pid}"
+      r = IO.popen("ps -eo pid,ppid,command | grep #{Process.pid}")
+      r.each_line do |line|
+        pid, ppid = line.split(" ")
+        pid = pid.to_i
+        ppid = ppid.to_i
+        if ppid == Process.pid && pid != r.pid
+          Process.kill("KILL", pid)
+        end
+      end
     end
 
     protected
 
-    def connection
-      @connection ||= printer_connection
-    end
-
-    def printer_connection
-      Connection.new printer_uri
-    end
-
     def print_status(test)
-      status = "[#{ENV['TEST_ENV_NUMBER']}] Running #{test}"
-      $stdout.puts status
-      $PROGRAM_NAME = "specjour#{status}"
+      status = "Running #{test}"
+      log status
+      $PROGRAM_NAME = "specjour #{status}"
     end
 
     def print_time_for(test, time)
-      printf "[#{ENV['TEST_ENV_NUMBER']}] Finished #{test} in %.2fs\n", time
+      log sprintf("Finished #{test} in %.2fs\n", time)
     end
 
     def profile(test, time)
-      connection.send_message(:add_to_profiler, [test, time])
+      connection.add_to_profiler(test, time, "#{hostname}[#{ENV["TEST_ENV_NUMBER"]}]")
       print_time_for(test, time)
     end
-
-    def run_test(test)
-      if test_type(test) == :cucumber
-        run_feature test
-      else
-        run_spec test
-      end
-    end
-
-    def run_feature(feature)
-      Cucumber::Runner.run(feature)
-    end
-
-    def run_spec(spec)
-      RSpec::Runner.run(spec, connection)
-    end
-
-    def send_run_times(run_times)
-      [:rspec, :cucumber].each do |type|
-        connection.send_message(:"#{type}_summary=", {:duration => sprintf("%6f", run_times[type])}) if run_times[type] > 0
-      end
-    end
-
-    def test_type(test)
-      test =~ /\.feature(:\d+)?$/ ? :cucumber : :rspec
-    end
-
-    def set_env_variables
-      ENV['RSPEC_COLOR'] ||= 'true'
-      ENV['TEST_ENV_NUMBER'] ||= number.to_s
-    end
   end
 end