gearman-ruby 2.0.0 → 3.0.1

data/lib/gearman/job.rb

@@ -1,38 +0,0 @@
-module Gearman
-  # = Job
-  #
-  # == Description
-  # Interface to allow a worker to report information to a job server.
-  class Job
-    ##
-    # Create a new Job.
-    #
-    # @param sock    Socket connected to job server
-    # @param handle  job server-supplied job handle
-    def initialize(client, handle)
-      @client = client
-      @handle = handle
-    end
-    ##
-    # Report our status to the job server.
-    def report_status(numerator, denominator)
-      @client.send :work_status, "#{@handle}\0#{numerator}\0#{denominator}"
-      self
-    end
-
-    ##
-    # Send data before job completes
-    def send_partial(data)
-      @client.send :work_data, "#{@handle}\0#{data}"
-      self
-    end
-    alias :send_data :send_partial
-
-    ##
-    # Send a warning explicitly
-    def report_warning(warning)
-      @client.send :work_warning, "#{@handle}\0#{warning}"
-      self
-    end
-  end
-end

data/lib/gearman/protocol.rb

@@ -1,110 +0,0 @@
-module Gearman
-
-  class ProtocolError < Exception; end
-
-
-  class Protocol
-    # Map from Integer representations of commands used in the network
-    # protocol to more-convenient symbols.
-    COMMANDS = {
-      1  => :can_do,               # W->J: FUNC
-      2  => :cant_do,              # W->J: FUNC
-      3  => :reset_abilities,      # W->J: --
-      4  => :pre_sleep,            # W->J: --
-      #5 =>  (unused),             # -      -
-      6  => :noop,                 # J->W: --
-      7  => :submit_job,           # C->J: FUNC[0]UNIQ[0]ARGS
-      8  => :job_created,          # J->C: HANDLE
-      9  => :grab_job,             # W->J: --
-      10 => :no_job,               # J->W: --
-      11 => :job_assign,           # J->W: HANDLE[0]FUNC[0]ARG
-      12 => :work_status,          # W->J/C: HANDLE[0]NUMERATOR[0]DENOMINATOR
-      13 => :work_complete,        # W->J/C: HANDLE[0]RES
-      14 => :work_fail,            # W->J/C: HANDLE
-      15 => :get_status,           # C->J: HANDLE
-      16 => :echo_req,             # ?->J: TEXT
-      17 => :echo_res,             # J->?: TEXT
-      18 => :submit_job_bg,        # C->J: FUNC[0]UNIQ[0]ARGS
-      19 => :error,                # J->?: ERRCODE[0]ERR_TEXT
-      20 => :status_res,           # C->J: HANDLE[0]KNOWN[0]RUNNING[0]NUM[0]DENOM
-      21 => :submit_job_high,      # C->J: FUNC[0]UNIQ[0]ARGS
-      22 => :set_client_id,        # W->J: [RANDOM_STRING_NO_WHITESPACE]
-      23 => :can_do_timeout,       # W->J: FUNC[0]TIMEOUT
-      24 => :all_yours,            # REQ    Worker
-      25 => :work_exception,       # W->J: HANDLE[0]ARG
-      26 => :option_req,           # C->J: TEXT
-      27 => :option_res,           # J->C: TEXT
-      28 => :work_data,            # REQ    Worker
-      29 => :work_warning,         # W->J/C: HANDLE[0]MSG
-      30 => :grab_job_uniq,        # REQ    Worker
-      31 => :job_assign_uniq,      # RES    Worker
-      32 => :submit_job_high_bg,   # C->J: FUNC[0]UNIQ[0]ARGS
-      33 => :submit_job_low,       # C->J: FUNC[0]UNIQ[0]ARGS
-      34 => :submit_job_low_bg,    # C->J: FUNC[0]UNIQ[0]ARGS
-      35 => :submit_job_sched,     # REQ    Client
-      36 => :submit_job_epoch      # REQ    Client
-    }
-
-    # Map e.g. 'can_do' => 1
-    COMMANDS_NUMERIC = COMMANDS.invert
-
-    # Default job server port.
-    DEFAULT_PORT = 4730
-
-    class << self
-
-      def encode_request(type_name, arg = nil)
-        type_num = COMMANDS_NUMERIC[type_name.to_sym]
-        raise InvalidArgsError, "Invalid type name '#{type_name}'" unless type_num
-        arg = '' if not arg
-        "\0REQ" + [type_num, arg.size].pack('NN') + arg
-      end
-
-      def decode_response(data, packets = [])
-        # p data
-        magic, type, len = data[0..12].unpack('a4NN')
-        raise ProtocolError, "Invalid magic '#{magic}'" unless magic == "\0RES"
-        type = COMMANDS[type]
-        raise ProtocolError, "Invalid packet type #{type}" unless type
-
-        buf, *more = data[12, data.size].split("\0RES")
-        handle, data = buf ? buf.split("\0", 2) : nil
-        packets << response_packet(type, handle, data)
-        more.each do |packet|
-          decode_response("\0RES#{packet}", packets)
-        end
-        packets
-      end
-
-      def response_packet(type, handle, data)
-        case type
-        when :work_complete,
-             :work_exception,
-             :work_warning,
-             :work_data,
-             :error
-          [type, handle, data]
-        when :job_assign
-          func, data = data.split("\0", 3)
-          [type, handle, func.to_s, data]
-        when :job_assign_uniq
-          func, uuid, data = data.split("\0", 3)
-          [type, handle, func.to_s, data, uuid]
-        when :work_fail,
-             :job_created,
-             :no_job,
-             :noop
-          [type, handle]
-        when :work_status
-          num, den = data.split("\0", 3)
-          [type, handle, num, den]
-        when :status_res
-          known, running, num, den = data.split("\0", 4)
-          [type, handle, known, running, num, den]
-        else
-          raise ProtocolError, "Invalid packet #{type}"
-        end
-      end
-    end
-  end
-end

