hydra 0.4.1 → 0.5.0

data/TODO

@@ -1,54 +1,16 @@
-# runners = []
-# cores.each do |c|
-#   in = pipes[c][0]
-#   out = pipes[c][1]
-#   runners << TestRunner.new(in, out)
-# end
-#
-# files = [ ... ]
-# results = []
-#
-# runners.each do |r|
-#   Thread.new do
-#     while !files.empty?
-#       results << r.run_file(files.pop)
-#     end
-#     r.shutdown
-#   end
-# end
-#
-# puts results.join("\n")
-#
+IO selection configuration for master
+- allow pipe setup
+- allow ssh setup
 
+YML configuration
+
+v0.6.0
+
+multitest backwards compatible
+
+v0.7.0
+
+???
+
+v1.0.0
 
-# Master
-# boot up workers
-# listen for worker messages
-# add worker messages to message queue
-# process message queue
-# "reply" to a message allows sending a message back down to worker
-#
-# When worker asks for file but no files left, send shutdown message to worker
-# when worker connection breaks, end thread
-# wait on all threads
-# when all threads are done, all workers must be done
-#
-#
-# Worker
-# boot up runners
-# listen for runner messages
-# add runner messages to message queue
-# process message queue
-# "reply" to a message allows sending message back down to runner
-#
-# when a runner asks for file but master responds with shutdown, mark self
-#   as terminated, shut down runners. Any runner that asks for a file is
-#   auto-terminated
-# wait for runner threads to finish
-# then exit, breaking master connection
-#
-# Runner
-# when booted, ask for a file
-# then process messages on the queue
-# when it's a file, run it and send a results message
-# when it's a shutdown, break main loop

data/VERSION

@@ -1 +1 @@
-0.4.1
+0.5.0

data/hydra.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{hydra}
-  s.version = "0.4.1"
+  s.version = "0.5.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Nick Gauthier"]
-  s.date = %q{2010-01-28}
+  s.date = %q{2010-01-29}
   s.description = %q{Spread your tests over multiple machines to test your code faster.}
   s.email = %q{nick@smartlogicsolutions.com}
   s.extra_rdoc_files = [
@@ -27,7 +27,9 @@ Gem::Specification.new do |s|
      "VERSION",
      "hydra.gemspec",
      "lib/hydra.rb",
+     "lib/hydra/master.rb",
      "lib/hydra/message.rb",
+     "lib/hydra/message/master_messages.rb",
      "lib/hydra/message/runner_messages.rb",
      "lib/hydra/message/worker_messages.rb",
      "lib/hydra/messaging_io.rb",
@@ -38,6 +40,7 @@ Gem::Specification.new do |s|
      "test/fixtures/assert_true.rb",
      "test/fixtures/echo_the_dolphin.rb",
      "test/fixtures/write_file.rb",
+     "test/master_test.rb",
      "test/message_test.rb",
      "test/pipe_test.rb",
      "test/runner_test.rb",
@@ -57,6 +60,7 @@ Gem::Specification.new do |s|
      "test/fixtures/write_file.rb",
      "test/fixtures/assert_true.rb",
      "test/fixtures/echo_the_dolphin.rb",
+     "test/master_test.rb",
      "test/worker_test.rb",
      "test/runner_test.rb",
      "test/pipe_test.rb"

data/lib/hydra.rb

@@ -3,4 +3,5 @@ require 'hydra/ssh'
 require 'hydra/message'
 require 'hydra/runner'
 require 'hydra/worker'
+require 'hydra/master'
 

data/lib/hydra/master.rb

@@ -0,0 +1,75 @@
+module Hydra #:nodoc:
+  # Hydra class responsible for delegate work down to workers.
+  #
+  # The Master is run once for any given testing session.
+  class Master
+    include Hydra::Messages::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.
+    def initialize(opts = { })
+      @files = opts.fetch(:files) { [] }
+      @workers = []
+      @listeners = []
+      boot_workers(opts.fetch(:workers) { [ {:runners => 1} ] } )
+      process_messages
+    end
+
+    # Message handling
+    
+    # Send a file down to a worker. If there are no more files, this will shut the
+    # worker down.
+    def send_file(worker)
+      f = @files.pop
+      if f
+        worker[:io].write(RunFile.new(:file => f))
+      else
+        worker[:io].write(Shutdown.new)
+        Thread.exit
+      end
+    end
+
+    private
+    
+    def boot_workers(workers)
+      workers.each do |worker|
+        pipe = Hydra::Pipe.new
+        child = Process.fork do
+          pipe.identify_as_child
+          Hydra::Worker.new(:io => pipe, :runners => worker[:runners])
+        end
+        pipe.identify_as_parent
+        @workers << { :pid => child, :io => pipe, :idle => false }
+      end
+    end
+
+    def process_messages
+      Thread.abort_on_exception = true
+
+      @workers.each do |worker|
+        @listeners << Thread.new do
+          while true
+            begin
+              message = worker[:io].gets
+              message.handle(self, worker) if message
+            rescue IOError => ex
+              $stderr.write "Master lost Worker [#{worker.inspect}]\n"
+              worker[:io].close
+              @workers.delete(worker)
+              Thread.exit
+            end
+          end
+        end
+      end
+      
+      @listeners.each{|l| l.join}
+    end
+  end
+end

data/lib/hydra/message.rb

@@ -43,4 +43,5 @@ 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

@@ -8,20 +8,11 @@ module Hydra #:nodoc:
         end
       end
 
-      # Message telling the Runner to run a file
-      class RunFile < Hydra::Message
-        attr_accessor :file
-        def serialize #:nodoc:
-          super(:file => @file)
-        end
-        def handle(runner) #:nodoc:
-          runner.run_file(@file)
-        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)
@@ -31,10 +22,11 @@ module Hydra #:nodoc:
         end
       end
 
