ngauthier-hydra 0.24.0

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'
+

data/lib/hydra/message/master_messages.rb

@@ -0,0 +1,19 @@
+module Hydra #:nodoc:
+  module Messages #:nodoc:
+    module Master #:nodoc:
+      # Message telling a worker to delegate a file to a runner
+      class RunFile < Hydra::Messages::Worker::RunFile
+        def handle(worker) #:nodoc:
+          worker.delegate_file(self)
+        end
+      end
+
+      # Message telling the worker to shut down.
+      class Shutdown < Hydra::Messages::Worker::Shutdown
+        def handle(worker) #:nodoc:
+          worker.shutdown
+        end
+      end
+    end
+  end
+end

data/lib/hydra/message/runner_messages.rb

@@ -0,0 +1,46 @@
+module Hydra #:nodoc:
+  module Messages #:nodoc:
+    module Runner #:nodoc:
+      # Message indicating that a Runner needs a file to run
+      class RequestFile < Hydra::Message
+        def handle(worker, runner) #:nodoc:
+          worker.request_file(self, runner)
+        end
+      end
+
+      # Message for the Runner to respond with its results
+      class Results < Hydra::Message
+        # The output from running the test
+        attr_accessor :output
+        # The file that was run
+        attr_accessor :file
+        def serialize #:nodoc:
+          super(:output => @output, :file => @file)
+        end
+        def handle(worker, runner) #:nodoc:
+          worker.relay_results(self, runner)
+        end
+      end
+
+      # Message a runner sends to a worker to verify the connection
+      class Ping < Hydra::Message
+        def handle(worker, runner) #:nodoc:
+          # We don't do anything to handle a ping. It's just to test
+          # the connectivity of the IO
+        end
+      end
+
+      # The runner forks to run rspec messages
+      # so that specs don't get rerun. It uses
+      # this message to report the results. See
+      # Runner::run_rspec_file.
+      class RSpecResult < Hydra::Message
+        # the output of the spec
+        attr_accessor :output
+        def serialize #:nodoc:
+          super(:output => @output)
+        end
+      end
+    end
+  end
+end

data/lib/hydra/message/worker_messages.rb

@@ -0,0 +1,52 @@
+module Hydra #:nodoc: 
+  module Messages #:nodoc:
+    module Worker #:nodoc:
+      # Message indicating that a worker needs a file to delegate to a runner
+      class RequestFile < Hydra::Message
+        def handle(master, worker) #:nodoc:
+          master.send_file(worker)
+        end
+      end
+
+      class WorkerBegin < Hydra::Message
+        def handle(master, worker)
+          master.worker_begin(worker)
+        end
+      end
+
+      # Message telling the Runner to run a file
+      class RunFile < Hydra::Message
+        # The file that should be run
+        attr_accessor :file
+        def serialize #:nodoc:
+          super(:file => @file)
+        end
+        def handle(runner) #:nodoc:
+          runner.run_file(@file)
+        end
+      end
+
+      # Message to tell the Runner to shut down
+      class Shutdown < Hydra::Message
+        def handle(runner) #:nodoc:
+          runner.stop
+        end
+      end
+
+      # Message relaying the results of a worker up to the master
+      class Results < Hydra::Messages::Runner::Results
+        def handle(master, worker) #:nodoc:
+          master.process_results(worker, self)
+        end
+      end
+
+      # Message a worker sends to a master to verify the connection
+      class Ping < Hydra::Message
+        def handle(master, worker) #:nodoc:
+          # We don't do anything to handle a ping. It's just to test
+          # the connectivity of the IO
+        end
+      end
+    end
+  end
+end

data/lib/hydra/messaging_io.rb

