causes-hydra 0.21.0

data/lib/hydra/listener/abstract.rb

@@ -0,0 +1,39 @@
+module Hydra #:nodoc:
+  module Listener #:nodoc:
+    # Abstract listener that implements all the events
+    # but does nothing.
+    class Abstract
+      # Create a new listener.
+      #
+      # Output: The IO object for outputting any information.
+      # Defaults to STDOUT, but you could pass a file in, or STDERR
+      def initialize(output = $stdout)
+        @output = output
+      end
+
+      # Fired when testing has started
+      def testing_begin(files)
+      end
+
+      # Fired when testing finishes, after the workers shutdown
+      def testing_end
+      end
+
+      # Fired after runner processes have been started
+      def worker_begin(worker)
+      end
+
+      # Fired before shutting down the worker
+      def worker_end(worker)
+      end
+
+      # Fired when a file is started
+      def file_begin(file)
+      end
+
+      # Fired when a file is finished
+      def file_end(file, output)
+      end
+    end
+  end
+end

data/lib/hydra/listener/minimal_output.rb

@@ -0,0 +1,24 @@
+module Hydra #:nodoc:
+  module Listener #:nodoc:
+    # Minimal output listener. Outputs all the files at the start
+    # of testing and outputs a ./F/E per file. As well as
+    # full error output, if any.
+    class MinimalOutput < Hydra::Listener::Abstract
+      # output a starting message
+      def testing_begin(files)
+        @output.write "Hydra Testing:\n#{files.inspect}\n"
+      end
+
+      # output a finished message
+      def testing_end
+        @output.write "\nHydra Completed\n"
+      end
+
+      # For each file, just output a . for a successful file, or the
+      # Failure/Error output from the tests
+      def file_end(file, output)
+        @output.write output
+      end
+    end
+  end
+end

data/lib/hydra/listener/notifier.rb

@@ -0,0 +1,17 @@
+module Hydra #:nodoc:
+  module Listener #:nodoc:
+    # Sends a command to Notifier when the testing has finished
+    # http://manpages.ubuntu.com/manpages/gutsy/man1/notify-send.1.html
+    class Notifier < Hydra::Listener::Abstract
+      # output a finished notification
+      def testing_end
+        icon_path = File.join(
+          File.dirname(__FILE__), '..', '..', '..',
+          'hydra-icon-64x64.png'
+        )
+        `notify-send -i #{icon_path} "Hydra" "Testing Completed"`
+      end
+    end
+  end
+end
+

data/lib/hydra/listener/progress_bar.rb

@@ -0,0 +1,48 @@
+module Hydra #:nodoc:
+  module Listener #:nodoc:
+    # Output a progress bar as files are completed
+    class ProgressBar < Hydra::Listener::Abstract
+      # Store the total number of files
+      def testing_begin(files)
+        @total_files = files.size
+        @files_completed = 0
+        @test_output = ""
+        @errors = false
+        render_progress_bar
+      end
+
+      # Increment completed files count and update bar
+      def file_end(file, output)
+        unless output == '.'
+          @output.write "\r#{' '*60}\r#{output}\n"
+          @errors = true
+        end
+        @files_completed += 1
+        render_progress_bar
+      end
+
+      # Break the line
+      def testing_end
+        render_progress_bar
+        @output.write "\n"
+      end
+
+      private
+
+      def render_progress_bar
+        width = 30
+        complete = ((@files_completed.to_f / @total_files.to_f) * width).to_i
+        @output.write "\r" # move to beginning
+        @output.write 'Hydra Testing ['
+        @output.write @errors ? "\033[0;31m" : "\033[0;32m"
+        complete.times{@output.write '#'}
+        @output.write '>'
+        (width-complete).times{@output.write ' '}
+        @output.write "\033[0m"
+        @output.write "] #{@files_completed}/#{@total_files}"
+        @output.flush
+      end
+    end
+  end
+end
+

data/lib/hydra/listener/report_generator.rb

@@ -0,0 +1,30 @@
+module Hydra #:nodoc:
+  module Listener #:nodoc:
+    # Output a textual report at the end of testing
+    class ReportGenerator < Hydra::Listener::Abstract
+      # Initialize a new report
+      def testing_begin(files)
+        @report = { }
+      end
+
+      # Log the start time of a file
+      def file_begin(file)
+        @report[file] ||= { }
+        @report[file]['start'] = Time.now.to_f
+      end
+
+      # Log the end time of a file and compute the file's testing
+      # duration
+      def file_end(file, output)
+        @report[file]['end'] = Time.now.to_f
+        @report[file]['duration'] = @report[file]['end'] - @report[file]['start']
+      end
+
+      # output the report
+      def testing_end
+        YAML.dump(@report, @output)
+        @output.close
+      end
+    end
+  end
+end

data/lib/hydra/master.rb