-      # Message to tell the Runner to shut down
-      class Shutdown < Hydra::Message
-        def handle(runner) #:nodoc:
-          runner.stop
+      # 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
     end

data/lib/hydra/message/worker_messages.rb

@@ -1,25 +1,45 @@
 module Hydra #:nodoc: 
   module Messages #:nodoc:
     module Worker #:nodoc:
-      # Message indicating that a work needs a file to delegate to a runner
+      # 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
+
+      # 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 telling a worker to delegate a file to a runner
-      class RunFile < Hydra::Messages::Runner::RunFile
-        def handle(worker)
-          worker.delegate_file(self)
+      # 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:
+          $stdout.write output
+          master.send_file(worker)
+        end
       end
 
-      # Message telling the worker to shut down.
-      class Shutdown < Hydra::Messages::Runner::Shutdown
-        def handle(worker)
-          worker.shutdown
+      # 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

data/lib/hydra/messaging_io.rb

@@ -20,11 +20,9 @@ module Hydra #:nodoc:
     def write(message)
       raise IOError unless @writer
       raise UnprocessableMessage unless message.is_a?(Hydra::Message)
-      begin
-        @writer.write(message.serialize+"\n")
-      rescue Errno::EPIPE
-        raise IOError
-      end
+      @writer.write(message.serialize+"\n")
+    rescue Errno::EPIPE
+      raise IOError
     end
 
     # Closes the IO object.
@@ -37,6 +35,7 @@ module Hydra #:nodoc:
     # 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

data/lib/hydra/pipe.rb

@@ -51,5 +51,11 @@ module Hydra #:nodoc:
       @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,32 +1,94 @@
 module Hydra #:nodoc:
-  # Hydra class responsible for running test files
+  # 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
     # 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(io)
-      @io = io
-      @io.write Hydra::Messages::Runner::RequestFile.new
-      process_messages
-    end
+    def initialize(opts = {})
+      @io = opts.fetch(:io) { raise "No IO Object" } 
+      @verbose = opts.fetch(:verbose) { false }
 
-    # The runner will continually read messages and handle them.
-    def process_messages
-      @running = true
-      while @running
-        message = @io.gets
-        message.handle(self) if message
-      end
+      Test::Unit.run = true
+
+      @io.write RequestFile.new
+      process_messages
     end
 
     # Run a test file and report the results
     def run_file(file)
-      `ruby #{file}`
-      @io.write Hydra::Messages::Runner::Results.new(:output => "Finished", :file => file)
+      require file
+      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 << ex.to_s
+      end
+
+      output << '.' if output.empty?
+
+      @io.write Results.new(:output => output.join("\n"), :file => file)
     end
 
     # Stop running
     def stop
       @running = false
     end