@@ -0,0 +1,49 @@
+module Hydra #:nodoc:
+  # Module that implemets methods that auto-serialize and deserialize messaging
+  # objects.
+  module MessagingIO
+    # Read a Message from the input IO object. Automatically build
+    # a message from the response and return it.
+    #
+    #  IO.gets
+    #    => Hydra::Message # or subclass
+    def gets
+      while true
+        begin
+          raise IOError unless @reader
+          message = @reader.gets
+          return nil unless message
+          return Message.build(eval(message.chomp))
+        rescue SyntaxError, NameError
+          # uncomment to help catch remote errors by seeing all traffic
+          #$stderr.write "Not a message: [#{message.inspect}]\n"
+        end
+      end
+    end
+
+    # Write a Message to the output IO object. It will automatically
+    # serialize a Message object.
+    #  IO.write Hydra::Message.new
+    def write(message)
+      raise IOError unless @writer
+      raise UnprocessableMessage unless message.is_a?(Hydra::Message)
+      @writer.write(message.serialize+"\n")
+    rescue Errno::EPIPE
+      raise IOError
+    end
+
+    # Closes the IO object.
+    def close
+      @reader.close if @reader
+      @writer.close if @writer
+    end
+
+    # IO will return this error if it cannot process a message.
+    # For example, if you tried to write a string, it would fail,
+    # because the string is not a message.
+    class UnprocessableMessage < RuntimeError
+      # Custom error message
+      attr_accessor :message
+    end
+  end
+end

data/lib/hydra/pipe.rb

@@ -0,0 +1,61 @@
+require 'hydra/messaging_io'
+module Hydra #:nodoc:
+  # Read and write between two processes via pipes. For example:
+  #   @pipe = Hydra::Pipe.new
+  #   @child = Process.fork do
+  #     @pipe.identify_as_child
+  #     puts "A message from my parent:\n#{@pipe.gets.text}"
+  #     @pipe.close
+  #   end
+  #   @pipe.identify_as_parent
+  #   @pipe.write Hydra::Messages::TestMessage.new(:text => "Hello!")
+  #   @pipe.close
+  #
+  # Note that the TestMessage class is only available in tests, and
+  # not in Hydra by default.
+  #
+  #
+  # When the process forks, the pipe is copied. When a pipe is
+  # identified as a parent or child, it is choosing which ends
+  # of the pipe to use.
+  #
+  # A pipe is actually two pipes:
+  #
+  #  Parent  == Pipe 1 ==> Child
+  #  Parent <== Pipe 2 ==  Child
+  #
+  # It's like if you had two cardboard tubes and you were using
+  # them to drop balls with messages in them between processes.
+  # One tube is for sending from parent to child, and the other
+  # tube is for sending from child to parent.
+  class Pipe
+    include Hydra::MessagingIO
+    # Creates a new uninitialized pipe pair.
+    def initialize
+      @child_read, @parent_write = IO.pipe
+      @parent_read, @child_write = IO.pipe
+    end
+
+    # Identify this side of the pipe as the child.
+    def identify_as_child
+      @parent_write.close
+      @parent_read.close
+      @reader = @child_read
+      @writer = @child_write
+    end
+
+    # Identify this side of the pipe as the parent
+    def identify_as_parent
+      @child_write.close
+      @child_read.close
+      @reader = @parent_read
+      @writer = @parent_write
+    end
+
+    # Output pipe nicely
+    def inspect
+      "#<#{self.class} @reader=#{@reader.to_s}, @writer=#{@writer.to_s}>"
+    end
+
+  end
+end

data/lib/hydra/runner.rb

