gearman-ruby 3.0.8 → 4.0.2

data/lib/gearman/worker/ability.rb

@@ -0,0 +1,55 @@
+module Gearman
+  class Worker
+
+    class Ability
+      ##
+      # Create a new ability. Setting timeout means we register with CAN_DO_TIMEOUT
+      # @param func_name  Function name of this ability
+      # @param block      Code to run
+      # @param timeout    Server gives up on us after this many seconds
+      def initialize(func_name, block, timeout=nil)
+        @func_name = func_name
+        @block = block
+        @timeout = timeout
+        @on_complete = nil
+      end
+
+      attr_reader :timeout, :func_name
+
+      ##
+      # Run the block of code given for a job of this type.
+      #
+      # @param data  data passed to us by a client
+      # @param job   interface to report job information to the server
+      def run(data, job)
+        begin
+          result = @block.call(data, job) if @block
+          @on_complete.call(result, data) if @on_complete
+          return result
+        rescue => ex
+          raise ex
+        end
+      end
+
+      ##
+      # Add an after-ability hook
+      #
+      # The passed-in block of code will be executed after the work block for
+      # jobs with the same function name. It takes two arguments, the result of
+      # the work and the original job data. This way, if you need to hook into
+      # *after* the job_complete packet is sent to the server, you can do so.
+      #
+      # N.B The after-ability hook ONLY runs if the ability was successful and no
+      # exceptions were raised.
+      #
+      # @param func     function name (without prefix)
+      #
+      def after_complete(&block)
+        @on_complete = block
+      end
+
+
+    end
+
+  end
+end

data/lib/gearman/worker/callbacks.rb

@@ -0,0 +1,39 @@
+# Provides callbacks for internal worker use:
+#
+# def named_metric(metric)
+#   "HardWorker.#{Process.pid}.#{metric}"
+# end
+#
+# worker = Gearman::Worker.new
+# worker.on_grab_job { StatsD.increment(named_metric('grab_job')) }
+# worker.on_job_assign { StatsD.increment(named_metric('job_assign')) }
+# worker.on_no_job { StatsD.increment(named_metric('no_job')) }
+# worker.on_work_complete { StatsD.increment(named_metric('work_complete')) }
+
+module Gearman
+  class Worker
+
+    module Callbacks
+
+      %w(connect grab_job no_job job_assign work_complete work_fail
+         work_exception).each do |event|
+
+        define_method("on_#{event}") do |&callback|
+          instance_variable_set("@__on_#{event}", callback)
+        end
+
+        define_method("run_#{event}_callback") do
+          callback = instance_variable_get("@__on_#{event}")
+          return unless callback
+
+          begin
+            callback.call
+          rescue Exception => e
+            logger.error "#{event} failed: #{e.inspect}"
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/gearman/worker/job.rb

@@ -0,0 +1,44 @@
+module Gearman
+  class Worker
+
+    class Job
+      ##
+      # Create a new Job.
+      #
+      # @param sock    Socket connected to job server
+      # @param handle  job server-supplied job handle
+      attr_reader :handle
+
+      def initialize(connection, handle)
+        @connection = connection
+        @handle = handle
+      end
+
+      ##
+      # Report our status to the job server.
+      def report_status(numerator, denominator)
+        req = Packet.pack_request(:work_status, "#{@handle}\0#{numerator}\0#{denominator}")
+        @connection.send_update(req)
+        self
+      end
+
+      ##
+      # Send data before job completes
+      def send_data(data)
+        req = Packet.pack_request(:work_data, "#{@handle}\0#{data}")
+        @connection.send_update(req)
+        self
+      end
+
+      ##
+      # Send a warning explicitly
+      def report_warning(warning)
+        req = Packet.pack_request(:work_warning, "#{@handle}\0#{warning}")
+        @connection.send_update(req)
+        self
+      end
+    end
+
+  end
+end
+

data/spec/client_spec.rb

@@ -1,19 +1,22 @@
 require 'spec_helper'
 require 'socket'
-require 'rspec'
-require 'rspec/mocks'
-require 'gearman'
 
 describe Gearman::Client do
   before(:all) do
     @tcp_server = TCPServer.new 5789
-    @client = Gearman::Client.new(["localhost:5789"])
   end
 
   after(:all) do
     @tcp_server.close
   end
 
+  before(:each) do
+    @mock_connection_pool = double(Gearman::ConnectionPool)
+    Gearman::ConnectionPool.stub(:new).and_return @mock_connection_pool
+
+    @client = Gearman::Client.new(["localhost:5789"])
+  end
+
   it "creates a client" do
     @client.should_not be nil
   end
@@ -30,31 +33,40 @@ describe Gearman::Client do
 
   it "raises an exception when submitting a job fails" do
     task = Gearman::Task.new("queue", "data")
