gearman-ruby 3.0.4 → 3.0.6

data/.gitignore

@@ -1 +1,3 @@
 pkg/
+coverage
+.idea

data/CHANGELOG

@@ -0,0 +1,3 @@
+3.0.6 
+
+ * Connection failover for clients

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+gem 'rspec'
+gem "simplecov", ">= 0.3.8"
+
+group :test do
+  gem 'rake'
+end

data/HOWTO

@@ -12,7 +12,7 @@ is the nervous system for how distributed processing communicates."
 
 == Setting up a basic environment
 
-A very basic German environment will look like this:
+A very basic Gearman environment will look like this:
 
                        ----------  
                        | Client |  

data/Rakefile

@@ -1,40 +1,19 @@
-require 'rake'
-require 'rake/testtask'
-require 'rake/rdoctask'
-require 'rcov/rcovtask'
- 
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |s|
-    s.name = "gearman-ruby"
-    s.summary = "Library for the Gearman distributed job system"
-    s.email = "gearman.ruby@librelist.com"
-    s.homepage = "http://github.com/gearman-ruby/gearman-ruby"
-    s.description = "Library for the Gearman distributed job system"
-    s.authors = ["John Ewart", "Colin Curtin", "Daniel Erat", "Ladislav Martincik", "Pablo Delgado", "Mauro Pompilio", "Antonio Garrote", "Kim Altintop"]
-  end
-rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
-end
+require 'rubygems'
+require 'bundler'
+require "rspec/core/rake_task"
+Bundler::GemHelper.install_tasks
 
-Rake::TestTask.new do |t|
-  t.libs << 'lib'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = false
-end
-
-Rake::RDocTask.new do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = 'Gearman Ruby'
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
 end
 
-Rcov::RcovTask.new do |t|
-  t.libs << "test"
-  t.test_files = FileList['test/*_test.rb']
-  t.verbose = true
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = ["-c", "-f progress", "-r ./spec/spec_helper.rb"]
+  t.pattern = 'spec/**/*_spec.rb'
 end
 
-task :default => :rcov
+task :default => :spec

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 3
 :minor: 0
-:patch: 4
+:patch: 5

data/examples/client.rb

@@ -1,7 +1,7 @@
 require 'rubygems'
 #require 'gearman'
 require '../lib/gearman'
-Gearman::Util.debug = true
+# Gearman::Util.debug = true
 
 servers = ['localhost:4730', 'localhost:4731']
   

data/gearman-ruby.gemspec

@@ -0,0 +1,28 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "gearman/version"
+
+Gem::Specification.new do |s|
+  s.name          = %q{gearman-ruby}
+  s.version       = Gearman::VERSION
+  s.platform      = Gem::Platform::RUBY
+  s.authors       = ["John Ewart", "Colin Curtin", "Daniel Erat", "Ladislav Martincik", "Pablo Delgado", "Mauro Pompilio", "Antonio Garrote", "Kim Altintop"]
+  s.date          = %q{2013-07-25}
+  s.summary       = %q{Ruby Gearman library}
+  s.description   = %q{Library for the Gearman distributed job system}
+  s.email         = %q{john@johnewart.net}
+  s.homepage      = %q{http://github.com/johnewart/gearman-ruby}
+  s.rubyforge_project = "gearman-ruby"
+
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README",
+    "TODO"
+  ]
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.require_paths = ["lib"]
+end
+

data/lib/gearman.rb

@@ -73,4 +73,10 @@ end
 class NetworkError < Exception
 end
 
+class NoJobServersError < Exception
+end
+
+class JobQueueError < Exception
+end
+
 end

data/lib/gearman/client.rb

@@ -1,5 +1,3 @@
-#!/usr/bin/env ruby
-
 require 'socket'
 
 module Gearman
@@ -18,13 +16,12 @@ class Client
     self.job_servers = job_servers if job_servers
     @sockets = {}  # "host:port" -> [sock1, sock2, ...]
     @socket_to_hostport = {}  # sock -> "host:port"
-    @test_hostport = nil  # make get_job_server return a given host for testing
     @task_create_timeout_sec = 10
     @server_counter = -1
     @bad_servers = []
   end
   attr_reader :job_servers, :bad_servers