@@ -0,0 +1,312 @@
+require 'test/unit'
+require 'test/unit/testresult'
+Test::Unit.run = true
+
+module Hydra #:nodoc:
+  # Hydra class responsible for running test files.
+  #
+  # The Runner is never run directly by a user. Runners are created by a
+  # Worker to run test files.
+  #
+  # The general convention is to have one Runner for each logical processor
+  # of a machine.
+  class Runner
+    include Hydra::Messages::Runner
+    traceable('RUNNER')
+
+    DEFAULT_LOG_FILE = 'hydra-runner.log'
+
+    # Boot up a runner. It takes an IO object (generally a pipe from its
+    # parent) to send it messages on which files to execute.
+    def initialize(opts = {})
+      redirect_output( opts.fetch( :runner_log_file ) { DEFAULT_LOG_FILE } )
+      reg_trap_sighup
+
+      @io = opts.fetch(:io) { raise "No IO Object" }
+      @verbose = opts.fetch(:verbose) { false }
+      @event_listeners = Array( opts.fetch( :runner_listeners ) { nil } )
+      @options = opts.fetch(:options) { "" }
+      @directory = get_directory
+
+      $stdout.sync = true
+      runner_begin
+
+      trace 'Booted. Sending Request for file'
+      @io.write RequestFile.new
+      begin
+        process_messages
+      rescue => ex
+        trace ex.to_s
+        raise ex
+      end
+    end
+
+    def reg_trap_sighup
+      for sign in [:SIGHUP, :INT]
+        trap sign do
+          stop
+        end
+      end
+      @runner_began = true
+    end
+
+    def runner_begin
+      trace "Firing runner_begin event"
+      @event_listeners.each {|l| l.runner_begin( self ) }
+    end
+
+    # Run a test file and report the results
+    def run_file(file)
+      trace "Running file: #{file}"
+
+      output = ""
+      if file =~ /_spec.rb$/i
+        output = run_rspec_file(file)
+      elsif file =~ /.feature$/i
+        output = run_cucumber_file(file)
+      elsif file =~ /.js$/i or file =~ /.json$/i
+        output = run_javascript_file(file)
+      else
+        output = run_test_unit_file(file)
+      end
+
+      output = "." if output == ""
+
+      @io.write Results.new(:output => output, :file => file)
+      return output
+    end
+
+    # Stop running
+    def stop
+      runner_end if @runner_began
+      @runner_began = @running = false
+    end
+
+    def runner_end
+      trace "Ending runner #{self.inspect}"
+      @event_listeners.each {|l| l.runner_end( self ) }
+    end
+
+    def format_exception(ex)
+      "#{ex.class.name}: #{ex.message}\n    #{ex.backtrace.join("\n    ")}"
+    end
+
+    private
+
+    # The runner will continually read messages and handle them.
+    def process_messages
+      trace "Processing Messages"
+      @running = true
+      while @running
+        begin
+          message = @io.gets
+          if message and !message.class.to_s.index("Worker").nil?
+            trace "Received message from worker"
+            trace "\t#{message.inspect}"
+            message.handle(self)
+          else
+            @io.write Ping.new
+          end
+        rescue IOError => ex
+          trace "Runner lost Worker"
+          stop
+        end
+      end
+    end
+
+    def format_ex_in_file(file, ex)
+      "Error in #{file}:\n  #{format_exception(ex)}"
+    end
+
+    # Run all the Test::Unit Suites in a ruby file
+    def run_test_unit_file(file)
+      begin
+        require @directory + file
+      rescue LoadError => ex
+        trace "#{file} does not exist [#{ex.to_s}]"
+        return ex.to_s
+      rescue Exception => ex
+        trace "Error requiring #{file} [#{ex.to_s}]"
+        return format_ex_in_file(file, ex)
+      end
+      output = []
+      @result = Test::Unit::TestResult.new
+      @result.add_listener(Test::Unit::TestResult::FAULT) do |value|
+        output << value
+      end
+
+      klasses = Runner.find_classes_in_file(file)
+      begin
+        klasses.each{|klass| klass.suite.run(@result){|status, name| ;}}
+      rescue => ex
+        output << format_ex_in_file(file, ex)
+      end
+
+      return output.join("\n")
+    end
+
+    # run all the Specs in an RSpec file (NOT IMPLEMENTED)
+    def run_rspec_file(file)
+      # pull in rspec
+      begin
+        require 'rspec'
+        require 'hydra/spec/hydra_formatter'
+        # Ensure we override rspec's at_exit
+        RSpec::Core::Runner.disable_autorun!
+      rescue LoadError => ex
+        return ex.to_s
+      end
+      hydra_output = StringIO.new
+
+      config = [
+        '-f', 'RSpec::Core::Formatters::HydraFormatter',
+        file
+      ]
+
+      RSpec.instance_variable_set(:@world, nil)
+      RSpec::Core::Runner.run(config, hydra_output, hydra_output)
+
+      hydra_output.rewind
+      output = hydra_output.read.chomp
+      output = "" if output.gsub("\n","") =~ /^\.*$/
+
+      return output
+    end
+
+    # run all the scenarios in a cucumber feature file
+    def run_cucumber_file(file)
+      hydra_response = StringIO.new
+
+      options = @options if @options.is_a?(Array)
+      options = @options.split(' ') if @options.is_a?(String)
+
+      fork_id = fork do
+        files = [file]
+        dev_null = StringIO.new
+
+        args = [file, options].flatten.compact
+        hydra_response.puts args.inspect
+
+        results_directory = "#{Dir.pwd}/results/features"
+        FileUtils.mkdir_p results_directory
+
+        require 'cucumber/cli/main'
+        require 'hydra/cucumber/formatter'
+        require 'hydra/cucumber/partial_html'
+
+        Cucumber.logger.level = Logger::INFO
+
+        cuke = Cucumber::Cli::Main.new(args, dev_null, dev_null)
+        cuke.configuration.formats << ['Cucumber::Formatter::Hydra', hydra_response]
+
+        html_output = cuke.configuration.formats.select{|format| format[0] == 'html'}
+        if html_output
+          cuke.configuration.formats.delete(html_output)
+          cuke.configuration.formats << ['Hydra::Formatter::PartialHtml', "#{results_directory}/#{file.split('/').last}.html"]
+        end
+
+        cuke_runtime = Cucumber::Runtime.new(cuke.configuration)
+        cuke_runtime.run!
+        exit 1 if cuke_runtime.results.failure?
+      end
+      Process.wait fork_id
+
+      hydra_response.puts "." if not $?.exitstatus == 0
+      hydra_response.rewind
+
+      hydra_response.read
+    end
+
+    def run_javascript_file(file)
+      errors = []
+      require 'v8'
+      V8::Context.new do |context|
+        context.load(File.expand_path(File.join(File.dirname(__FILE__), 'js', 'lint.js')))
+        context['input'] = lambda{
+          File.read(file)
+        }
+        context['reportErrors'] = lambda{|js_errors|
+          js_errors.each do |e|
+            e = V8::To.rb(e)
+            errors << "\n\e[1;31mJSLINT: #{file}\e[0m"
+            errors << "  Error at line #{e['line'].to_i + 1} " + 
+              "character #{e['character'].to_i + 1}: \e[1;33m#{e['reason']}\e[0m"
+            errors << "#{e['evidence']}"
+          end
+        }
+        context.eval %{
+          JSLINT(input(), {
+            sub: true,
+            onevar: true,
+            eqeqeq: true,
+            plusplus: true,
+            bitwise: true,
+            regexp: true,
+            newcap: true,
+            immed: true,
+            strict: true,
+            rhino: true
+          });
+          reportErrors(JSLINT.errors);
+        }
+      end
+
+      if errors.empty?
+        return '.'
+      else
+        return errors.join("\n")
+      end
+    end
+
+    # find all the test unit classes in a given file, so we can run their suites
+    def self.find_classes_in_file(f)
+      code = ""
+      File.open(f) {|buffer| code = buffer.read}
+      matches = code.scan(/class\s+([\S]+)/)
+      klasses = matches.collect do |c|
+        begin
+          if c.first.respond_to? :constantize
+            c.first.constantize
+          else
+            eval(c.first)
+          end
+        rescue NameError
+          # means we could not load [c.first], but thats ok, its just not
+          # one of the classes we want to test
+          nil
+        rescue SyntaxError
+          # see above
+          nil
+        end
+      end
+      return klasses.select{|k| k.respond_to? 'suite'}
+    end
+
+    # Yanked a method from Cucumber
+    def tag_excess(features, limits)
+      limits.map do |tag_name, tag_limit|
+        tag_locations = features.tag_locations(tag_name)
+        if tag_limit && (tag_locations.length > tag_limit)
+          [tag_name, tag_limit, tag_locations]
+        else
+          nil
+        end
+      end.compact
+    end
+
+    def redirect_output file_name
+      begin
+        $stderr = $stdout =  File.open(file_name, 'a')
+      rescue
+        # it should always redirect output in order to handle unexpected interruption
+        # successfully
+        $stderr = $stdout =  File.open(DEFAULT_LOG_FILE, 'a')
+      end
+    end
+
+    def get_directory
+      RUBY_VERSION < "1.9" ? "" : Dir.pwd + "/"
+    end
+  end
+end
+