hydra 0.23.3 → 0.24.0

data/lib/hydra/worker.rb

@@ -19,8 +19,18 @@ module Hydra #:nodoc:
       @io = opts.fetch(:io) { raise "No IO Object" }
       @runners = []
       @listeners = []
+      @options = opts.fetch(:options) { "" }
 
       load_worker_initializer
+
+      @runner_event_listeners = Array(opts.fetch(:runner_listeners) { nil })
+      @runner_event_listeners.select{|l| l.is_a? String}.each do |l|
+        @runner_event_listeners.delete_at(@runner_event_listeners.index(l))
+        listener = eval(l)
+        @runner_event_listeners << listener if listener.is_a?(Hydra::RunnerListener::Abstract)
+      end
+      @runner_log_file = opts.fetch(:runner_log_file) { nil }
+
       boot_runners(opts.fetch(:runners) { 1 })
       @io.write(Hydra::Messages::Worker::WorkerBegin.new)
 
@@ -81,9 +91,10 @@ module Hydra #:nodoc:
       trace "Booting #{num_runners} Runners"
       num_runners.times do
         pipe = Hydra::Pipe.new
+
         child = SafeFork.fork do
           pipe.identify_as_child
-          Hydra::Runner.new(:io => pipe, :verbose => @verbose)
+          Hydra::Runner.new(:io => pipe, :verbose => @verbose, :runner_listeners => @runner_event_listeners, :runner_log_file => @runner_log_file, :options => @options)
         end
         pipe.identify_as_parent
         @runners << { :pid => child, :io => pipe, :idle => false }
@@ -121,7 +132,7 @@ module Hydra #:nodoc:
             end
           rescue IOError => ex
             trace "Worker lost Master"
-            Thread.exit
+            shutdown
           end
         end
       end

data/test/fixtures/hydra_worker_init.rb

@@ -0,0 +1,2 @@
+require '../test/fixtures/runner_listeners.rb'
+require '../test/fixtures/master_listeners.rb'

data/test/fixtures/many_outputs_to_console.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+10000.times do 
+  $stdout.write "A non-hydra message...\n"
+  $stdout.flush
+end
+
+$stdout.write "{:class=>Hydra::Messages::TestMessage, :text=>\"My message\"}\n"
+$stdout.flush

data/test/fixtures/master_listeners.rb

@@ -0,0 +1,10 @@
+module HydraExtension
+  module Listener
+    class WorkerBeganFlag < Hydra::Listener::Abstract
+      # Fired after runner processes have been started
+      def worker_begin(worker)
+        FileUtils.touch File.expand_path(File.join(Dir.consistent_tmpdir, 'worker_began_flag'))
+      end
+    end
+  end
+end

data/test/fixtures/runner_listeners.rb

@@ -0,0 +1,23 @@
+module HydraExtension
+  module RunnerListener
+    class RunnerBeginTest < Hydra::RunnerListener::Abstract
+      # Fired by the runner just before requesting the first file
+      def runner_begin( runner )
+        FileUtils.touch File.expand_path(File.join(Dir.consistent_tmpdir, 'alternate_hydra_test.txt'))
+      end
+    end
+
+    class RunnerEndTest < Hydra::RunnerListener::Abstract
+      # Fired by the runner just before requesting the first file
+      def runner_begin( runner )
+        FileUtils.touch File.expand_path(File.join(Dir.consistent_tmpdir, 'runner_began_flag')) #used to know when the runner is ready
+      end
+      # Fired by the runner just after stoping
+      def runner_end( runner )
+        # NOTE: do not use trace here
+        #runner.trace "Ending runner"
+        FileUtils.touch File.expand_path(File.join(Dir.consistent_tmpdir, 'alternate_hydra_test.txt'))
+      end
+    end
+  end
+end

data/test/fixtures/task_test_config.yml

@@ -0,0 +1,6 @@
+---
+  workers:
+    - type: ssh
+      connect: localhost
+      directory: /tmp
+      runners: 1

data/test/master_test.rb