-  attr_accessor :test_hostport, :task_create_timeout_sec
+  attr_accessor :task_create_timeout_sec
 
   ##
   # Set the options
@@ -54,18 +51,37 @@ class Client
   #
   # @return  "host:port"
   def get_job_server
+    if @job_servers.empty? && !@bad_servers.empty?
+      Util.logger.debug "GearmanRuby: No more good job servers, trying bad ones: #{@bad_servers.inspect}."
+      # Try to reconnect to the bad servers
+      @bad_servers.each do |bad_server|
+        Util.logger.debug "GearmanRuby: Trying server: #{bad_server.inspect}"
+        begin
+          request = Util.pack_request("echo_req", "ping")
+          sock = self.get_socket(bad_server)
+          Util.send_request(sock, request)
+          response = Util.read_response(sock, 20)
+          if response[0] == :echo_res
+            @job_servers << bad_server
+            @bad_servers.delete bad_server
+          end
+        rescue NetworkError
+          Util.logger.debug "GearmanRuby: Error trying server: #{bad_server.inspect}"
+        end
+      end
+    end
 
-    raise Exception.new('No servers available') if @job_servers.empty?
-
+    Util.logger.debug "GearmanRuby: job servers: #{@job_servers.inspect}"
+    raise NoJobServersError if @job_servers.empty?
     @server_counter += 1
-    # Return a specific server if one's been set.
-    @test_hostport or @job_servers[@server_counter % @job_servers.size]
+    @job_servers[@server_counter % @job_servers.size]
   end
-  
+
   def signal_bad_server(hostport)
     @job_servers = @job_servers.reject { |s| s == hostport }
     @bad_servers << hostport
   end
+
   ##
   # Get a socket for a job server.
   #
@@ -83,15 +99,14 @@ class Client
       begin
         sock = TCPSocket.new(*hostport.split(':'))
       rescue Exception
+        # Swallow error so we can retry -> num_retries times
       else
-
+        # No error, stash socket mapping and return it
         @socket_to_hostport[sock] = hostport
         return sock
       end
     end
-
-    signal_bad_server(hostport)
-    raise RuntimeError, "Unable to connect to job server #{hostport}"
+    raise NetworkError, "Unable to connect to job server #{hostport}"
   end
 
   ##
@@ -103,9 +118,8 @@ class Client
   def return_socket(sock)
     hostport = get_hostport_for_socket(sock)
     if not hostport
-      inet, port, host, ip = s.addr
-      Util.logger.error "GearmanRuby: Got socket for #{ip}:#{port}, which we don't " +
-        "know about -- closing"
+      inet, port, host, ip = sock.addr
+      Util.logger.error "GearmanRuby: Got socket for #{ip}:#{port}, which we don't know about -- closing"
       sock.close
       return
     end
@@ -141,12 +155,15 @@ class Client
     task.on_fail { failed = true }
 
     taskset = TaskSet.new(self)
-    taskset.add_task(task)
-    taskset.wait
+    if taskset.add_task(task)
+      taskset.wait
+    else
+      raise JobQueueError, "Unable to enqueue job."
+    end
 
     failed ? nil : result
   end
 
 end
 
-end
+end

data/lib/gearman/server.rb

@@ -48,7 +48,7 @@ class Server
     while true do 
       if buf = socket.recv_nonblock(65536) rescue nil
         response << buf 
-        return response if response =~ /\n.\n$/
+        return response if response =~ /^.$/
       end
     end
   end
@@ -61,7 +61,7 @@ class Server
     status = {}
     if response = send_command('status')
       response.split("\n").each do |line|
-        if line.match /^([A-Za-z_]+)\t([A-Za-z_]+)\t(\d+)\t(\d+)\t(\d+)$/
+        if line.match /^(.*)?\t(\d+)\t(\d+)\t(\d+)$/
           (status[$1] ||= {})[$2] = { :queue => $3, :active => $4, :workers => $5 }
         end
       end

data/lib/gearman/task.rb

@@ -38,8 +38,7 @@ module Gearman
     attr_reader :successful, :func, :arg, :retries_done
 
     ##