+
+    private
+
+    # The runner will continually read messages and handle them.
+    def process_messages
+      $stdout.write "RUNNER| Processing Messages\n" if @verbose
+      @running = true
+      while @running
+        begin
+          message = @io.gets
+          if message
+            $stdout.write "RUNNER| Received message from worker\n" if @verbose
+            $stdout.write "      | #{message.inspect}\n" if @verbose
+            message.handle(self)
+          else
+            @io.write Ping.new
+          end
+        rescue IOError => ex
+          $stderr.write "Runner lost Worker\n" if @verbose
+          @running = false
+        end
+      end
+    end
+
+    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
+          # $stderr.write "Could not load [#{c.first}] from [#{f}]\n"
+          nil
+        rescue SyntaxError
+          # $stderr.write "Could not load [#{c.first}] from [#{f}]\n"
+          nil
+        end
+      end
+      return klasses.select{|k| k.respond_to? 'suite'}
+    end
   end
 end

data/lib/hydra/worker.rb

@@ -1,15 +1,25 @@
 module Hydra #:nodoc:
   # Hydra class responsible to dispatching runners and communicating with the master.
+  #
+  # The Worker is never run directly by a user. Workers are created by a
+  # Master to delegate to Runners.
+  #
+  # The general convention is to have one Worker per machine on a distributed
+  # network.
   class Worker
+    include Hydra::Messages::Worker
     # Create a new worker.
     # * io: The IO object to use to communicate with the master
     # * num_runners: The number of runners to launch
-    def initialize(io, num_runners)
-      @io = io
+    def initialize(opts = {})
+      @verbose = opts.fetch(:verbose) { false }
+      @io = opts.fetch(:io) { raise "No IO Object" }
       @runners = []
       @listeners = []
-      boot_runners(num_runners)
+
+      boot_runners(opts.fetch(:runners) { 1 })
       process_messages
+      
       @runners.each{|r| Process.wait r[:pid] }
     end
 
@@ -19,93 +29,114 @@ module Hydra #:nodoc:
     # When a runner wants a file, it hits this method with a message.
     # Then the worker bubbles the file request up to the master.
     def request_file(message, runner)
-      @io.write(Hydra::Messages::Worker::RequestFile.new)
+      @io.write(RequestFile.new)
       runner[:idle] = true
     end
 
     # When the master sends a file down to the worker, it hits this
     # method. Then the worker delegates the file down to a runner.
     def delegate_file(message)
-      r = idle_runner
-      r[:idle] = false
-      r[:io].write(Hydra::Messages::Runner::RunFile.new(eval(message.serialize)))
+      runner = idle_runner
+      runner[:idle] = false
+      runner[:io].write(RunFile.new(eval(message.serialize)))
     end
 
     # When a runner finishes, it sends the results up to the worker. Then the
     # worker sends the results up to the master.
-    # TODO: when we relay results, it should trigger a RunFile or Shutdown from
-    # the master implicitly
     def relay_results(message, runner)
       runner[:idle] = true
-      @io.write(Hydra::Messages::Worker::Results.new(eval(message.serialize)))
+      @io.write(Results.new(eval(message.serialize)))
     end
 
     # When a master issues a shutdown order, it hits this method, which causes
     # the worker to send shutdown messages to its runners.
-    # TODO: implement a ShutdownComplete message, so that we can kill the
-    # processes if necessary.
     def shutdown
       @running = false
+      $stdout.write "WORKER| Notifying #{@runners.size} Runners of Shutdown\n" if @verbose
       @runners.each do |r|
-        r[:io].write(Hydra::Messages::Runner::Shutdown.new)
+        $stdout.write "WORKER| Sending Shutdown to Runner\n" if @verbose
+        $stdout.write "      | #{r.inspect}\n" if @verbose
+        r[:io].write(Shutdown.new)
       end
+      Thread.exit
     end
 
     private
 
     def boot_runners(num_runners) #:nodoc:
+      $stdout.write "WORKER| Booting #{num_runners} Runners\n" if @verbose
       num_runners.times do
         pipe = Hydra::Pipe.new
         child = Process.fork do
           pipe.identify_as_child
-          Hydra::Runner.new(pipe)
+          Hydra::Runner.new(:io => pipe, :verbose => @verbose)
         end
         pipe.identify_as_parent
         @runners << { :pid => child, :io => pipe, :idle => false }
       end
+      $stdout.write "WORKER| #{@runners.size} Runners booted\n" if @verbose
     end
 
     # Continuously process messages
     def process_messages #:nodoc:
+      $stdout.write "WORKER| Processing Messages\n" if @verbose
       @running = true
 
-      # Abort the worker if one of the runners has an exception
-      # TODO: catch this exception, return a dying message to the master
-      # then shutdown
       Thread.abort_on_exception = true
 