@@ -1,4 +1,6 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
+require File.join(File.dirname(__FILE__), 'fixtures', 'runner_listeners')
+require File.join(File.dirname(__FILE__), 'fixtures', 'master_listeners')
 
 class MasterTest < Test::Unit::TestCase
   context "with a file to test and a destination to verify" do
@@ -115,8 +117,8 @@ class MasterTest < Test::Unit::TestCase
         :workers => [{
           :type => :ssh,
           :connect => 'localhost',
-          :directory => File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')),
-          :runners => 1 
+          :directory => remote_dir_path,
+          :runners => 1
         }]
       )
       assert File.exists?(target_file)
@@ -178,4 +180,204 @@ class MasterTest < Test::Unit::TestCase
       assert !File.exists?(File.join(remote, 'test_b.rb')), "B was not deleted"
     end
   end
+
+  context "with a runner_end event" do
+    setup do
+      # avoid having other tests interfering with us
+      sleep(0.2)
+      FileUtils.rm_f(target_file)
+      FileUtils.rm_f(alternate_target_file)
+
+      @runner_began_flag = File.expand_path(File.join(Dir.consistent_tmpdir, 'runner_began_flag')) #used to know when the worker is ready
+      FileUtils.rm_f(@runner_began_flag)
+
+      @runner_listener = 'HydraExtension::RunnerListener::RunnerEndTest.new' # runner_end method that creates alternate_target_file
+      @master_listener = HydraExtension::Listener::WorkerBeganFlag.new  #used to know when the runner is up
+    end
+
+    teardown do
+      FileUtils.rm_f(target_file)
+      FileUtils.rm_f(alternate_target_file)
+    end
+
+    context "running a local worker" do
+      should "run runner_end on successful termination" do
+        @pid = Process.fork do
+            Hydra::Master.new(
+              :files => [test_file] * 6,
+              :autosort => false,
+              :listeners => [@master_listener],
+              :runner_listeners => [@runner_listener],
+              :verbose => false
+            )
+          end
+        Process.waitpid @pid
+
+        assert_file_exists alternate_target_file
+      end
+
+      should "run runner_end after interruption signal" do
+        add_infinite_worker_begin_to @master_listener
+
+        capture_stderr do # redirect stderr
+          @pid = Process.fork do
+            Hydra::Master.new(
+              :files => [test_file],
+              :autosort => false,
+              :listeners => [@master_listener],
+              :runner_listeners => [@runner_listener],
+              :verbose => false
+            )
+          end
+        end
+        wait_for_runner_to_begin
+
+        Process.kill 'SIGINT', @pid
+        Process.waitpid @pid
+
+        assert_file_exists alternate_target_file
+      end
+    end
+
+    context "running a remote worker" do
+      setup do
+        copy_worker_init_file # this method has a protection to avoid erasing an existing worker_init_file
+      end
+
+      teardown do
+        FileUtils.rm_f(@remote_init_file) unless @protect_init_file
+      end
+
+      should "run runner_end on successful termination" do
+        capture_stderr do # redirect stderr
+          @pid = Process.fork do
+            Hydra::Master.new(
+              :files => [test_file],
+              :autosort => false,
+              :listeners => [@master_listener],
+              :runner_listeners => [@runner_listener],
+              :workers => [{
+                :type => :ssh,
+                :connect => 'localhost',
+                :directory => remote_dir_path,
+                :runners => 1
+              }],
+              :verbose => false
+            )
+          end
+        end
+        Process.waitpid @pid
+
+        assert_file_exists alternate_target_file
+      end
+    end
+  end
+
+  context "redirecting runner's output and errors" do
+    setup do
+      # avoid having other tests interfering with us
+      sleep(0.2)
+      FileUtils.rm_f(target_file)
+      FileUtils.rm_f(runner_log_file)
+      FileUtils.rm_f("#{remote_dir_path}/#{runner_log_file}")
+    end
+
+    teardown do
+      FileUtils.rm_f(target_file)
+      FileUtils.rm_f(runner_log_file)
+      FileUtils.rm_f("#{remote_dir_path}/#{runner_log_file}")
+    end
+
+    should "create a runner log file when usign local worker and passing a log file name" do
+      @pid = Process.fork do
+        Hydra::Master.new(
+              :files => [test_file],
+              :runner_log_file => runner_log_file,
+              :verbose => false
+            )
+      end
+      Process.waitpid @pid
+
+      assert_file_exists target_file # ensure the test was successfully ran
+      assert_file_exists runner_log_file
+    end
+
+    should "create a runner log file when usign remote worker and passing a log file name" do
+      @pid = Process.fork do
+        Hydra::Master.new(
+              :files => [test_file],
+              :workers => [{
+                :type => :ssh,
+                :connect => 'localhost',
+                :directory => remote_dir_path,
+                :runners => 1
+              }],
+              :verbose => false,
+              :runner_log_file => runner_log_file
+            )
+      end
+      Process.waitpid @pid
+
+      assert_file_exists target_file # ensure the test was successfully ran
+      assert_file_exists "#{remote_dir_path}/#{runner_log_file}"
+    end
+
+    should "create the default runner log file when passing an incorrect log file path" do
+      default_log_file = "#{remote_dir_path}/#{Hydra::Runner::DEFAULT_LOG_FILE}" # hydra-runner.log"
+      FileUtils.rm_f(default_log_file)
+
+      @pid = Process.fork do
+        Hydra::Master.new(
+              :files => [test_file],
+              :workers => [{
+                :type => :ssh,
+                :connect => 'localhost',
+                :directory => remote_dir_path,
+                :runners => 1
+              }],
+              :verbose => false,
+              :runner_log_file => 'invalid-dir/#{runner_log_file}'
+            )
+      end
+      Process.waitpid @pid
+
+      assert_file_exists target_file # ensure the test was successfully ran
+      assert_file_exists default_log_file #default log file
+      assert !File.exists?( "#{remote_dir_path}/#{runner_log_file}" )
+
+      FileUtils.rm_f(default_log_file)
+    end
+  end
+
+  private
+
+  def runner_log_file
+    "my-hydra-runner.log"
+  end
+
+  def add_infinite_worker_begin_to master_listener
+    class << master_listener
+      def worker_begin( worker )
+        super
+        sleep 1 while true #ensure the process doesn't finish before killing it
+      end
+    end
+  end
+
+  #  this requires that a worker_begin listener creates a file named worker_began_flag in tmp directory
+  def wait_for_runner_to_begin
+    assert_file_exists @runner_began_flag
+  end
+
+  # with a protection to avoid erasing something important in lib
+  def copy_worker_init_file
+    @remote_init_file = "#{remote_dir_path}/#{File.basename( hydra_worker_init_file )}"
+    if File.exists?( @remote_init_file )
+      $stderr.puts "\nWARNING!!!: #{@remote_init_file} exits and this test needs to create a new file here. Make sure there is nothing inportant in that file and remove it before running this test\n\n"
+      @protect_init_file = true
+      exit
+    end
+    # copy the hydra_worker_init to the correct location
+    FileUtils.cp(hydra_worker_init_file, remote_dir_path)
+  end
 end

