hydra 0.24.0 → 6.0.0.rc1

data/lib/hydra/message.rb

@@ -1,47 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,312 +0,0 @@
-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
-