-    @client.should_receive(:get_job_server).and_raise Gearman::NoJobServersError
+    @mock_connection_pool.should_receive(:get_connection).and_raise Gearman::NoJobServersError
     expect {
       @client.do_task(task)
-    }.to raise_error
+    }.to raise_exception
   end
 
-  it "gets a socket for the client's host:port combo" do
-    sock = @client.get_socket("localhost:5789")
-    sock.should_not be nil
-  end
+  it "properly emits an options request" do
+    mock_connection = double(Gearman::Connection)
+    mock_connection.should_receive(:send_request).and_return([:error, "Snarf"])
 
-  it "closes sockets it doesn't know about when asked to return them" do
-    sock = double(TCPSocket)
-    sock.should_receive(:addr).and_return [nil, 1234, 'hostname', '1.2.3.4']
-    sock.should_receive(:close)
-    @client.return_socket(sock)
-  end
+    @mock_connection_pool.should_receive(:with_all_connections).and_yield mock_connection
 
-  it "properly emits an options request" do
-    Gearman::Util.should_receive(:send_request)
-    Gearman::Util.should_receive(:read_response).and_return([:error, "Snarf"])
     expect {
-      @client.option_request("exceptions")
+      @client.set_options("exceptions")
     }.to raise_error
 
   end
 
+
+
+  it "should raise a NetworkError when it didn't write as much as expected to a socket" do
+    socket = double(TCPSocket)
+    socket.should_receive(:write).with(anything).and_return(0)
+
+    task = Gearman::Task.new("job_queue", "data")
+    request = task.get_submit_packet
+    connection = Gearman::Connection.new("localhost", 1234)
+    connection.should_receive(:socket).and_return socket
+
+    expect {
+      connection.send_request(request)
+    }.to raise_error
+  end
+
+
+
 end

data/spec/connection_pool_spec.rb

@@ -0,0 +1,55 @@
+
+require 'spec_helper'
+require 'socket'
+
+describe Gearman::ConnectionPool do
+  context "normalizing job servers" do
+    before :each do
+      @connection_pool = Gearman::ConnectionPool.new
+    end
+
+    it "should handle a string for input" do
+      connection = Gearman::Connection.new("localhost", 1234)
+      connection.should_receive(:is_healthy?).and_return true
+      Gearman::Connection.should_receive(:new).with("localhost", 1234).and_return connection
+      @connection_pool.add_servers("localhost:1234")
+      @connection_pool.get_connection.should be connection
+    end
+
+    it "should handle an array of host:port without changing a thing" do
+      connection_one = Gearman::Connection.new("localhost", 123)
+      connection_one.should_receive(:is_healthy?).and_return true
+      connection_two = Gearman::Connection.new("localhost", 456)
+      connection_two.should_receive(:is_healthy?).and_return true
+
+      Gearman::Connection.should_receive(:new).with("localhost", 123).and_return connection_one
+      Gearman::Connection.should_receive(:new).with("localhost", 456).and_return connection_two
+
+      servers = [ "#{connection_one.to_host_port}", "#{connection_two.to_host_port}" ]
+      @connection_pool.add_servers(servers)
+
+
+      @connection_pool.get_connection.should be connection_two
+      @connection_pool.get_connection.should be connection_one
+
+    end
+
+    it "should append the default port to anything in the array that doesn't have a port" do
+      in_servers = ["foo.bar.com:123", "narf.quiddle.com"]
+      out_servers = ["foo.bar.com:123", "narf.quiddle.com:4730"]
+
+      connection_one = Gearman::Connection.new("foo.bar.com", 123)
+      connection_one.should_receive(:is_healthy?).and_return true
+      connection_two = Gearman::Connection.new("narf.quiddle.com", 4730)
+      connection_two.should_receive(:is_healthy?).and_return true
+
+      Gearman::Connection.should_receive(:new).with("foo.bar.com", 123).and_return connection_one
+      Gearman::Connection.should_receive(:new).with("narf.quiddle.com", 4730).and_return connection_two
+
+      @connection_pool.add_servers(in_servers)
+
+      @connection_pool.get_connection.should be connection_two
+      @connection_pool.get_connection.should be connection_one
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,4 +1,6 @@
 require 'simplecov'
+require 'rspec'
+require 'rspec/mocks'
 
 SimpleCov.start do
   add_filter "/spec/"
@@ -8,6 +10,9 @@ end
 $:.unshift(File.expand_path('../lib', __FILE__))
 require 'gearman'
 
+Gearman.logger = Logger.new(STDERR)
+Gearman.logger.level = Logger::DEBUG
+
 RSpec.configure do |config|
   config.mock_with :rspec
 end

data/spec/task_spec.rb