-    # Schedule this job to run at a certain time (like `cron`)
-    # XXX: But there is no wildcard??
+    # Schedule this job to run at a certain time
     #
     # @param time     Ruby Time object that represents when to run the thing
     def schedule(time)
@@ -120,6 +119,15 @@ module Gearman
       @on_complete.call(data) if @on_complete
       self
     end
+    
+    def on_created(&f)
+      @on_created = f
+    end
+      
+    def handle_created(data)
+      @on_created.call(data) if @on_created
+      self
+    end
 
     ##
     # Record a failure and check whether we should be retried.
@@ -176,7 +184,7 @@ module Gearman
       return @hash if @hash
     
       if @uniq.nil? 
-        string = (@func+@arg).to_s
+        string = @func+@arg.to_s
       else 
         string = @uniq
       end

data/lib/gearman/taskset.rb

@@ -43,44 +43,47 @@ class TaskSet
     req = task.get_submit_packet()
 
     @task_waiting_for_handle = task
-    # FIXME: We need to loop here in case we get a bad job server, or the
-    # job creation fails (see how the server reports this to us), or ...
 
+    # Target the same job manager when submitting jobs
+    # with the same unique id so that we can coalesce
     merge_hash = task.get_uniq_hash
 
-    looking_for_socket = true
-
-    should_try_rehash = true
-    while(looking_for_socket)
+    while (@task_waiting_for_handle != nil)
       begin
-        hostport = if should_try_rehash
-          (@merge_hash_to_hostport[merge_hash] or @client.get_job_server)
-        else
-          @client.get_job_server
-        end
+        # Try to connect again to the same server based on the unique hash
+        @merge_hash_to_hostport[merge_hash] ||= @client.get_job_server
+        hostport = @merge_hash_to_hostport[merge_hash]
 
-        @merge_hash_to_hostport[merge_hash] = hostport if merge_hash
-        sock = (@sockets[hostport] or @client.get_socket(hostport))
-        looking_for_socket = false
-      rescue RuntimeError
-        should_try_rehash = false
-      end
-    end
-    Util.logger.debug "GearmanRuby: Using socket #{sock.inspect} for #{hostport}"
-    Util.send_request(sock, req)
-    while @task_waiting_for_handle
-      begin
+        # Cache the socket
+        @sockets[hostport] ||= @client.get_socket(hostport)
+
+        # Submit job to server
+        sock = @sockets[hostport]
+        Util.logger.debug "GearmanRuby: Using socket #{sock.inspect} for #{hostport} to SUBMIT_JOB"
+        Util.send_request(sock, req)
+
+        # read_packet will fire off handle_job_created and set @task_waiting_for_handle to nil
+        # TODO: Better way of doing this.
         read_packet(sock, @client.task_create_timeout_sec)
       rescue NetworkError
-        Util.logger.debug "GearmanRuby: Got timeout on read from #{hostport}"
-        @task_waiting_for_handle = nil
-        @client.close_socket(sock)
+        Util.logger.debug "GearmanRuby: Network error on read from #{hostport} while adding job, marking server bad"
+        # Tell the client this is a bad server
+        @client.signal_bad_server(hostport)
+        if(sock != nil)
+          @client.close_socket(sock)
+        end
+
+        # Un-cache socket
+        @sockets.delete hostport
+        # Remove from hash -> hostport mapping
+        @merge_hash_to_hostport[merge_hash] = nil
+      rescue NoJobServersError
+        Util.logger.error "GearmanRuby: No servers available."
         return false
       end
     end
 
-    @sockets[hostport] ||= sock
-    true
+    return true
   end
   private :add_task_internal
 
@@ -91,9 +94,11 @@ class TaskSet
   # @param data      data returned in packet from server
   def handle_job_created(hostport, data)
     Util.logger.debug "GearmanRuby: Got job_created with handle #{data} from #{hostport}"
+
     if not @task_waiting_for_handle
-      raise ProtocolError, "Got unexpected job_created notification " + "with handle #{data} from #{hostport}"
+      raise ProtocolError, "Got unexpected job_created notification with handle #{data} from #{hostport}"
     end
+
     js_handle = Util.handle_to_str(hostport, data)
     task = @task_waiting_for_handle
     @task_waiting_for_handle = nil