@@ -0,0 +1,249 @@
+require 'hydra/hash'
+require 'open3'
+require 'tmpdir'
+require 'erb'
+require 'yaml'
+
+module Hydra #:nodoc:
+  # Hydra class responsible for delegate work down to workers.
+  #
+  # The Master is run once for any given testing session.
+  class YmlLoadError < StandardError; end
+
+  class Master
+    include Hydra::Messages::Master
+    include Open3
+    traceable('MASTER')
+
+    # Create a new Master
+    #
+    # Options:
+    # * :files
+    #   * An array of test files to be run. These should be relative paths from
+    #     the root of the project, since they may be run on different machines
+    #     which may have different paths.
+    # * :workers
+    #   * An array of hashes. Each hash should be the configuration options
+    #     for a worker.
+    # * :listeners
+    #   * An array of Hydra::Listener objects. See Hydra::Listener::MinimalOutput for an
+    #     example listener
+    # * :verbose
+    #   * Set to true to see lots of Hydra output (for debugging)
+    # * :autosort
+    #   * Set to false to disable automatic sorting by historical run-time per file
+    def initialize(opts = { })
+      opts.stringify_keys!
+      config_file = opts.delete('config') { nil }
+      if config_file
+
+        begin
+          config_erb = ERB.new(IO.read(config_file)).result(binding)
+        rescue Exception => e
+          raise(YmlLoadError,"config file was found, but could not be parsed with ERB.\n#{$!.inspect}")
+        end
+
+        begin
+          config_yml = YAML::load(config_erb)
+        rescue StandardError => e
+          raise(YmlLoadError,"config file was found, but could not be parsed.\n#{$!.inspect}")
+        end
+
+        opts.merge!(config_yml.stringify_keys!)
+      end
+      @files = Array(opts.fetch('files') { nil })
+      raise "No files, nothing to do" if @files.empty?
+      @incomplete_files = @files.dup
+      @workers = []
+      @listeners = []
+      @stats = Hash.new(0)
+      @event_listeners = Array(opts.fetch('listeners') { nil } )
+      @event_listeners.select{|l| l.is_a? String}.each do |l|
+        @event_listeners.delete_at(@event_listeners.index(l))
+        listener = eval(l)
+        @event_listeners << listener if listener.is_a?(Hydra::Listener::Abstract)
+      end
+      @verbose = opts.fetch('verbose') { false }
+      @autosort = opts.fetch('autosort') { true }
+      @sync = opts.fetch('sync') { nil }
+      @environment = opts.fetch('environment') { 'test' }
+
+      if @autosort
+        sort_files_from_report
+        @event_listeners << Hydra::Listener::ReportGenerator.new(File.new(heuristic_file, 'w'))
+      end
+
+      # default is one worker that is configured to use a pipe with one runner
+      worker_cfg = opts.fetch('workers') { [ { 'type' => 'local', 'runners' => 1} ] }
+
+      trace "Initialized"
+      trace "  Files:   (#{@files.inspect})"
+      trace "  Workers: (#{worker_cfg.inspect})"
+      trace "  Verbose: (#{@verbose.inspect})"
+
+      @event_listeners.each{|l| l.testing_begin(@files) }
+
+      boot_workers worker_cfg
+      process_messages
+
+      report_fields = [:tests, :assertions, :errors, :failures]
+      report = report_fields.map{|field| "#{field}: #{@stats[field]}"}.join(', ')
+      puts report
+    end
+
+    # Message handling
+    def worker_begin(worker)
+      @event_listeners.each {|l| l.worker_begin(worker) }
+    end
+
+    # Send a file down to a worker.
+    def send_file(worker)
+      f = @files.shift
+      if f
+        trace "Sending #{f.inspect}"
+        @event_listeners.each{|l| l.file_begin(f) }
+        worker[:io].write(RunFile.new(:file => f))
+      else
+        trace "No more files to send"
+      end
+    end
+
+    # Process the results coming back from the worker.
+    def process_results(worker, message)
+      if message.stats
+        message.stats.each do |key, value|
+          @stats[key] += value
+        end
+      end
+
+      if message.output =~ /ActiveRecord::StatementInvalid(.*)[Dd]eadlock/ or
+         message.output =~ /PGError: ERROR(.*)[Dd]eadlock/ or
+         message.output =~ /Mysql::Error: SAVEPOINT(.*)does not exist: ROLLBACK/ or
+         message.output =~ /Mysql::Error: Deadlock found/
+        trace "Deadlock detected running [#{message.file}]. Will retry at the end"
+        @files.push(message.file)
+        send_file(worker)
+      else
+        @incomplete_files.delete_at(@incomplete_files.index(message.file))
+        trace "#{@incomplete_files.size} Files Remaining"
+        @event_listeners.each{|l| l.file_end(message.file, message.output) }
+        if @incomplete_files.empty?
+          @workers.each do |worker|
+            @event_listeners.each{|l| l.worker_end(worker) }
+          end
+
+          shutdown_all_workers
+        else
+          send_file(worker)
+        end
+      end
+    end
+
+    # A text report of the time it took to run each file
+    attr_reader :report_text
+
+    private
+
+    def boot_workers(workers)
+      trace "Booting #{workers.size} workers"
+      workers.each do |worker|
+        worker.stringify_keys!
+        trace "worker opts #{worker.inspect}"
+        type = worker.fetch('type') { 'local' }
+        if type.to_s == 'local'
+          boot_local_worker(worker)
+        elsif type.to_s == 'ssh'
+          @workers << worker # will boot later, during the listening phase
+        else
+          raise "Worker type not recognized: (#{type.to_s})"
+        end
+      end
+    end
+
+    def boot_local_worker(worker)
+      runners = worker.fetch('runners') { raise "You must specify the number of runners" }
+      trace "Booting local worker"
+      pipe = Hydra::Pipe.new
+      child = SafeFork.fork do
+        pipe.identify_as_child
+        Hydra::Worker.new(:io => pipe, :runners => runners, :verbose => @verbose)
+      end
+
+      pipe.identify_as_parent
+      @workers << { :pid => child, :io => pipe, :idle => false, :type => :local }
+    end
+
+    def boot_ssh_worker(worker)
+      sync = Sync.new(worker, @sync, @verbose)
+
+      runners = worker.fetch('runners') { raise "You must specify the number of runners"  }
+      command = worker.fetch('command') {
+        "RAILS_ENV=#{@environment} ruby -e \"require 'rubygems'; require 'hydra'; Hydra::Worker.new(:io => Hydra::Stdio.new, :runners => #{runners}, :verbose => #{@verbose});\""
+      }
+
+      trace "Booting SSH worker"
+      ssh = Hydra::SSH.new("#{sync.ssh_opts} #{sync.connect}", sync.remote_dir, command)
+      return { :io => ssh, :idle => false, :type => :ssh, :connect => sync.connect }
+    end
+
+    def shutdown_all_workers
+      trace "Shutting down all workers"
+      @workers.each do |worker|
+        worker[:io].write(Shutdown.new) if worker[:io]
+        worker[:io].close if worker[:io]
+      end
+      @listeners.each{|t| t.exit}
+    end
+
+    def process_messages
+      Thread.abort_on_exception = true
+
+      trace "Processing Messages"
+      trace "Workers: #{@workers.inspect}"
+      @workers.each do |worker|
+        @listeners << Thread.new do
+          trace "Listening to #{worker.inspect}"
+           if worker.fetch('type') { 'local' }.to_s == 'ssh'
+             worker = boot_ssh_worker(worker)
+             @workers << worker
+           end
+          while true
+            begin
+              message = worker[:io].gets
+              trace "got message: #{message}"
+              # if it exists and its for me.
+              # SSH gives us back echoes, so we need to ignore our own messages
+              if message and !message.class.to_s.index("Worker").nil?
+                message.handle(self, worker)
+              end
+            rescue IOError
+              trace "lost Worker [#{worker.inspect}]"
+              Thread.exit
+            end
+          end
+        end
+      end
+
+      @listeners.each{|l| l.join}
+      @event_listeners.each{|l| l.testing_end}
+    end
+
+    def sort_files_from_report
+      if File.exists? heuristic_file
+        report = YAML.load_file(heuristic_file)
+        return unless report
+        sorted_files = report.sort{ |a,b|
+          b[1]['duration'] <=> a[1]['duration']
+        }.collect{|tuple| tuple[0]}
+
+        sorted_files.each do |f|
+          @files.push(@files.delete_at(@files.index(f))) if @files.index(f)
+        end
+      end
+    end
+
+    def heuristic_file
+      @heuristic_file ||= File.join(Dir.tmpdir, 'hydra_heuristics.yml')
+    end
+  end
+end