data/test/basic_integration_test.rb

@@ -1,121 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-class BasicIntegrationTest < Test::Unit::TestCase
-
-  def setup
-    start_gearmand
-    @client = Gearman::Client.new("localhost:4730")
-    @worker = Gearman::Worker.new("localhost:4730")
-    Thread.new { EM.run } unless EM.reactor_running?
-  end
-
-  def teardown
-    stop_gearmand
-  end
-
-  def test_ping_job
-    response = nil
-
-    @worker.add_ability("pingpong") {|data, job| "pong" }
-    @worker.work
-
-    task = Gearman::Task.new("pingpong", "ping")
-
-    task.on_complete {|res| response = res }
-    @client.run task
-
-    assert_equal "pong", response
-  end
-
-  def test_exception_in_worker
-    warning_given = nil
-    failed = false
-
-    task = Gearman::Task.new("crash", "doesntmatter")
-
-    @worker.add_ability("crash") {|data, job| raise Exception.new("BOOM!") }
-    @worker.work
-
-    task.on_warning {|warning| warning_given = warning }
-    task.on_fail { failed = true}
-    @client.run task
-
-    assert_not_nil warning_given
-    assert_equal true, failed
-    assert_equal 0, task.retries_done
-  end
-
-  def test_should_be_able_to_retry_on_worker_exception
-    retry_callback_called = false
-    fail_count = 0
-
-    # Gearman::Util.debug = true
-    task = Gearman::Task.new("crash", "doesntmatter", :retries => 1)
-
-    @worker.add_ability("crash") {|data, job| raise Exception.new("BOOM!") }
-    @worker.work
-
-    task.on_retry {|i| retry_callback_called = true }
-    task.on_fail { fail_count += 1 }
-    @client.run task
-
-    assert_equal true, retry_callback_called
-    assert_equal 1, task.retries_done
-    assert_equal 1, fail_count
-  end
-
-  def test_chunked_response
-    chunks_received = 0
-
-    @worker.add_ability("chunked") do |data, job|
-      5.times {|i| job.send_partial("chunk #{i}") }
-    end
-    @worker.work
-
-    task = Gearman::Task.new("chunked")
-    task.on_data do |data|
-      assert_match /^chunk \d/, data
-      chunks_received += 1
-    end
-    @client.run task
-
-    assert_equal 5, chunks_received
-  end
-
-  def test_background
-    status_received = false
-
-    @worker.add_ability("fireandforget") {|data, job| "this goes to /dev/null" }
-    @worker.work
-
-    task = Gearman::Task.new('fireandforget', 'background', :background => true, :poll_status_interval => 0.1)
-    task.on_complete {|d| flunk "on_complete should never be called for a background job!" }
-    task.on_status {|d| status_received = true }
-    @client.run task
-
-    assert_equal true, status_received
-  end
-
-  def test_non_blocking_run
-    @worker.add_ability("foo") {|data, job| "foo: #{data}" }
-    @worker.work
-
-    task1_complete = false
-    task2_complete = false
-
-    task1 = Gearman::Task.new("foo", 1)
-    task1.on_complete {|d| task1_complete = true}
-    @client.run task1, nil, true
-
-    assert_equal false, task1_complete
-
-    task2 = Gearman::Task.new("foo", 2)
-    task2.on_complete {|d| task2_complete = true}
-    @client.run task2, nil, true
-
-    Thread.new { sleep 0.1 }.join
-
-    assert_equal true, task1_complete
-    assert_equal true, task2_complete
-  end
-end

data/test/crash_test.rb