@@ -102,6 +107,7 @@ class TaskSet
     else
       (@tasks_in_progress[js_handle] ||= []) << task
     end
+    task.handle_created(data)
     nil
   end
   private :handle_job_created
@@ -248,15 +254,16 @@ class TaskSet
         @sockets = {}
         return false
       end
+
       ready_socks[0].each do |sock|
         begin
-          read_packet(sock, (end_time ? end_time - Time.now.to_f : nil))
+           read_packet(sock, (end_time ? end_time - Time.now.to_f : nil))
         rescue ProtocolError
           hostport = @client.get_hostport_for_socket(sock)
           Util.logger.debug "GearmanRuby: Ignoring bad packet from #{hostport}"
         rescue NetworkError
           hostport = @client.get_hostport_for_socket(sock)
-          Util.logger.debug "GearmanRuby: Got timeout on read from #{hostport}"
+          Util.logger.debug "GearmanRuby: Network error on read from #{hostport}"
         end
       end
     end
@@ -265,7 +272,7 @@ class TaskSet
     @sockets = {}
     @finished_tasks.each do |t|
       if ( (t.background.nil? || t.background == false) && !t.successful)
-        Util.logger.debug "GearmanRuby: Taskset failed"
+        Util.logger.debug "GearmanRuby: TaskSet failed"
         return false
       end
     end

data/lib/gearman/util.rb

@@ -116,7 +116,11 @@ class Util
     while data.size < len and (not timeout or Time.now.to_f < end_time) do
       IO::select([sock], nil, nil, timeout ? end_time - Time.now.to_f : nil) \
         or break
-      data += sock.readpartial(len - data.size)
+      begin
+        data += sock.readpartial(len - data.size)
+      rescue
+        raise NetworkError, "Unable to read data from socket."
+      end
     end
     if data.size < len
       raise NetworkError, "Read #{data.size} byte(s) instead of #{len}"
@@ -131,7 +135,6 @@ class Util
   # @param timeout  timeout in seconds, nil for no timeout
   # @return         array consisting of integer packet type and data
   def Util.read_response(sock, timeout=nil)
-    #debugger
     end_time = Time.now.to_f + timeout if timeout
     head = timed_recv(sock, 12, timeout)
     magic, type, len = head.unpack('a4NN')