data/lib/hydra/message.rb

@@ -0,0 +1,47 @@
+module Hydra #:nodoc:
+  # Base message object. Used to pass messages with parameters around
+  # via IO objects.
+  #   class MyMessage < Hydra::Message
+  #     attr_accessor :my_var
+  #     def serialize
+  #       super(:my_var => @my_var)
+  #     end
+  #   end
+  #   m = MyMessage.new(:my_var => 'my value')
+  #   m.my_var
+  #     => "my value"
+  #   m.serialize
+  #     => "{:class=>TestMessage::MyMessage, :my_var=>\"my value\"}"
+  #   Hydra::Message.build(eval(@m.serialize)).my_var
+  #     => "my value"
+  class Message
+    # Create a new message. Opts is a hash where the keys
+    # are attributes of the message and the values are
+    # set to the attribute.
+    def initialize(opts = {})
+      opts.delete :class
+      opts.each do |variable,value|
+        self.send("#{variable}=",value)
+      end
+    end
+
+    # Build a message from a hash. The hash must contain
+    # the :class symbol, which is the class of the message
+    # that it will build to.
+    def self.build(hash)
+      hash.delete(:class).new(hash)
+    end
+
+    # Serialize the message for output on an IO channel.
+    # This is really just a string representation of a hash
+    # with no newlines. It adds in the class automatically
+    def serialize(opts = {})
+      opts.merge({:class => self.class}).inspect
+    end
+  end
+end
+
+require 'hydra/message/runner_messages'
+require 'hydra/message/worker_messages'
+require 'hydra/message/master_messages'
+