data/test/runner_test.rb

@@ -1,4 +1,5 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
+require File.join(File.dirname(__FILE__), 'fixtures', 'runner_listeners')
 
 class RunnerTest < Test::Unit::TestCase
   context "with a file to test and a destination to verify" do
@@ -79,46 +80,91 @@ class RunnerTest < Test::Unit::TestCase
       # because of all the crap cucumber pulls in
       # we run this in a fork to not contaminate
       # the main test environment
-      pid = Process.fork do
-        runner = Hydra::Runner.new(:io => File.new('/dev/null', 'w'))
-        runner.run_file(cucumber_feature_file)
-        assert File.exists?(target_file)
-        assert_equal "HYDRA", File.read(target_file)
-        
-        FileUtils.rm_f(target_file)
-        
-        runner.run_file(alternate_cucumber_feature_file)
-        assert File.exists?(alternate_target_file)
-        assert_equal "HYDRA", File.read(alternate_target_file)
-        assert !File.exists?(target_file)
+      capture_stderr do # redirect stderr
+        pid = Process.fork do
+          runner = Hydra::Runner.new(:io => File.new('/dev/null', 'w'))
+          runner.run_file(cucumber_feature_file)
+          assert File.exists?(target_file)
+          assert_equal "HYDRA", File.read(target_file)
+
+          FileUtils.rm_f(target_file)
+
+          runner.run_file(alternate_cucumber_feature_file)
+          assert File.exists?(alternate_target_file)
+          assert_equal "HYDRA", File.read(alternate_target_file)
+          assert !File.exists?(target_file)
+        end
+        Process.wait pid
       end