@@ -184,7 +187,7 @@ class Util
   # @return     [hostport, handle]
   def Util.str_to_handle(str)
     str =~ %r{^([^:]+:\d+)//(.+)}
-    return [$1, $3]
+    return [$1, $2]
   end
 
   def self.with_safe_socket_op

data/lib/gearman/version.rb

@@ -0,0 +1,3 @@
+module Gearman
+  VERSION = "3.0.6"
+end

data/lib/gearman/worker.rb

@@ -67,6 +67,7 @@ class Worker
     #
     # @param sock    Socket connected to job server
     # @param handle  job server-supplied job handle
+    attr_reader :handle
     def initialize(sock, handle)
       @socket = sock
       @handle = handle
@@ -98,6 +99,42 @@ class Worker
     end
   end
 
+  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
+          Util.logger.error "GearmanRuby: #{event} failed: #{e.inspect}"
+        end
+      end
+    end
+
+  end
+
+  # 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')) }
+  include Callbacks
+
   ##
   # Create a new worker.
   #
@@ -172,7 +209,7 @@ class Worker
     # Disconnect from servers that we no longer care about.
     @sockets.each do |server,sock|
       if not servers.include? server
-        Util.logger.debug "GearmanRuby: Disconnecting from old server #{server}"
+        Util.logger.info "GearmanRuby: Disconnecting from old server #{server}"
         sock.close
         @sockets.delete(server)
       end
@@ -181,11 +218,12 @@ class Worker
     servers.each do |server|
       if not @sockets[server]
         begin
-          Util.logger.debug "GearmanRuby: Connecting to server #{server}"
+          Util.logger.info "GearmanRuby: Connecting to server #{server}"
+          run_connect_callback
           @sockets[server] = connect(server)
         rescue NetworkError
           @bad_servers << server
-          Util.logger.debug "GearmanRuby: Unable to connect to #{server}"
+          Util.logger.info "GearmanRuby: Unable to connect to #{server}"
         end
       end
     end
@@ -311,12 +349,15 @@ class Worker
     cmd = if ret && exception.nil?
       Util.logger.debug "GearmanRuby: Sending work_complete for #{handle} with #{ret.to_s.size} byte(s) " +
         "to #{hostport}"
+      run_work_complete_callback
       [ Util.pack_request(:work_complete, "#{handle}\0#{ret.to_s}") ]
     elsif exception.nil?
       Util.logger.debug "GearmanRuby: Sending work_fail for #{handle} to #{hostport}"
+      run_work_fail_callback
       [ Util.pack_request(:work_fail, handle) ]
     elsif exception
       Util.logger.debug "GearmanRuby: Sending work_exception for #{handle} to #{hostport}"
+      run_work_exception_callback
       [ Util.pack_request(:work_exception, "#{handle}\0#{exception.message}") ]
     end
 
@@ -344,6 +385,8 @@ class Worker
   # Do a single job and return.
   def work
     req = Util.pack_request(:grab_job)
+    type = nil
+    data = nil
     loop do
       @status = :preparing
       bad_servers = []
@@ -353,6 +396,7 @@ class Worker
       @servers_mutex.synchronize { servers = @sockets.keys.sort }
       servers.each do |hostport|
         Util.logger.debug "GearmanRuby: Sending grab_job to #{hostport}"
+        run_grab_job_callback
         sock = @sockets[hostport]
         Util.send_request(sock, req)
 
@@ -365,16 +409,18 @@ class Worker
             case type
             when :no_job
               Util.logger.debug "GearmanRuby: Got no_job from #{hostport}"
+              run_no_job_callback
               break
             when :job_assign
               @status = :working
+              run_job_assign_callback
               return worker_enabled if handle_job_assign(data, sock, hostport)
               break
             else
               Util.logger.debug "GearmanRuby: Got #{type.to_s} from #{hostport}"
             end
           rescue Exception
-            Util.logger.debug "GearmanRuby: Server #{hostport} timed out or lost connection (#{$!.inspect}); marking bad"
+            Util.logger.info "GearmanRuby: Server #{hostport} timed out or lost connection (#{$!.inspect}); marking bad"
             bad_servers << hostport
             break
           end
@@ -399,10 +445,29 @@ class Worker
       return false unless worker_enabled
       @status = :waiting
 
-      # FIXME: We could optimize things the next time through the 'each' by
-      # sending the first grab_job to one of the servers that had a socket
-      # with data in it.  Not bothering with it for now.
-      IO::select(@sockets.values, nil, nil, @reconnect_sec)
+      sleepTime = Time.now
+      while(@status == :waiting)
+        # FIXME: We could optimize things the next time through the 'each' by
+        # sending the first grab_job to one of the servers that had a socket
+        # with data in it.  Not bothering with it for now.
+        IO::select(@sockets.values, nil, nil, @reconnect_sec)
+        
+        # If 30 seconds have passed, then wakeup
+        @status = :wakeup if Time.now - sleepTime > 30 
+
+        if(@status == :waiting)
+          @sockets.values.each do |sock|
+            type, data = Util.read_response(sock, @network_timeout_sec)
+ 
+            # there shouldn't be anything else here, if there is, we should be able to ignore it...
+            if(type == :noop)
+              Util.logger.debug "Received NoOp while sleeping... waking up!"
+              @status = :wakeup
+            end
+          end
+        end
+      end
+      
     end
   end
 end

data/spec/client_spec.rb

@@ -0,0 +1,60 @@
+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
+
+  it "creates a client" do
+    @client.should_not be nil
+  end
+
+  it "creates a task set when you run a task" do
+    task_set = Gearman::TaskSet.new(@client)
+    Gearman::TaskSet.stub(:new).and_return task_set
+    task_set.should_receive(:add_task).and_return true
+    task_set.should_receive(:wait)
+
+    task = Gearman::Task.new("do_something", {:data => 123})
+    @client.do_task(task)
+  end
+
+  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
+    expect {
+      @client.do_task(task)
+    }.to raise_error
+  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 "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
+
+  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")
+    }.to raise_error
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'simplecov'
+
+SimpleCov.start do
+  add_filter "/spec/"
+  merge_timeout 3600
+end
+
+$:.unshift(File.expand_path('../lib', __FILE__))
+require 'gearman'
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+end