@@ -16,6 +16,16 @@ describe Gearman::Task do
       }.to raise_error
     end
 
+    it "should generate a task from two arguments" do
+      task = Gearman::Task.new("queue", "data")
+      task.should_not be nil
+    end
+
+    it "should generate a task from three arguments" do
+      task = Gearman::Task.new("queue", "data", {:background => true})
+      task.should_not be nil
+    end
+
     it "generates a uniq value based on the data and the function" do
       hash_data = 'bc2ca93d86a28cb72fedf36326d1da0cc3d4ed6a'
       task_one = Gearman::Task.new("unique_id", "abcdef")

data/spec/taskset_spec.rb

@@ -13,7 +13,7 @@ describe Gearman::TaskSet do
 
   end
 
-  it "handles a NetworkError when submitting a job" do
+  xit "handles a NetworkError when submitting a job" do
     bad_socket = double(TCPSocket)
     bad_socket.should_receive(:write) { |*args|
       args[0].length
@@ -41,7 +41,7 @@ describe Gearman::TaskSet do
     task_set.add_task(task)
   end
 
-  it "waits for an answer from the server" do
+  xit "waits for an answer from the server" do
     good_socket = double(TCPSocket)
     good_socket.should_receive(:write) { |*args|
       args[0].length

metadata

@@ -1,21 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gearman-ruby
 version: !ruby/object:Gem::Version
-  version: 3.0.8
+  version: 4.0.2
 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: 2013-07-25 00:00:00.000000000 Z
+date: 2014-11-29 00:00:00.000000000 Z
 dependencies: []
 description: Library for the Gearman distributed job system
 email: john@johnewart.net
@@ -23,54 +16,42 @@ executables: []
 extensions: []
 extra_rdoc_files:
 - LICENSE
-- README
-- TODO
+- README.md
 files:
 - .gitignore
+- .travis.yml
 - CHANGELOG.md
 - Gemfile
-- HOWTO
 - LICENSE
-- README
+- README.md
 - Rakefile
-- TODO
-- 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/client_reverse.rb
-- examples/gearman_environment.sh
-- examples/scale_image.rb
-- examples/scale_image_worker.rb
-- examples/server.rb
+- examples/client_reverse_nohost.rb
+- examples/client_reverse_wait.rb
 - examples/worker.rb
-- examples/worker_data.rb
-- examples/worker_exception.rb
-- examples/worker_prefix.rb
 - examples/worker_reverse_string.rb
-- examples/worker_reverse_to_file.rb
-- examples/worker_signals.rb
 - gearman-ruby.gemspec
 - lib/gearman.rb
 - lib/gearman/client.rb
+- lib/gearman/connection.rb
+- lib/gearman/connection_pool.rb
+- lib/gearman/exceptions.rb
+- lib/gearman/logging.rb
+- lib/gearman/packet.rb
 - lib/gearman/server.rb
 - lib/gearman/task.rb
-- lib/gearman/taskset.rb
-- lib/gearman/util.rb
+- lib/gearman/task_set.rb
 - lib/gearman/version.rb
 - lib/gearman/worker.rb
+- lib/gearman/worker/ability.rb
+- lib/gearman/worker/callbacks.rb
+- lib/gearman/worker/job.rb
 - spec/client_spec.rb
+- spec/connection_pool_spec.rb
 - spec/spec_helper.rb
 - spec/support/fake_tcp_socket.rb
 - spec/task_spec.rb
 - spec/taskset_spec.rb
-- spec/util_spec.rb
 - test/client_test.rb
 - test/mock_client_test.rb
 - test/mock_worker_test.rb
@@ -102,11 +83,11 @@ specification_version: 4
 summary: Ruby Gearman library
 test_files:
 - spec/client_spec.rb
+- spec/connection_pool_spec.rb
 - spec/spec_helper.rb
 - spec/support/fake_tcp_socket.rb
 - spec/task_spec.rb
 - spec/taskset_spec.rb
-- spec/util_spec.rb
 - test/client_test.rb
 - test/mock_client_test.rb
 - test/mock_worker_test.rb

data/HOWTO

@@ -1,146 +0,0 @@
-= GEARMAN
-
-"Gearman provides a generic application framework to farm out work to other 
-machines or processes that are better suited to do the work. It allows you to 
-do work in parallel, to load balance processing, and to call functions between 
-languages. It can be used in a variety of applications, from high-availability 
-web sites to the transport of database replication events. In other words, it 
-is the nervous system for how distributed processing communicates."
-
- - http://www.gearman.org/
-
-
-== Setting up a basic environment
-
-A very basic Gearman environment will look like this:
-
-                       ----------  
-                       | Client |  
-                       ----------  
-                           |
-                     --------------     
-                     | Job Server |     
-                     --------------     
-                           |
-    ----------------------------------------------
-    |              |              |              |
-----------     ----------     ----------     ----------
-| Worker |     | Worker |     | Worker |     | Worker |
-----------     ----------     ----------     ----------
-
-And the behavior will be the following:
-
- * JobServer: Acts as a message passing point.
- * Client: Sends tasks to the JobServer. Will be connected to only one JobServer
-           in case more than one exits for failover purposes.
- * Worker: Anounce his 'abilities' to the JobServer and waits for tasks.
-
-For the JobServer we recommend to use the offical Perl version, there's also a
-more performant C implementation of the server with support for persistent
-queues, bells and whistles but is not stable enough for production use at the 
-time of this document was wrote.
-
-The Client and the Worker can be implemented in any language. This way you can
-send tasks from a Ruby client server, to a Perl or C worker in order to get 
-better performance.
-
-== Installing the required software
-
-For the JobServer we recommend to use the offical Perl version, to install it:
-
- * Mac OS X: sudo port install p5-gearman-server
- * Debian/Ubuntu: sudo apt-get install gearman-server
-
-To get the Ruby libraries by Xing:
-
- git clone git://github.com/xing/gearman-ruby.git
-
-== Gearman demo
-
-Now you're ready for you first experience with Gearman. In the cloned repository
-you'll find an 'examples' directory.
-
-Run the 'gearman_environment.sh' to build an environment like the one showed in
-the diagram above.
-
-  * Client: Will ask you for an arithmetic operation, like: 2+3
-            The code of the client is in: 'examples/calculus_client.rb'
-
-  * JobServer: The Perl server.
-
-  * Workers: You'll have 4 worker, one for each of the basic arithmetic 
-             operations.
-             The code of the worker is in: 'examples/calculus_worker.rb'
-
-There are other demos in the examples folder you can give a look at. Each demo usually
-consist in the client and server scripts.
-
-=== Creating clients and tasks
-
-In order to get a job scheduled by a Gearman server using the gearman ruby library, there
-are three main objects you must interact with: Gearman::Client, Gearman::Task and Gearman::TaskSet.
-Let's review all of them briefly:
-
-  - Gearman::Client -> the portion of the library storing the data about the connection to 
-                       the Gearman server.
-  - Gearman::Task -> a job execution request that will be dispatched by the Gearman server to 
-                     worker and whose result data will be returned to the client.
-  - Gearman::TaskSet -> a collection of tasks to be executed. The Taskset object will track the
-                        execution of the tasks with the info returned from the Gearman server
-                        and notify the client with the results or errors when all the tasks
-                        have completed their execution.
-
-To send a new task to the Gearman server, the client must build a new Gearman::Task object, add it to
-a Gearman::TaskSet that must hold a reference to a Gearman::Client and send the wait message to
-the TaskSet.
-The following code taken from examples/client.rb shows the process:
-
-----------------------------------------------------
-servers = ['localhost:4730', 'localhost:4731']
-  
-client = Gearman::Client.new(servers)
-taskset = Gearman::TaskSet.new(client)
-
-task = Gearman::Task.new('sleep', 20)
-task.on_complete {|d| puts d }
-
-taskset.add_task(task)
-taskset.wait(100)
-----------------------------------------------------
-
-The name of the function to be executed is the first parameter to the constructor of the Task object.
-Take into account that the string you pass as a parameter will be used 'as it' by the Gearman server
-to locate a suitable worker for that function.
-The second parameter is the argument to be sent to the worker that will execute, if the arguments for
-the task are complex, a serialization format like YAML or XML must be agreeded with the workers.
-The last and optional parameter is a hash of options. The following options are currently available:
-
-  - :priority -> (:high | :low) the priority of the job, a high priority job is executed before a low on
-  - :background -> (true | false) a background task will return no further information to the client.
-
-The execution of a task in a Gearman remote worker can fail, the worker can throw an exception, etc.
-All these events can be handled by the client of the ruby library registering callback blocks.
-The following events are currently available:
-
-  - on_complete -> the task was executed succesfully
-  - on_fail -> the task fail for some unknown reason
-  - on_retry -> after failure, the task is gonna be retried, the number of retries is passed
-  - on_exception -> the remote worker send an exception notification, the exception text is passed
-  - on_stauts -> a status update is sent by the remote worker
-
-In order to receive exception notifications in the client, this option must be sent in the server, the 
-method option_request can be used this task. The following example, extracted from the examples/client_exception.rb 
-demo script shows the process:
-
-----------------------------------------------------
-client = Gearman::Client.new(servers)
-#try this out
-client.option_request("exceptions")
-----------------------------------------------------
-
-This feature will only works if the server and workers have implemented support for the OPT_REQ and WORK_EXCEPTION
-messages of the Gearman protocol.
-
-
-Enjoy.
-