JonathanTron-specjour 0.2.5.1

data/lib/specjour/manager.rb

@@ -0,0 +1,101 @@
+module Specjour
+  class Manager
+    require 'dnssd'
+    include DRbUndumped
+    include SocketHelpers
+
+    attr_accessor :project_name, :specs_to_run
+    attr_reader :worker_size, :batch_size, :dispatcher_uri, :registered_projects, :bonjour_service, :worker_pids
+
+    def initialize(options = {})
+      @worker_size = options[:worker_size]
+      @batch_size = options[:batch_size]
+      @registered_projects = options[:registered_projects]
+      @worker_pids = []
+    end
+
+    def available_for?(project_name)
+      registered_projects ? registered_projects.include?(project_name) : true
+   end
+
+    def bundle_install
+      Dir.chdir(project_path) do
+        unless system('bundle check > /dev/null')
+          system("bundle install --relock > /dev/null")
+        end
+      end
+    end
+
+    def dispatcher_uri=(uri)
+      uri.host = ip_from_hostname(uri.host)
+      @dispatcher_uri = uri
+    end
+
+    def kill_worker_processes
+      Process.kill('TERM', *worker_pids) rescue nil
+    end
+
+    def project_path
+      File.join("/tmp", project_name)
+    end
+
+    def dispatch
+      suspend_bonjour do
+        sync
+        bundle_install
+        dispatch_workers
+      end
+    end
+
+    def dispatch_workers
+      GC.copy_on_write_friendly = true if GC.respond_to?(:copy_on_write_friendly=)
+      (1..worker_size).each do |index|
+        worker_pids << fork do
+          exec("specjour --batch-size #{batch_size} #{'--log' if Specjour.log?} --do-work #{project_path},#{dispatcher_uri},#{index}")
+          Kernel.exit!
+        end
+      end
+      at_exit { kill_worker_processes }
+      Process.waitall
+    end
+
+    def start
+      drb_start
+      puts "Workers ready: #{worker_size}"
+      bonjour_announce
+      Signal.trap('INT') { puts; puts "Shutting down manager..."; exit }
+      DRb.thread.join
+    end
+
+    def drb_start
+      DRb.start_service nil, self
+      puts "Manager started at #{drb_uri}"
+      at_exit { DRb.stop_service }
+    end
+
+    def sync
+      cmd "rsync -aL --delete --port=8989 #{dispatcher_uri.host}::#{project_name} #{project_path}"
+    end
+
+    protected
+
+    def bonjour_announce
+      @bonjour_service = DNSSD.register! "specjour_manager_#{object_id}", "_#{drb_uri.scheme}._tcp", nil, drb_uri.port
+    end
+
+    def cmd(command)
+      puts command
+      system command
+    end
+
+    def drb_uri
+      @drb_uri ||= URI.parse(DRb.uri)
+    end
+
+    def suspend_bonjour(&block)
+      bonjour_service.stop
+      block.call
+      bonjour_announce
+    end
+  end
+end

data/lib/specjour/printer.rb

@@ -0,0 +1,102 @@
+module Specjour
+  require 'specjour/rspec'
+
+  class Printer < GServer
+    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
+
+    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
+      self.specs_to_run = specs_to_run
+    end
+
+    def serve(client)
+      client = Connection.wrap client
+      client.each(TERMINATOR) do |data|
+        process load_object(data), client
+      end
+    end
+
+    def ready(client)
+      synchronize do
+        client.print specs_to_run.shift
+        client.flush
+      end
+    end
+
+    def done(client)
+      self.completed_workers += 1
+    end
+
+    def exit_status
+      report.exit_status
+    end
+
+    def worker_summary=(client, summary)
+      report.add(summary)
+    end
+
+    protected
+
+    def disconnecting(client_port)
+      self.disconnections += 1
+      if disconnections == worker_size
+        shutdown
+        stop unless stopped?
+      end
+    end
+
+    def log(msg)
+      # noop
+    end
+
+    def error(exception)
+      Specjour.logger.debug exception.inspect
+    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])
+      end
+    end
+
+    def report
+      @report ||= Rspec::FinalReport.new
+    end
+
+    def stopping
+      report.summarize
+      if disconnections != completed_workers && !Specjour::Dispatcher.interrupted?
+        puts abandoned_worker_message
+      end
+    end
+
+    def synchronize(&block)
+      @connectionsMutex.synchronize &block
+    end
+
+    def abandoned_worker_message
+      data = "* ERROR: NOT ALL WORKERS COMPLETED PROPERLY *"
+      filler = "*" * data.size
+      [filler, data, filler].join "\n"
+    end
+  end
+end