data/spec/support/fake_tcp_socket.rb

@@ -0,0 +1,25 @@
+class FakeTCPSocket
+
+  def readline(some_text = nil)
+    return @canned_response
+  end
+
+  def flush
+  end
+
+  def write(some_text = nil)
+  end
+
+  def readchar
+    return 6
+  end
+
+  def read(num)
+    return num > @canned_response.size ? @canned_response : @canned_response[0..num]
+  end
+
+  def set_canned(response)
+    @canned_response = response
+  end
+
+end

data/spec/task_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+require 'socket'
+require 'rspec'
+require 'rspec/mocks'
+require 'gearman'
+
+describe Gearman::Task do
+  before(:each) do
+
+  end
+
+  context :creation do
+    it "throws an exception when passed bogus opts" do
+      expect {
+         Gearman::Task.new("bogus_task", "data", {:bogus => 'bogon'})
+      }.to raise_error
+    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")
+      expect(task_one.get_uniq_hash).to eq(hash_data)
+
+      task_two = Gearman::Task.new("unique_id", "foobar")
+      expect(task_two.get_uniq_hash).to_not eq(hash_data)
+    end
+
+    it "honors a uniq value set for the task" do
+      task = Gearman::Task.new("unique_id", "abcdef", {:uniq => 'totally_awesome'})
+      expect(task.get_uniq_hash).to eq ('91aa6f67b66e394412d9be5f5699c843c726aad8')
+    end
+  end
+
+  context :get_submit_packet do
+    it "represents an EPOCH task properly" do
+      task = Gearman::Task.new("function", "data")
+      scheduled_for = Time.now
+      task.schedule(scheduled_for)
+
+      task_str = task.get_submit_packet
+      expect(task_str).to eq "\x00REQ\x00\x00\x00$\x00\x00\x00Afunction\x007dda232f7c04c9d59c0cc43e1c30dea72362e265\x00#{scheduled_for.to_i}\x00data"
+    end
+
+    it "represents a background job properly" do
+      task = Gearman::BackgroundTask.new("background", "bgdata")
+      byte_string = "\x00REQ\x00\x00\x00\x12\x00\x00\x00:background\x00ed75b3f27f59d8e1ed51eedd3b5f98de3141ad49\x00bgdata"
+      expect(task.get_submit_packet).to eq byte_string
+    end
+
+    it "represents a high priority background job properly" do
+      task = Gearman::BackgroundTask.new("background", "highbgdata", {:priority => :high})
+      byte_string = "\x00REQ\x00\x00\x00 \x00\x00\x00>background\x003e304e4c11c31c904fbfae7b4f9840ef33006c5e\x00highbgdata"
+      expect(task.get_submit_packet).to eq byte_string
+    end
+
+    it "represents a low priority background job properly" do
+      task = Gearman::BackgroundTask.new("background", "lowbgdata", {:priority => :low})
+      byte_string = "\x00REQ\x00\x00\x00\"\x00\x00\x00=background\x0079f123e29effe921e32ce1600b2efc63ab716cad\x00lowbgdata"
+      expect(task.get_submit_packet).to eq byte_string
+    end
+
+  end
+
+
+  context :handle_responses do
+    before :each do
+      @task = Gearman::Task.new("handle_response", "some data")
+    end
+
+    it "calls handle_warning properly" do
+      warning_data = nil
+      @task.on_warning do |msg|
+        warning_data = msg
+      end
+
+      @task.handle_warning("message")
+      expect(warning_data).to eq "message"
+    end
+
+    it "calls handle_status properly" do
+      numerator = nil
+      denominator = nil
+
+      @task.on_status do |n, d|
+        numerator = n
+        denominator = d
+      end
+
+      @task.handle_status(10, 100)
+      expect(numerator).to eq 10
+      expect(denominator).to eq 100
+    end
+
+    it "calls handle_failure correctly" do
+      error_message = nil
+
+      @task.on_fail do
+        error_message = "oops!"
+      end
+
+      @task.handle_failure
+
+      expect(error_message).to eq "oops!"
+    end
+
+    it "calls handle_data correctly" do
+      data_result = nil
+
+      @task.on_data do |data|
+        data_result = data
+      end
+
+      @task.handle_data("foonarf")
+
+      expect(data_result).to eq "foonarf"
+    end
+
+    it "calls handle_created correctly" do
+      job_handle = nil
+
+      @task.on_created do |data|
+        job_handle = data
+      end
+
+      @task.handle_created("foonarf.local:1234")
+
+      expect(job_handle).to eq "foonarf.local:1234"
+    end
+
+    it "calls handle_exception correctly" do
+      exception_message = nil
+
+      @task.on_exception do |data|
+        exception_message = data
+      end
+
+      @task.handle_exception("NetworkError")
+
+      expect(exception_message).to eq "NetworkError"
+    end
+
+    it "retries if failure occurs and the failure count is greater than zero" do
+      retries_completed = 0
+      @task.retry_count = 5
+      @task.on_retry do |retries_done|
+        retries_completed = retries_done
+      end
+      @task.handle_failure.should == true
+      retries_completed.should == 1
+    end
+
+    it "does not retry if the number of retries completed has met the number of retries to execute" do
+      @task.retry_count = 3
+      retries_completed = 0
+      (0..@task.retry_count-1).each do |i|
+        retries_completed += 1
+        @task.handle_failure.should == true
+      end
+      @task.handle_failure.should == false
+      retries_completed.should == 3
+    end
+  end
+end