@@ -1,69 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-# Gearman::Util.debug = true
-class CrashTest < Test::Unit::TestCase
-
-  def setup
-    teardown_gearmands
-    Thread.new { EM.run } unless EM.reactor_running?
-  end
-
-  def teardown
-    teardown_gearmands
-  end
-
-  def test_worker_should_reconnect_if_gearmand_goes_away
-    start_gearmand
-    worker = Gearman::Worker.new("localhost:4730", :reconnect_sec => 1)
-    worker.add_ability("foo") {|data, job| "noop!" }
-
-    response = nil
-
-    worker.work
-    stop_gearmand
-    start_gearmand
-
-    task = Gearman::Task.new("foo", "ping")
-    task.on_complete {|res| response = res }
-    Gearman::Client.new("localhost:4730").run task
-
-    assert_equal "noop!", response
-    stop_gearmand
-  end
-
-  def test_client_and_worker_should_use_failover_gearmand_if_primary_is_not_available
-    start_gearmand 4731
-
-    worker = Gearman::Worker.new(["localhost:4730", "localhost:4731"], :reconnect_sec => 1)
-    worker.add_ability("foo") {|data, job| "noop!" }
-
-    response = nil
-    worker.work
-    task = Gearman::Task.new("foo", "ping")
-    task.on_complete {|res| response = res }
-    Gearman::Client.new(["localhost:4730", "localhost:4731"]).run task
-
-    assert_equal "noop!", response
-    stop_gearmand 4731
-  end
-
-  def test_client_and_worker_should_switch_to_failover_gearmand_if_primary_goes_down
-    start_gearmand 4730
-    start_gearmand 4731
-
-    worker = Gearman::Worker.new(["localhost:4730", "localhost:4731"], :reconnect_sec => 1)
-    worker.add_ability("foo") {|data, job| "noop!" }
-
-    response = nil
-    worker.work
-
-    stop_gearmand 4730
-
-    task = Gearman::Task.new("foo", "ping")
-    task.on_complete {|res| response = res }
-    Gearman::Client.new(["localhost:4730", "localhost:4731"]).run task
-
-    assert_equal "noop!", response
-    stop_gearmand 4731
-  end
-end

data/test/job_test.rb

@@ -1,30 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-class JobTest < Test::Unit::TestCase
-
-  def setup
-    @handle = "H:foo:1"
-    @mock_client = mock()
-    @job = Gearman::Job.new(@mock_client, @handle)
-  end
-
-  def test_supports_report_status
-    @mock_client.expects(:send).with(:work_status, [@handle, 1, 5].join("\0"))
-    @job.report_status(1, 5)
-  end
-
-  def test_supports_send_partial
-    @mock_client.expects(:send).with(:work_data, [@handle, "bar"].join("\0"))
-    @job.send_partial("bar")
-  end
-
-  def test_supports_send_data
-    @mock_client.expects(:send).with(:work_data, [@handle, "bar"].join("\0"))
-    @job.send_data("bar")
-  end
-
-  def test_supports_report_warning
-    @mock_client.expects(:send).with(:work_warning, [@handle, "danger"].join("\0"))
-    @job.report_warning("danger")
-  end
-end

data/test/protocol_test.rb