-      # Worker listens and handles messages
+      process_messages_from_master
+      process_messages_from_runners
+
+      @listeners.each{|l| l.join }
+      @io.close
+      $stdout.write "WORKER| Done processing messages\n" if @verbose
+    end
+
+    def process_messages_from_master
       @listeners << Thread.new do
         while @running
-          message = @io.gets
-          message.handle(self) if message
+          begin
+            message = @io.gets
+            if message
+              $stdout.write "WORKER| Received Message from Master\n" if @verbose 
+              $stdout.write "      | #{message.inspect}\n" if @verbose
+              message.handle(self)
+            else
+              @io.write Ping.new
+            end
+          rescue IOError => ex
+            $stderr.write "Worker lost Master\n" if @verbose
+            Thread.exit
+          end
         end
       end
+    end
 
-      # Runners listen, but when they handle they pass themselves
-      # so we can reference them when we deal with their messages
+    def process_messages_from_runners
       @runners.each do |r|
         @listeners << Thread.new do
           while @running
             begin
               message = r[:io].gets
-              message.handle(self, r) if message
+              if message
+                $stdout.write "WORKER| Received Message from Runner\n" if @verbose
+                $stdout.write "      | #{message.inspect}\n" if @verbose
+                message.handle(self, r)
+              end
             rescue IOError => ex
-              # If the other end of the pipe closes
-              # we will continue, because we're probably
-              # not @running anymore
+              $stderr.write "Worker lost Runner [#{r.inspect}]\n"
+              Thread.exit
             end
           end
         end
       end
-      @listeners.each{|l| l.join }
     end
 
     # Get the next idle runner
     def idle_runner #:nodoc:
       idle_r = nil
       while idle_r.nil?
-        idle_r = @runners.detect{|r| r[:idle]}
+        idle_r = @runners.detect{|runner| runner[:idle]}
         sleep(1)
       end
       return idle_r

data/test/fixtures/write_file.rb

@@ -1,7 +1,7 @@
 require File.join(File.dirname(__FILE__), '..', 'test_helper')
 
 class WriteFileTest < Test::Unit::TestCase
-  should "write file" do
+  def test_write_a_file
     File.open(File.join(Dir.tmpdir, 'hydra_test.txt'), 'w') do |f|
       f.write "HYDRA"
     end

data/test/master_test.rb

@@ -0,0 +1,21 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class MasterTest < Test::Unit::TestCase
+  context "with a file to test and a destination to verify" do
+    setup do
+      FileUtils.rm_f(target_file)
+    end
+
+    teardown do
+      FileUtils.rm_f(target_file)
+    end
+
+    should "run a test" do
+      m = Hydra::Master.new({
+        :files => Array(test_file)
+      })
+      assert File.exists?(target_file)
+      assert_equal "HYDRA", File.read(target_file)
+    end
+  end
+end

data/test/runner_test.rb

@@ -1,16 +1,13 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-TARGET = File.join(Dir.tmpdir, 'hydra_test.txt')
-TESTFILE = File.join(File.dirname(__FILE__), 'fixtures', 'write_file.rb')
-
 class RunnerTest < Test::Unit::TestCase
   context "with a file to test and a destination to verify" do
     setup do
-      FileUtils.rm_f(TARGET)
+      FileUtils.rm_f(target_file)
     end
 
     teardown do
-      FileUtils.rm_f(TARGET)
+      FileUtils.rm_f(target_file)
     end
 
 
@@ -44,25 +41,22 @@ class RunnerTest < Test::Unit::TestCase
 
       # make sure it asks for a file, then give it one
       assert pipe.gets.is_a?(Hydra::Messages::Runner::RequestFile)
-      pipe.write(Hydra::Messages::Runner::RunFile.new(:file => TESTFILE))
+      pipe.write(Hydra::Messages::Worker::RunFile.new(:file => test_file))
       
       # grab its response. This makes us wait for it to finish
       response = pipe.gets
       
       # tell it to shut down
-      pipe.write(Hydra::Messages::Runner::Shutdown.new)
+      pipe.write(Hydra::Messages::Worker::Shutdown.new)
       
       # ensure it ran
-      assert File.exists?(TARGET)
-      assert_equal "HYDRA", File.read(TARGET)
-
-      pipe.close
+      assert File.exists?(target_file)
+      assert_equal "HYDRA", File.read(target_file)
     end
 
     def run_the_runner(pipe)
       pipe.identify_as_child