-      Process.wait pid
     end
 
     should "be able to run a runner over ssh" do
       ssh = Hydra::SSH.new(
-        'localhost', 
+        'localhost',
         File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')),
         "ruby -e \"require 'rubygems'; require 'hydra'; Hydra::Runner.new(:io => Hydra::Stdio.new, :verbose => true);\""
       )
       assert ssh.gets.is_a?(Hydra::Messages::Runner::RequestFile)
       ssh.write(Hydra::Messages::Worker::RunFile.new(:file => test_file))
-      
+
       # grab its response. This makes us wait for it to finish
       echo = ssh.gets # get the ssh echo
       response = ssh.gets
 
       assert_equal Hydra::Messages::Runner::Results, response.class
-      
+
       # tell it to shut down
       ssh.write(Hydra::Messages::Worker::Shutdown.new)
 
       ssh.close
-      
+
       # ensure it ran
       assert File.exists?(target_file)
       assert_equal "HYDRA", File.read(target_file)
     end
+
+    context "using runner events" do
+      context "on successful termination" do
+        setup do
+          @pipe = Hydra::Pipe.new
+          @parent = Process.fork do
+            request_a_file_and_verify_completion(@pipe, test_file)
+          end
+        end
+
+        should "fire runner_begin event" do
+          run_the_runner(@pipe,  [HydraExtension::RunnerListener::RunnerBeginTest.new] )
+          Process.wait(@parent)
+
+          # ensure runner_begin was fired
+          assert_file_exists alternate_target_file
+        end
+
+        should "fire runner_end event" do
+          run_the_runner(@pipe,  [HydraExtension::RunnerListener::RunnerEndTest.new] )
+          Process.wait(@parent)
+
+          assert_file_exists alternate_target_file
+        end
+      end
+
+      should "fire runner_end event after losing communication with worker" do
+        pipe = Hydra::Pipe.new
+        parent = Process.fork do
+          pipe.identify_as_parent
+
+          # grab its response.
+          response = pipe.gets
+          pipe.close #this will be detected by the runner and it should call runner_end
+        end
+
+        run_the_runner(pipe,  [HydraExtension::RunnerListener::RunnerEndTest.new] )
+        Process.wait(parent)
+
+        # ensure runner_end was fired
+        assert File.exists?( alternate_target_file )
+      end
+    end
   end
 
   module RunnerTestHelper
@@ -140,9 +186,9 @@ class RunnerTest < Test::Unit::TestCase
       assert_equal "HYDRA", File.read(target_file)
     end
 
-    def run_the_runner(pipe)
+    def run_the_runner(pipe, listeners = [])
       pipe.identify_as_child
-      Hydra::Runner.new(:io => pipe)
+      Hydra::Runner.new( :io => pipe, :runner_listeners => listeners )
     end
   end
   include RunnerTestHelper

data/test/ssh_test.rb

@@ -11,4 +11,15 @@ class SSHTest < Test::Unit::TestCase
     assert_equal "Hello World", response.text
     ssh.close
   end
+
+  should "be able to handle a large number of non-Hydra console output" do
+    ssh = Hydra::SSH.new(
+      'localhost', # connect to this machine
+      File.expand_path(File.join(File.dirname(__FILE__))), # move to the test directory
+      "ruby fixtures/many_outputs_to_console.rb"
+    )
+    response = ssh.gets
+    assert_equal "My message", response.text
+    ssh.close
+  end
 end