data/lib/specjour/protocol.rb

@@ -0,0 +1,14 @@
+module Specjour
+  module Protocol
+    TERMINATOR = "|ruojceps|"
+    TERMINATOR_REGEXP = /#{TERMINATOR}$/
+
+    def dump_object(data)
+      Marshal.dump(data) << TERMINATOR
+    end
+
+    def load_object(data)
+      Marshal.load(data.sub(TERMINATOR_REGEXP, ''))
+    end
+  end
+end

data/lib/specjour/rspec.rb

@@ -0,0 +1,9 @@
+module Specjour
+  module Rspec
+    require 'spec'
+    require 'spec/runner/formatter/base_text_formatter'
+
+    require 'specjour/rspec/distributed_formatter'
+    require 'specjour/rspec/final_report'
+  end
+end

data/lib/specjour/rspec/distributed_formatter.rb

@@ -0,0 +1,83 @@
+module Specjour::Rspec
+  class DistributedFormatter < Spec::Runner::Formatter::BaseTextFormatter
+    require 'specjour/rspec/marshalable_rspec_failure'
+
+    class << self
+      attr_accessor :batch_size
+    end
+    @batch_size = 1
+
+    attr_reader :failing_messages, :passing_messages, :pending_messages, :output
+    attr_reader :duration, :example_count, :failure_count, :pending_count, :pending_examples, :failing_examples
+
+    def initialize(options, output)
+      @options = options
+      @output = output
+      @failing_messages = []
+      @passing_messages = []
+      @pending_messages = []
+      @pending_examples = []
+      @failing_examples = []
+    end
+
+    def example_failed(example, counter, failure)
+      failing_messages << colorize_failure('F', failure)
+      batch_print(failing_messages)
+    end
+
+    def example_passed(example)
+      passing_messages << green('.')
+      batch_print(passing_messages)
+    end
+
+    def example_pending(example, message, deprecated_pending_location=nil)
+      super
+      pending_messages << yellow('*')
+      batch_print(pending_messages)
+    end
+
+    def dump_summary(duration, example_count, failure_count, pending_count)
+      @duration = duration
+      @example_count = example_count
+      @failure_count = failure_count
+      @pending_count = pending_count
+      output.send_message(:worker_summary=, to_hash)
+    end
+
+    def dump_pending
+      #noop
+    end
+
+    def dump_failure(counter, failure)
+      failing_examples << failure
+    end
+
+    def start_dump
+      print_and_flush failing_messages
+      print_and_flush passing_messages
+      print_and_flush pending_messages
+    end
+
+    def to_hash
+      h = {}
+      [:duration, :example_count, :failure_count, :pending_count, :pending_examples, :failing_examples].each do |key|
+        h[key] = send(key)
+      end
+      h
+    end
+
+    protected
+
+    def batch_print(messages)
+      if messages.size == self.class.batch_size
+        print_and_flush(messages)
+      end
+    end
+
+    def print_and_flush(messages)
+      output.print messages.to_s
+      output.flush
+      messages.replace []
+    end
+  end
+end

data/lib/specjour/rspec/final_report.rb

@@ -0,0 +1,65 @@
+module Specjour
+  module Rspec
+    class FinalReport
+      attr_reader :duration, :example_count, :failure_count, :pending_count, :pending_examples, :failing_examples
+
+      def initialize
+        @duration = 0.0
+        @example_count = 0
+        @failure_count = 0
+        @pending_count = 0
+        @pending_examples = []
+        @failing_examples = []
+      end
+
+      def add(stats)
+        stats.each do |key, value|
+          if key == :duration
+            @duration = value.to_f if duration < value.to_f
+          else
+            increment(key, value)
+          end
+        end
+      end
+
+      def exit_status
+        failing_examples.empty?
+      end
+
+      def increment(key, value)
+        current = instance_variable_get("@#{key}")
+        instance_variable_set("@#{key}", current + value)
+      end
+
+      def formatter_options
+        @formatter_options ||= OpenStruct.new(
+          :colour   => true,
+          :autospec => false,
+          :dry_run  => false
+        )
+      end
+
+      def formatter
+        @formatter ||= begin
+          f = Spec::Runner::Formatter::BaseTextFormatter.new(formatter_options, $stdout)
+          f.instance_variable_set(:@pending_examples, pending_examples)
+          f
+        end
+      end
+
+      def summarize
+        if example_count > 0
+          formatter.dump_pending
+          dump_failures
+          formatter.dump_summary(duration, example_count, failure_count, pending_count)
+        end
+      end
+
+      def dump_failures
+        failing_examples.each_with_index do |failure, index|
+          formatter.dump_failure index + 1, failure
+        end
+      end
+    end
+  end
+end