-      Hydra::Runner.new(pipe)
-      pipe.close
+      Hydra::Runner.new({:io => pipe})
     end
   end
   include RunnerTestHelper

data/test/test_helper.rb

@@ -8,6 +8,13 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'hydra'
 
 class Test::Unit::TestCase
+  def target_file
+    File.join(Dir.tmpdir, 'hydra_test.txt')
+  end
+
+  def test_file
+    File.join(File.dirname(__FILE__), 'fixtures', 'write_file.rb')
+  end
 end
 
 module Hydra #:nodoc:

data/test/worker_test.rb

@@ -1,32 +1,28 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-TARGET = File.join(Dir.tmpdir, 'hydra_test.txt')
-TESTFILE = File.join(File.dirname(__FILE__), 'fixtures', 'write_file.rb')
-
 class WorkerTest < Test::Unit::TestCase
   context "with a file to test and a destination to verify" do
     setup do
-      FileUtils.rm_f(TARGET)
+      FileUtils.rm_f(target_file)
     end
 
     teardown do
-      FileUtils.rm_f(TARGET)
+      FileUtils.rm_f(target_file)
     end
 
     # run the worker in the foreground and the requests in the background
-    should "run a test" do
+    should "run a test in the foreground" do
       num_runners = 4
       pipe = Hydra::Pipe.new
       child = Process.fork do
         request_a_file_and_verify_completion(pipe, num_runners)
-        pipe.close
       end
       run_the_worker(pipe, num_runners)
       Process.wait(child)
     end
 
     # inverse of the above test to run the worker in the background
-    should "be able to tell a worker to run a test" do
+    should "run a test in the background" do
       num_runners = 4
       pipe = Hydra::Pipe.new
       child = Process.fork do
@@ -34,15 +30,13 @@ class WorkerTest < Test::Unit::TestCase
       end
       request_a_file_and_verify_completion(pipe, num_runners)
       Process.wait(child)
-      pipe.close
     end
   end
 
   module WorkerTestHelper
     def run_the_worker(pipe, num_runners)
       pipe.identify_as_child
-      Hydra::Worker.new(pipe, num_runners)
-      pipe.close
+      Hydra::Worker.new({:io => pipe, :runners => num_runners})
     end
 
     def request_a_file_and_verify_completion(pipe, num_runners)
@@ -50,15 +44,14 @@ class WorkerTest < Test::Unit::TestCase
       num_runners.times do
         assert pipe.gets.is_a?(Hydra::Messages::Worker::RequestFile)
       end
-      pipe.write(Hydra::Messages::Worker::RunFile.new(:file => TESTFILE))
+      pipe.write(Hydra::Messages::Master::RunFile.new(:file => test_file))
 
-      response = pipe.gets
-      assert response.is_a?(Hydra::Messages::Worker::Results)
+      assert pipe.gets.is_a?(Hydra::Messages::Worker::Results)
 
-      pipe.write(Hydra::Messages::Worker::Shutdown.new)
+      pipe.write(Hydra::Messages::Master::Shutdown.new)
 
-      assert File.exists?(TARGET)
-      assert_equal "HYDRA", File.read(TARGET)
+      assert File.exists?(target_file)
+      assert_equal "HYDRA", File.read(target_file)
     end
   end
   include WorkerTestHelper

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: hydra
 version: !ruby/object:Gem::Version 
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors: 
 - Nick Gauthier
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-28 00:00:00 -05:00
+date: 2010-01-29 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -52,7 +52,9 @@ files:
 - VERSION
 - hydra.gemspec
 - lib/hydra.rb
+- lib/hydra/master.rb
 - lib/hydra/message.rb
+- lib/hydra/message/master_messages.rb
 - lib/hydra/message/runner_messages.rb
 - lib/hydra/message/worker_messages.rb
 - lib/hydra/messaging_io.rb
@@ -63,6 +65,7 @@ files:
 - test/fixtures/assert_true.rb
 - test/fixtures/echo_the_dolphin.rb
 - test/fixtures/write_file.rb
+- test/master_test.rb
 - test/message_test.rb
 - test/pipe_test.rb
 - test/runner_test.rb
@@ -104,6 +107,7 @@ test_files:
 - test/fixtures/write_file.rb
 - test/fixtures/assert_true.rb
 - test/fixtures/echo_the_dolphin.rb
+- test/master_test.rb
 - test/worker_test.rb
 - test/runner_test.rb
 - test/pipe_test.rb