gearman-ruby 2.0.0 → 3.0.1

data/test/mock_worker_test.rb

@@ -0,0 +1,321 @@
+#!/usr/bin/env ruby
+
+$:.unshift('../lib')
+require 'gearman'
+require 'gearman/testlib'
+require 'test/unit'
+require 'thread'
+
+Thread.abort_on_exception = true
+
+class TestWorker < Test::Unit::TestCase
+  def setup
+    @server = FakeJobServer.new(self)
+    @server2 = FakeJobServer.new(self)
+  end
+
+  def teardown
+    @server.stop
+    @server2.stop
+  end
+
+  def test_complete
+    @server = FakeJobServer.new(self)
+    worker = nil
+    sock = nil
+
+    s = TestScript.new
+    w = TestScript.new
+
+    server_thread = Thread.new { s.loop_forever }.run
+    worker_thread = Thread.new { w.loop_forever }.run
+
+    # Create a worker and wait for it to connect to us.
+    w.exec {
+      worker = Gearman::Worker.new(
+        "localhost:#{@server.port}", { :client_id => 'test' })
+    }
+    s.exec { sock = @server.expect_connection }
+    s.wait
+
+    # After it connects, it should send its ID, and it should tell us its
+    # abilities when we report them.
+    s.exec { @server.expect_request(sock, :set_client_id, 'test') }
+    w.exec do
+      worker.add_ability('echo') do |data, job| 
+        job.report_status(1, 1);
+        part1, part2 = data.split(//, 2)
+        job.send_data(part1) # send partial data first
+        part2
+      end
+    end
+    s.exec { @server.expect_request(sock, :can_do, 'echo') }
+
+    # It should try to grab a job when we tell it to work.
+    w.exec { worker.work }
+    s.exec { @server.expect_request(sock, :grab_job) }
+
+    # If we tell it there aren't any jobs, it should go to sleep.
+    s.exec { @server.send_response(sock, :no_job) }
+    s.exec { @server.expect_request(sock, :pre_sleep) }
+
+    # When we send it a noop, it should wake up and ask for a job again.
+    s.exec { @server.send_response(sock, :noop) }
+    s.exec { @server.expect_request(sock, :grab_job) }
+
+    # When we give it a job, it should do it.
+    s.exec { @server.send_response(sock, :job_assign, "a\0echo\0foo") }
+    s.exec { @server.expect_request(sock, :work_status, "a\0001\0001") }
+    s.exec { @server.expect_request(sock, :work_data, "a\000f") }
+    s.exec { @server.expect_request(sock, :work_complete, "a\0oo") }
+
+    # Test that functions are unregistered correctly.
+    w.exec { worker.remove_ability('echo') }
+    s.exec { @server.expect_request(sock, :cant_do, 'echo') }
+    s.wait
+  end
+
+  def test_multiple_servers
+    # This is cheesy.  We want to know the order that Worker#work will
+    # iterate through the servers, so we make sure that server1 will be the
+    # first one when the names are lexographically sorted.
+    if @server2.port.to_s < @server.port.to_s
+      tmp = @server
+      @server = @server2
+      @server2 = tmp
+    end
+    worker = nil
+    sock1, sock2 = nil
+
+    s1 = TestScript.new
+    s2 = TestScript.new
+    w = TestScript.new
+
+    @server_thread = Thread.new { s1.loop_forever }.run
+    @server2_thread = Thread.new { s2.loop_forever }.run
+    worker_thread = Thread.new { w.loop_forever }.run
+
+    # Create a worker, which should connect to both servers.
+    w.exec {
+      worker = Gearman::Worker.new(
+        nil, { :client_id => 'test', :reconnect_sec => 0.1 }) }
+    w.exec { worker.add_ability('foo') {|d,j| 'bar' } }
+    w.exec {
+      worker.job_servers =
+        [ "localhost:#{@server.port}", "localhost:#{@server2.port}" ]
+    }
+    s1.exec { sock1 = @server.expect_connection }
+    s2.exec { sock2 = @server2.expect_connection }
+    s1.wait
+    s2.wait
+
+    # It should register itself with both.
+    s1.exec { @server.expect_request(sock1, :set_client_id, 'test') }
+    s1.exec { @server.expect_request(sock1, :can_do, 'foo') }
+    s2.exec { @server2.expect_request(sock2, :set_client_id, 'test') }
+    s2.exec { @server2.expect_request(sock2, :can_do, 'foo') }
+
+    # It should try to get a job from both servers and then sleep.
+    w.exec { worker.work }
+    s1.exec { @server.expect_request(sock1, :grab_job) }
+    s1.exec { @server.send_response(sock1, :no_job) }
+    s2.exec { @server2.expect_request(sock2, :grab_job) }
+    s2.exec { @server2.send_response(sock2, :no_job) }
+    s1.exec { @server.expect_request(sock1, :pre_sleep) }
+    s2.exec { @server2.expect_request(sock2, :pre_sleep) }
+
+    # If the second server wakes it up, it should again try to get a job
+    # and then do it.
+    s2.exec { @server2.send_response(sock2, :noop) }
+    s1.exec { @server.expect_request(sock1, :grab_job) }
+    s1.exec { @server.send_response(sock1, :no_job) }
+    s2.exec { @server2.expect_request(sock2, :grab_job) }
+    s2.exec { @server2.send_response(sock2, :job_assign, "a\0foo\0") }
+    s2.exec { @server2.expect_request(sock2, :work_complete, "a\0bar") }
+
+    w.wait
+    s1.wait
+    s2.wait
+
+    # Stop the first job server and make the worker try to reconnect to
+    # both.
+    old_servers = worker.job_servers
+    @server.stop
+    worker.job_servers = []
+    worker.job_servers = old_servers
+    s2.exec { sock2 = @server2.expect_connection }
+    s2.wait
+
+    # It shouldn't have any trouble with the second server.  Tell it to go
+    # to work.
+    s2.exec { @server2.expect_request(sock2, :set_client_id, 'test') }
+    s2.exec { @server2.expect_request(sock2, :can_do, 'foo') }
+    w.exec { worker.work }
+    s2.exec { @server2.expect_request(sock2, :grab_job) }
+    s2.exec { @server2.send_response(sock2, :no_job) }
+    s2.exec { @server2.expect_request(sock2, :pre_sleep) }
+    s2.wait
+
+    # Start the first server and wait for the worker to connect to it and
+    # register.
+    @server.start
+    s1.exec { sock1 = @server.expect_connection }
+    s1.wait
+    s1.exec { @server.expect_request(sock1, :set_client_id, 'test') }
+    s1.exec { @server.expect_request(sock1, :can_do, 'foo') }
+    s1.wait
+
+    # Let the second server wake the worker up and then give it a job.
+    s2.exec { @server2.send_response(sock2, :noop) }
+    s1.exec { @server.expect_request(sock1, :grab_job) }
+    s1.exec { @server.send_response(sock1, :no_job) }
+    s2.exec { @server2.expect_request(sock2, :grab_job) }
+    s2.exec { @server2.send_response(sock2, :job_assign, "a\0foo\0") }
+    s2.exec { @server2.expect_request(sock2, :work_complete, "a\0bar") }
+    s1.wait
+    s2.wait
+    w.wait
+  end
+
+  def test_timeout
+    worker = nil
+    sock = nil
+
+    s = TestScript.new
+    w = TestScript.new
+
+    server_thread = Thread.new { s.loop_forever }.run
+    worker_thread = Thread.new { w.loop_forever }.run
+
+    w.exec {
+      worker = Gearman::Worker.new("localhost:#{@server.port}",
+        { :client_id => 'test',
+          :reconnect_sec => 0.15,
+          :network_timeout_sec => 0.1 })
+    }
+    s.exec { sock = @server.expect_connection }
+    s.wait
+    s.exec { @server.expect_request(sock, :set_client_id, 'test') }
+
+    w.exec { worker.add_ability('foo') {|d,j| 'bar' } }
+    s.exec { @server.expect_request(sock, :can_do, 'foo') }
+
+    # Don't do anything after the client asks for a job.
+    w.exec { worker.work }
+    s.exec { @server.expect_request(sock, :grab_job) }
+    s.exec { sleep 0.16 }
+    s.wait
+
+    # The client should reconnect and ask for a job again.
+    s.exec { sock = @server.expect_connection }
+    s.wait
+
+    s.exec { @server.expect_request(sock, :set_client_id, 'test') }
+    s.exec { @server.expect_request(sock, :can_do, 'foo') }
+    s.exec { @server.expect_request(sock, :grab_job) }
+    s.exec { @server.send_response(sock, :job_assign, "a\0foo\0") }
+    s.exec { @server.expect_request(sock, :work_complete, "a\0bar") }
+    s.wait
+    w.wait
+  end
+
+  def test_exception
+    @server = FakeJobServer.new(self)
+    worker = nil
+    sock = nil
+
+    s = TestScript.new
+    w = TestScript.new
+
+    server_thread = Thread.new { s.loop_forever }.run
+    worker_thread = Thread.new { w.loop_forever }.run
+
+    # Create a worker and wait for it to connect to us.
+    w.exec {
+      worker = Gearman::Worker.new(
+        "localhost:#{@server.port}", { :client_id => 'test' })
+    }
+    s.exec { sock = @server.expect_connection }
+    s.wait
+
+    # After it connects, it should send its ID, and it should tell us its
+    # abilities when we report them.
+    s.exec { @server.expect_request(sock, :set_client_id, 'test') }
+    w.exec { worker.add_ability('echo') {|d,j| raise Exception.new("fooexception") } }
+    s.exec { @server.expect_request(sock, :can_do, 'echo') }
+
+    # It should try to grab a job when we tell it to work.
+    w.exec { worker.work }
+    s.exec { @server.expect_request(sock, :grab_job) }
+
+    # If we tell it there aren't any jobs, it should go to sleep.
+    s.exec { @server.send_response(sock, :no_job) }
+    s.exec { @server.expect_request(sock, :pre_sleep) }
+
+    # When we send it a noop, it should wake up and ask for a job again.
+    s.exec { @server.send_response(sock, :noop) }
+    s.exec { @server.expect_request(sock, :grab_job) }
+
+    # When we give it a job, it should raise an excpetion and notify the server
+    s.exec { @server.send_response(sock, :job_assign, "a\0echo\0foo") }
+    s.exec do
+      @server.expect_request(sock, :work_warning, "a\0fooexception")
+      @server.expect_request(sock, :work_fail, "a")
+    end
+
+    s.wait
+  end
+  
+  def test_worker_enabled
+    @server = FakeJobServer.new(self)
+    worker = nil
+    sock = nil
+    @result = nil
+
+    s = TestScript.new
+    w = TestScript.new
+
+    server_thread = Thread.new { s.loop_forever }.run
+    worker_thread = Thread.new { w.loop_forever }.run
+
+    # Create a worker and wait for it to connect to us.
+    w.exec {
+      worker = Gearman::Worker.new(
+        "localhost:#{@server.port}", { :client_id => 'test' })
+    }
+    s.exec { sock = @server.expect_connection }
+    s.wait
+
+    # After it connects, it should send its ID, and it should tell us its
+    # abilities when we report them.
+    s.exec { @server.expect_request(sock, :set_client_id, 'test') }
+    w.exec do
+      worker.add_ability('echo') do |data, job| 
+        job.report_status(1, 1);
+        part1, part2 = data.split(//, 2)
+        job.send_data(part1) # send partial data first
+        part2
+      end
+    end
+    s.exec { @server.expect_request(sock, :can_do, 'echo') }
+
+    # When we set to false worker_enabled, worker.work shall return false
+    s.exec { @server.send_response(sock, :job_assign, "a\0echo\0foo") }
+    w.exec { worker.worker_enabled = false; @result = worker.work }
+    w.wait
+    assert_equal false, @result
+
+    # When we set to true worker_enabled, worker.work shall return true
+    s.exec { @server.send_response(sock, :job_assign, "a\0echo\0foo") }
+    w.exec { worker.worker_enabled = true; @result = worker.work }
+    w.wait
+    assert_equal true, @result
+
+    # when there are no jobs pending, and set to false worker_enabled, worker.work shall return false
+    s.exec { @server.send_response(sock, :no_job) }
+    w.exec { worker.worker_enabled = false; @result = worker.work }
+    w.wait
+    assert_equal false, @result
+  end
+  
+end

data/test/util_test.rb

@@ -1,6 +1,11 @@
-require File.dirname(__FILE__) + '/test_helper'
+#!/usr/bin/env ruby
 
-class UtilTest < Test::Unit::TestCase
+$:.unshift('../lib')
+require 'gearman'
+require 'gearman/testlib'
+require 'test/unit'
+
+class TestUtil < Test::Unit::TestCase
 
   def test_ability_prefix_name_builder
     assert_equal(Gearman::Util.ability_name_with_prefix("test","a"),"test\ta")
@@ -8,5 +13,5 @@ class UtilTest < Test::Unit::TestCase
 
   def test_ability_name_for_perl
     assert_equal(Gearman::Util.ability_name_for_perl("test","a"),"test\ta")
-  end
+  end  
 end

data/test/worker_test.rb

@@ -1,45 +1,61 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-class WorkerTest < Test::Unit::TestCase
-
-  def test_accepts_multiple_job_servers
-    Gearman::Evented::WorkerReactor.expects(:connect).times(2)
-
-    EM.run do
-      EM.add_timer(0.1) { EM.stop_event_loop }
-      Gearman::Worker.new(["localhost:4730", "localhost:4731"]).work
-    end
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'mocha'
+
+$:.unshift('../lib')
+require 'gearman'
+require 'gearman/testlib'
+require 'test/unit'
+
+class TestClient < Test::Unit::TestCase
+  ##
+  # Test Gearman::Worker::Ability.
+  def test_ability
+    data, job = nil
+    ability = Gearman::Worker::Ability.new(
+      Proc.new {|d, j| data = d; job = j; true }, 5)
+    assert_equal(5, ability.timeout)
+    assert_equal(true, ability.run(1, 2))
+    assert_equal(1, data)
+    assert_equal(2, job)
   end
 
-  def test_accepts_exactly_one_job_server
-    Gearman::Evented::WorkerReactor.expects(:connect).with("localhost", "4730", {:abilities => {}}).times(1)
-
-    EM.run do
-      EM.add_timer(0.1) { EM.stop_event_loop }
-      Gearman::Worker.new("localhost:4730").work
-    end
+  ##
+  # Test Gearman::Worker::Job.
+  def test_job
+    server = FakeJobServer.new(self)
+    Thread.new do
+      sock = TCPSocket.new('localhost', server.port)
+      job = Gearman::Worker::Job.new(sock, 'handle')
+      job.report_status(10, 20)
+    end.run
+    sock = server.expect_connection
+    server.expect_request(sock, :work_status, "handle\00010\00020")
   end
 
-  def test_passes_abilities_to_reactor
-    worker = Gearman::Worker.new("localhost:4730")
-    worker.add_ability("foo") {|data, job| "noop!"}
-    worker.add_ability("bar") {|data, job| "nothing to see here!" }
-    worker.remove_ability("bar")
 
-    assert_equal true, worker.has_ability?("foo")
-    assert_equal false, worker.has_ability?("bar")
+  def test_job_reconnection
+    server = FakeJobServer.new(self)
+    Thread.new do
+      sock = server.expect_connection
+      server.expect_anything_and_close_socket(sock)
+    end
 
-    Gearman::Evented::WorkerReactor.expects(:connect).with do |host, port, opts|
-      assert_equal "localhost", host
-      assert_equal 4730, port.to_i
-      assert_equal 1, opts[:abilities].size
-      assert_equal true, opts[:abilities]['foo'][:callback].is_a?(Proc)
+    servers = ["localhost:#{server.port}"]
+    w = Gearman::Worker.new(servers)
+    Gearman::Util.stubs(:send_request).raises(Exception.new)
+    w.add_ability('sleep') do |data,job|
+      seconds = data
+      (1..seconds.to_i).each do |i|
+        sleep 1
+        print i
+        # Report our progress to the job server every second.
+        job.report_status(i, seconds)
+      end
+      # Report success.
       true
     end
 
-    EM.run do
-      EM.add_timer(0.1) { EM.stop_event_loop }
-      worker.work
-    end
+    assert(w.bad_servers.size == 1)
   end
 end

metadata

@@ -1,29 +1,32 @@
 --- !ruby/object:Gem::Specification 
 name: gearman-ruby
 version: !ruby/object:Gem::Version 
-  version: 2.0.0
+  prerelease: false
+  segments: 
+  - 3
+  - 0
+  - 1
+  version: 3.0.1
 platform: ruby
 authors: 
+- John Ewart
+- Colin Curtin
+- Daniel Erat
+- Ladislav Martincik
+- Pablo Delgado
+- Mauro Pompilio
+- Antonio Garrote
 - Kim Altintop
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-12-11 00:00:00 +01:00
+date: 2010-07-19 00:00:00 -07:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: eventmachine
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 0.12.8
-    version: 
+dependencies: []
+
 description: Library for the Gearman distributed job system
-email: kim.altintop@gmail.com
+email: john@unixninjas.org
 executables: []
 
 extensions: []
@@ -41,13 +44,14 @@ files:
 - VERSION.yml
 - examples/calculus_client.rb
 - examples/calculus_worker.rb
+- examples/client.php
 - examples/client.rb
 - examples/client_background.rb
 - examples/client_data.rb
+- examples/client_epoch.rb
 - examples/client_exception.rb
 - examples/client_prefix.rb
-- examples/evented_client.rb
-- examples/evented_worker.rb
+- examples/client_reverse.rb
 - examples/gearman_environment.sh
 - examples/scale_image.rb
 - examples/scale_image_worker.rb
@@ -56,28 +60,24 @@ files:
 - examples/worker_data.rb
 - examples/worker_exception.rb
 - examples/worker_prefix.rb
-- gearman-ruby.gemspec
+- examples/worker_reverse_string.rb
+- examples/worker_reverse_to_file.rb
+- examples/worker_signals.rb
 - lib/gearman.rb
 - lib/gearman/client.rb
-- lib/gearman/evented/client.rb
-- lib/gearman/evented/reactor.rb
-- lib/gearman/evented/worker.rb
-- lib/gearman/job.rb
-- lib/gearman/protocol.rb
 - lib/gearman/server.rb
 - lib/gearman/task.rb
 - lib/gearman/taskset.rb
+- lib/gearman/testlib.rb
 - lib/gearman/util.rb
 - lib/gearman/worker.rb
-- test/basic_integration_test.rb
-- test/crash_test.rb
-- test/job_test.rb
-- test/protocol_test.rb
-- test/test_helper.rb
+- test/client_test.rb
+- test/mock_client_test.rb
+- test/mock_worker_test.rb
 - test/util_test.rb
 - test/worker_test.rb
 has_rdoc: true
-homepage: http://github.com/kim/gearman-ruby
+homepage: http://github.com/gearman-ruby/gearman-ruby
 licenses: []
 
 post_install_message: 
@@ -89,27 +89,27 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Library for the Gearman distributed job system
 test_files: 
-- test/basic_integration_test.rb
-- test/crash_test.rb
-- test/job_test.rb
-- test/protocol_test.rb
-- test/test_helper.rb
+- test/client_test.rb
+- test/mock_client_test.rb
+- test/mock_worker_test.rb
 - test/util_test.rb
 - test/worker_test.rb
 - examples/calculus_client.rb
@@ -117,17 +117,17 @@ test_files:
 - examples/client.rb
 - examples/client_background.rb
 - examples/client_data.rb
-- examples/client_echo.rb
+- examples/client_epoch.rb
 - examples/client_exception.rb
 - examples/client_prefix.rb
-- examples/evented_client.rb
-- examples/evented_worker.rb
+- examples/client_reverse.rb
 - examples/scale_image.rb
 - examples/scale_image_worker.rb
 - examples/server.rb
 - examples/worker.rb
 - examples/worker_data.rb
-- examples/worker_echo.rb
-- examples/worker_echo_pprof.rb
 - examples/worker_exception.rb
 - examples/worker_prefix.rb
+- examples/worker_reverse_string.rb
+- examples/worker_reverse_to_file.rb
+- examples/worker_signals.rb