data/spec/taskset_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+require 'socket'
+require 'rspec'
+require 'rspec/mocks'
+require 'gearman'
+
+describe Gearman::TaskSet do
+  before do
+
+  end
+
+  after do
+
+  end
+
+  it "handles a NetworkError when submitting a job" do
+    bad_socket = double(TCPSocket)
+    bad_socket.should_receive(:write) { |*args|
+      args[0].length
+    }.at_least(:once)
+    bad_socket.should_receive(:close)
+
+    good_socket = double(TCPSocket)
+    good_socket.should_receive(:write) { |*args|
+      args[0].length
+    }.at_least(:once)
+
+    Gearman::Util.should_receive(:timed_recv).with(bad_socket, 12, anything).and_raise Gearman::NetworkError
+    Gearman::Util.should_receive(:timed_recv).with(good_socket, 12, anything).and_return("\x00RES\x00\x00\x00\x08\000\000\000\007")
+    Gearman::Util.should_receive(:timed_recv).with(good_socket, 7, anything).and_return("foo:123")
+
+    client = Gearman::Client.new(["localhost:4731", "localhost:4732"])
+    client.should_receive(:get_hostport_for_socket).at_least(1).times.with(bad_socket).and_return "localhost:4731"
+    client.should_receive(:get_hostport_for_socket).at_least(1).times.with(good_socket).and_return "localhost:4732"
+    client.should_receive(:get_socket).with("localhost:4731").and_return bad_socket
+    client.should_receive(:get_socket).with("localhost:4732").and_return good_socket
+
+    task = Gearman::Task.new("job_queue", "data")
+
+    task_set = Gearman::TaskSet.new(client)
+    task_set.add_task(task)
+  end
+
+  it "waits for an answer from the server" do
+    good_socket = double(TCPSocket)
+    good_socket.should_receive(:write) { |*args|
+      args[0].length
+    }.at_least(:once)
+
+    Gearman::Util.should_receive(:timed_recv).with(good_socket, 12, anything).and_return("\x00RES\x00\x00\x00\x08\000\000\000\007")
+    Gearman::Util.should_receive(:timed_recv).with(good_socket, 7, anything).and_return("foo:123")
+
+    client = Gearman::Client.new(["localhost:4731"])
+    client.should_receive(:get_hostport_for_socket).at_least(1).times.with(good_socket).and_return "localhost:4731"
+    client.should_receive(:get_socket).with("localhost:4731").and_return good_socket
+
+    task = Gearman::Task.new("job_queue", "data")
+
+    task_set = Gearman::TaskSet.new(client)
+    task_set.add_task(task)
+
+    Gearman::Util.should_receive(:timed_recv).with(good_socket, 12, anything) {
+      sleep 0.5
+      "\x00RES\x00\x00\x00\x0d\000\000\000\007"
+    }
+
+    Gearman::Util.should_receive(:timed_recv).with(good_socket, 7, anything) {
+      "foo:123"
+    }
+
+    IO.stub(:select).and_return([[good_socket]])
+    start_time = Time.now
+    task_set.wait(30)
+    time_diff = Time.now - start_time
+    time_diff.should be < 30
+    time_diff.should be > 0
+  end
+
+end