data/lib/specjour/rspec/marshalable_rspec_failure.rb

@@ -0,0 +1,35 @@
+module Specjour
+  module Rspec
+    class ::Spec::Runner::Reporter::Failure
+
+      def initialize(group_description, example_description, exception)
+        @example_name = "#{group_description} #{example_description}"
+        @exception = MarshalableException.new(exception)
+        @pending_fixed = exception.is_a?(Spec::Example::PendingExampleFixedError)
+        @exception_not_met = exception.is_a?(Spec::Expectations::ExpectationNotMetError)
+      end
+
+      def pending_fixed?
+        @pending_fixed
+      end
+
+      def expectation_not_met?
+        @exception_not_met
+      end
+    end
+  end
+
+  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
+  end
+end

data/lib/specjour/rsync_daemon.rb

@@ -0,0 +1,108 @@
+module Specjour
+  class RsyncDaemon
+    require 'fileutils'
+    include SocketHelpers
+
+    # Corresponds to the version of specjour that changed the configuration
+    # file.
+    CONFIG_VERSION = "0.2.3".freeze
+    CONFIG_FILE_NAME = "rsyncd.conf"
+    PID_FILE_NAME = "rsyncd.pid"
+
+    attr_reader :project_path, :project_name
+
+    def initialize(project_path, project_name)
+      @project_path = project_path
+      @project_name = project_name
+    end
+
+    def config_directory
+      @config_directory ||= File.join(project_path, ".specjour")
+    end
+
+    def config_file
+      @config_file ||= File.join(config_directory, CONFIG_FILE_NAME)
+    end
+
+    def pid
+      if File.exists?(pid_file)
+        File.read(pid_file).strip.to_i
+      end
+    end
+
+    def pid_file
+      File.join(config_directory, PID_FILE_NAME)
+    end
+
+    def start
+      write_config
+      Dir.chdir(project_path) do
+        Kernel.system *command
+      end
+      Kernel.at_exit { stop }
+    end
+
+    def stop
+      if pid
+        Process.kill("TERM", pid)
+        FileUtils.rm(pid_file)
+      end
+    end
+
+    protected
+
+    def command
+      ["rsync", "--daemon", "--config=#{config_file}", "--port=8989"]
+    end
+
+    def check_config_version
+      File.read(config_file) =~ /\A# (\d+.\d+.\d+)/
+      if out_of_date? Regexp.last_match(1)
+        $stderr.puts <<-WARN
+
+Specjour has made changes to the way #{CONFIG_FILE_NAME} is generated.
+Back up '#{config_file}'
+and re-run the dispatcher to generate the new config file.
+
+        WARN
+      end
+    end
+
+    def out_of_date?(version)
+      CONFIG_VERSION != version
+    end
+
+    def write_config
+      if File.exists? config_file
+        check_config_version
+      else
+        FileUtils.mkdir_p config_directory
+        File.open(config_file, 'w') do |f|
+          f.write config
+        end
+      end
+    end
+
+    def config
+      <<-CONFIG
+# #{CONFIG_VERSION}
+# Rsync daemon config for #{project_name}
+#
+# Serve this project with the following command:
+# $ #{(command | ['--no-detach']).join(' ')}
+#
+# Rsync with the following command:
+# $ rsync -a --port=8989 #{hostname}::#{project_name} /tmp/#{project_name}
+#
+use chroot = no
+timeout = 20
+read only = yes
+pid file = ./.specjour/#{PID_FILE_NAME}
+
+[#{project_name}]
+  path = .
+  exclude = .git* .specjour doc tmp/* log script
+      CONFIG
+    end
+  end
+end