@@ -1,132 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-class ProtocolTest < Test::Unit::TestCase
-
-  def test_encode_request
-    payload = ["foo", "123", "bar"].join("\0")
-    expected = "\0REQ" + [Gearman::Protocol::COMMANDS_NUMERIC[:submit_job], payload.size].pack("NN") + payload
-    assert_equal expected, Gearman::Protocol.encode_request(:submit_job, payload)
-  end
-
-  def test_decode_response
-    response = "\0RES" + [Gearman::Protocol::COMMANDS_NUMERIC[:work_data], 3].pack("NN") + handle + "\0foo"
-    packets = Gearman::Protocol.decode_response(response)
-    assert_equal 1, packets.size
-    assert_equal [:work_data, "H:wrk.acme:1", "foo"], packets.first
-  end
-
-  def test_decodes_multiple_response_packets
-    response = "\0RES" + [Gearman::Protocol::COMMANDS_NUMERIC[:work_data], 3].pack("NN") + handle + "\0foo"
-    response << "\0RES" + [Gearman::Protocol::COMMANDS_NUMERIC[:work_data], 3].pack("NN") + handle + "\0bar"
-    response << "\0RES" + [Gearman::Protocol::COMMANDS_NUMERIC[:work_data], 3].pack("NN") + handle + "\0baz"
-
-    assert_equal 3, Gearman::Protocol.decode_response(response).size
-  end
-
-  def test_response_packet
-    packet = [:work_data, handle, "foo"]
-    assert_equal packet, Gearman::Protocol.response_packet(*packet)
-  end
-
-  def test_decodes_work_complete
-    data     = "esta complet"
-    response = "\0RES" + [Gearman::Protocol::COMMANDS_NUMERIC[:work_complete], data.size].pack("NN") + [handle, data].join("\0")
-    assert_equal [:work_complete, handle, data], Gearman::Protocol.decode_response(response).first
-  end
-
-  def test_decodes_work_exception
-    data     = "{native perl exception object}"
-    response = "\0RES" + [Gearman::Protocol::COMMANDS_NUMERIC[:work_exception], data.size].pack("NN") + [handle, data].join("\0")
-    assert_equal [:work_exception, handle, data], Gearman::Protocol.decode_response(response).first
-  end
-
-  def test_decodes_work_warning
-    data     = "I warn you, dude"
-    response = "\0RES" + [Gearman::Protocol::COMMANDS_NUMERIC[:work_warning], data.size].pack("NN") + [handle, data].join("\0")
-    assert_equal [:work_warning, handle, data], Gearman::Protocol.decode_response(response).first
-  end
-
-  def test_decodes_work_data
-    data     = "foo"
-    response = "\0RES" + [Gearman::Protocol::COMMANDS_NUMERIC[:work_data], data.size].pack("NN") + [handle, data].join("\0")
-    assert_equal [:work_data, handle, data], Gearman::Protocol.decode_response(response).first
-  end
-
-  def test_decodes_error
-    data     = "error"
-    response = "\0RES" + [Gearman::Protocol::COMMANDS_NUMERIC[:error], data.size].pack("NN") + [handle, data].join("\0")
-    assert_equal [:error, handle, data], Gearman::Protocol.decode_response(response).first
-  end
-
-  def test_decodes_job_assign
-    function  = "foo_function"
-    arguments = "arguments"
-
-    payload  = [handle, function, arguments].join("\0")
-    response = "\0RES" + [Gearman::Protocol::COMMANDS_NUMERIC[:job_assign], payload.size].pack("NN") + payload
-    assert_equal [:job_assign, handle, function, arguments], Gearman::Protocol.decode_response(response).first
-  end
-
-  def test_decodes_job_assign_uniq
-    function  = "foo_function"
-    arguments = "arguments"
-    unique_id = "123-657"
-
-    payload  = [handle, function, unique_id, arguments].join("\0")
-    response = "\0RES" + [Gearman::Protocol::COMMANDS_NUMERIC[:job_assign_uniq], payload.size].pack("NN") + payload
-    assert_equal [:job_assign_uniq, handle, function, arguments, unique_id], Gearman::Protocol.decode_response(response).first
-  end
-
-  def test_decodes_work_fail
-    response = "\0RES" + [Gearman::Protocol::COMMANDS_NUMERIC[:work_fail], 0].pack("NN") + handle
-    assert_equal [:work_fail, handle], Gearman::Protocol.decode_response(response).first
-  end
-
-  def test_decodes_job_created
-    response = "\0RES" + [Gearman::Protocol::COMMANDS_NUMERIC[:job_created], 0].pack("NN") + handle
-    assert_equal [:job_created, handle], Gearman::Protocol.decode_response(response).first
-  end
-
-  def test_decodes_no_job
-    response = "\0RES" + [Gearman::Protocol::COMMANDS_NUMERIC[:no_job], 0].pack("NN") + handle
-    assert_equal [:no_job, handle], Gearman::Protocol.decode_response(response).first
-  end
-
-  def test_decodes_noop
-    response = "\0RES" + [Gearman::Protocol::COMMANDS_NUMERIC[:noop], 0].pack("NN") + handle
-    assert_equal [:noop, handle], Gearman::Protocol.decode_response(response).first
-  end
-
-  def test_decodes_work_status
-    numerator   = "1"
-    denominator = "5"
-
-    payload  = [handle, numerator, denominator].join("\0")
-    response = "\0RES" + [Gearman::Protocol::COMMANDS_NUMERIC[:work_status], payload.size].pack("NN") + payload
-
-    assert_equal [:work_status, handle, numerator, denominator], Gearman::Protocol.decode_response(response).first
-  end
-
-  def test_decodes_status_res
-    known       = "1"
-    running     = "0"
-    numerator   = "1"
-    denominator = "4"
-
-    payload = [handle, known, running, numerator, denominator].join("\0")
-    response = "\0RES" + [Gearman::Protocol::COMMANDS_NUMERIC[:status_res], payload.size].pack("NN") + payload
-
-    assert_equal [:status_res, handle, known, running, numerator, denominator], Gearman::Protocol.decode_response(response).first
-  end
-
-  def test_raises_on_invalid_command
-    response = "\0RES" + [6969, 0].pack("NN")
-    assert_raises(Gearman::ProtocolError) { Gearman::Protocol.decode_response(response) }
-    assert_raises(Gearman::ProtocolError) { Gearman::Protocol.response_packet(*[6969, handle, ''])}
-  end
-
-private
-  def handle
-    "H:wrk.acme:1"
-  end
-end