data/spec/util_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'socket'
+require 'rspec'
+require 'rspec/mocks'
+require 'gearman'
+
+describe Gearman::Util do
+  before(:each) do
+
+  end
+
+  it "should generate a task from two arguments" do
+    task = Gearman::Util.get_task_from_args("queue", "data")
+    task.should_not be nil
+  end
+
+  it "should generate a task from three arguments" do
+    task = Gearman::Util.get_task_from_args("queue", "data", {:background => true})
+    task.should_not be nil
+  end
+
+  it "should raise an exception with more than three arguments" do
+    expect {
+      Gearman::Util.get_task_from_args("one", "two", {:three => :four}, :five)
+    }.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
+    expect {
+      Gearman::Util.send_request(socket, request)
+    }.to raise_error
+  end
+
+  context "normalizing job servers" do
+    it "should handle a string for input" do
+      Gearman::Util.normalize_job_servers("localhost:1234").should eq ["localhost:1234"]
+    end
+
+    it "should handle an array of host:port without changing a thing" do
+      servers = ["localhost:123", "localhost:456"]
+      Gearman::Util.normalize_job_servers(servers).should eq servers
+    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"]
+      Gearman::Util.normalize_job_servers(in_servers).should eq out_servers
+    end
+  end
+
+  it "should convert a host:port & handle into its corresponding string" do
+      Gearman::Util.handle_to_str("localhost:4730", "foo:1").should eq "localhost:4730//foo:1"
+  end
+
+  it "should convert a host:port & handle string into its components" do
+    Gearman::Util.str_to_handle("localhost:4730//foo:1").should eq ["localhost:4730", "foo:1"]
+  end
+
+  it "should convert an ability name with prefix into its correct format" do
+    Gearman::Util.ability_name_with_prefix("test", "a").should eq "test\ta"
+  end
+end

metadata

@@ -1,15 +1,10 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: gearman-ruby
-version: !ruby/object:Gem::Version 
-  hash: 15
-  prerelease: false
-  segments: 
-  - 3
-  - 0
-  - 4
-  version: 3.0.4
+version: !ruby/object:Gem::Version
+  version: 3.0.6
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - John Ewart
 - Colin Curtin
 - Daniel Erat
@@ -21,22 +16,20 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-12-17 00:00:00 -08:00
-default_executable: 
+date: 2013-07-25 00:00:00.000000000 Z
 dependencies: []
-
 description: Library for the Gearman distributed job system
-email: gearman.ruby@librelist.com
+email: john@johnewart.net
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - LICENSE
 - README
-files: 
+- TODO
+files:
 - .gitignore
+- CHANGELOG
+- Gemfile
 - HOWTO
 - LICENSE
 - README
@@ -64,75 +57,64 @@ files:
 - 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/server.rb
 - lib/gearman/task.rb
 - lib/gearman/taskset.rb
-- lib/gearman/testlib.rb
 - lib/gearman/util.rb
+- lib/gearman/version.rb
 - lib/gearman/worker.rb
+- spec/client_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
+- test/testlib.rb
 - test/util_test.rb
 - test/worker_test.rb
-has_rdoc: true
-homepage: http://github.com/gearman-ruby/gearman-ruby
+homepage: http://github.com/johnewart/gearman-ruby
 licenses: []
-
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
-require_paths: 
+rdoc_options: []
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+      hash: -888361438356632818
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: 
-rubygems_version: 1.3.7
+rubyforge_project: gearman-ruby
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: Library for the Gearman distributed job system
-test_files: 
+summary: Ruby Gearman library
+test_files:
+- spec/client_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
+- test/testlib.rb
 - test/util_test.rb
 - test/worker_test.rb
-- examples/calculus_client.rb
-- examples/calculus_worker.rb
-- 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/scale_image.rb
-- examples/scale_image_worker.rb
-- examples/server.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