backburner 1.6.1 → 1.8.0

data/test/worker_test.rb

@@ -5,7 +5,7 @@ require File.expand_path('../fixtures/hooked', __FILE__)
 describe "Backburner::Worker module" do
   before do
     Backburner.default_queues.clear
-    clear_jobs!(Backburner.configuration.primary_queue, "test-plain", "test.bar", "bar.baz.foo")
+    clear_jobs!(Backburner.configuration.primary_queue, "test-plain", "test.bar", "bar.baz.foo", "test-parent")
   end
 
   describe "for enqueue class method" do
@@ -49,6 +49,28 @@ describe "Backburner::Worker module" do
       end
     end # queue respond_timeout
 
+    it "should enqueue a subclass job on its superclass queue with its settings" do
+      Backburner::Worker.enqueue TestChildQueueJob, [3, 4]
+      pop_one_job("test-parent") do |job, body|
+        assert_equal "TestChildQueueJob", body["class"]
+        assert_equal [3, 4], body["args"]
+        assert_equal 250, job.ttr
+        assert_equal 0, job.pri
+      end
+    end # subclass queue
+
+    it "should support a priority label as the default priority" do
+      default_priority = Backburner.configuration.default_priority
+      Backburner.configuration.default_priority = :low
+      Backburner::Worker.enqueue TestPlainJob, [1, 2]
+      pop_one_job("test-plain") do |job, body|
+        assert_equal "TestPlainJob", body["class"]
+        assert_equal 200, job.pri
+      end
+    ensure
+      Backburner.configuration.default_priority = default_priority
+    end # default priority label
+
     it "should support enqueuing job with custom queue" do
       Backburner::Worker.enqueue TestJob, [6, 7], :queue => "test.bar", :pri => 5000
       pop_one_job("test.bar") do |job, body|
@@ -60,6 +82,31 @@ describe "Backburner::Worker module" do
       end
     end # custom
 
+    it "should round a fractional delay up to whole seconds, so the job never runs early" do
+      conn = beanstalk_connection
+      { nil => 0, -1 => 0, 0 => 0, 0.2 => 1, 1 => 1, 1.5 => 2, 2 => 2 }.each do |delay, expected|
+        response = Backburner::Worker.enqueue TestPlainJob, [1, 2], :delay => delay
+        assert_equal expected, conn.jobs.find(response[:id]).stats.delay, "delay #{delay.inspect}"
+      end
+    ensure
+      conn.close if conn
+      clear_jobs!("test-plain")
+    end # fractional delay
+
+    it "should round a fractional TTR up to whole seconds, from an option, a class or the default" do
+      respond_timeout = Backburner.configuration.respond_timeout
+      conn = beanstalk_connection
+      ttr_of = lambda { |response| conn.jobs.find(response[:id]).stats.ttr }
+      assert_equal 1, ttr_of.call(Backburner::Worker.enqueue(TestPlainJob, [1, 2], :ttr => 0.2))
+      assert_equal 2, ttr_of.call(Backburner::Worker.enqueue(TestFloatRespondTimeoutJob, []))
+      Backburner.configuration.respond_timeout = 2.5
+      assert_equal 3, ttr_of.call(Backburner::Worker.enqueue(TestPlainJob, [1, 2]))
+    ensure
+      Backburner.configuration.respond_timeout = respond_timeout
+      conn.close if conn
+      clear_jobs!("test-plain")
+    end # fractional ttr
+
     it "should support async job" do
       TestAsyncJob.async(:ttr => 100, :queue => "bar.baz.foo").foo(10, 5)
       pop_one_job("bar.baz.foo") do |job, body|
@@ -80,6 +127,282 @@ describe "Backburner::Worker module" do
     end
   end # enqueue
 
+  describe "for the enqueue connections" do
+    before do
+      GC.start # closes the connections earlier tests left to the garbage collector before a test counts them
+      @gc_was_disabled = GC.disable # and keeps a collection from closing one while it counts
+      @stats_connection = beanstalk_connection
+      @beanstalk_url = Backburner.configuration.beanstalk_url
+    end
+
+    after do
+      GC.enable unless @gc_was_disabled
+      @stats_connection.close
+      Backburner.configuration.beanstalk_url = @beanstalk_url
+    end
+
+    # Connections beanstalkd has accepted so far
+    def total_connections
+      @stats_connection.stats.total_connections
+    end
+
+    def open_connections
+      @stats_connection.stats.current_connections
+    end
+
+    def enqueue(n = 0)
+      Backburner::Worker.enqueue(TestJob, [n, 0])
+    end
+
+    # Starts the pool afresh: a new URL (spelling the same beanstalkd) closes its idle connections.
+    # Leaves one idle connection in it.
+    def fresh_pool
+      ["beanstalk://127.0.0.1:11300", "beanstalk://127.0.0.1:11300/"].each do |url|
+        Backburner.configuration.beanstalk_url = url
+        enqueue
+      end
+      settle
+    end
+
+    # Waits for beanstalkd to have seen the connections closed so far
+    def settle
+      last = nil
+      wait_for(5) { (now = open_connections) == last || (last = now; sleep 0.1; false) }
+    end
+
+    it "should reuse a connection for sequential enqueues" do
+      enqueue
+      before_count = total_connections
+      responses = Array.new(5) { |i| enqueue(i) }
+      assert_equal ["INSERTED"] * 5, responses.map { |res| res[:status] }
+      assert_equal 0, total_connections - before_count
+    end
+
+    it "should reuse a connection across fibers and threads" do
+      enqueue
+      before_count = total_connections
+      5.times { |i| Fiber.new { enqueue(i) }.resume }
+      5.times { |i| Thread.new { enqueue(i) }.join }
+      assert_equal 0, total_connections - before_count
+    end
+
+    it "should keep at most 5 idle connections after concurrent enqueues" do
+      fresh_pool # one idle connection
+      before_total, before_open = total_connections, open_connections
+      threads, inside = 8, Queue.new
+      release = Queue.new
+      serializer = Backburner.configuration.job_serializer_proc
+      # every thread holds a connection until all of them do
+      Backburner.configuration.job_serializer_proc = lambda { |body| inside << 1; release.pop; body.to_json }
+      workers = Array.new(threads) { |i| Thread.new { enqueue(i) } }
+      threads.times { inside.pop }
+      threads.times { release << 1 }
+      workers.each(&:join)
+      Backburner.configuration.job_serializer_proc = serializer
+      assert_equal threads - 1, total_connections - before_total, "one reused, the rest opened"
+      kept = 5
+      wait_for(5) { open_connections - before_open == kept - 1 }
+      assert_equal kept - 1, open_connections - before_open, "only #{kept} stay open"
+    ensure
+      Backburner.configuration.job_serializer_proc = serializer if serializer
+    end
+
+    it "should give a forked child its own connection" do
+      skip "needs fork" unless Process.respond_to?(:fork)
+      enqueue(1)
+      before_child = total_connections
+      pid = Process.fork do
+        res = Backburner::Worker.enqueue(TestJob, [2, 0]) rescue nil
+        exit!(res && res[:status] == "INSERTED" ? 0 : 1)
+      end
+      Process.wait(pid)
+      assert_equal 0, $?.exitstatus, "the child's enqueue failed"
+      assert_equal 1, total_connections - before_child, "the child should open its own connection"
+      assert_equal "INSERTED", enqueue(3)[:status]
+      assert_equal 1, total_connections - before_child, "the parent should keep its connection"
+    end
+
+    it "should close a connection that an error interrupted instead of reusing it" do
+      fresh_pool # one idle connection
+      before_total, before_open = total_connections, open_connections
+      serializer = Backburner.configuration.job_serializer_proc
+      Backburner.configuration.job_serializer_proc = lambda { |body| raise Timeout::Error }
+      assert_raises(Timeout::Error) { enqueue(2) }
+      Backburner.configuration.job_serializer_proc = serializer
+      wait_for(5) { open_connections == before_open - 1 }
+      assert_equal before_open - 1, open_connections, "the interrupted connection should be closed"
+      assert_equal "INSERTED", enqueue(3)[:status]
+      assert_equal 1, total_connections - before_total, "the next enqueue should open a new connection"
+    ensure
+      Backburner.configuration.job_serializer_proc = serializer if serializer
+    end
+
+    it "should close a connection whose enqueue was killed" do
+      fresh_pool # one idle connection
+      before_total, before_open = total_connections, open_connections
+      serializer = Backburner.configuration.job_serializer_proc
+      inside = Queue.new
+      Backburner.configuration.job_serializer_proc = lambda { |body| inside << 1; sleep }
+      thread = Thread.new { enqueue(2) }
+      inside.pop
+      thread.kill.join
+      Backburner.configuration.job_serializer_proc = serializer
+      wait_for(5) { open_connections == before_open - 1 }
+      assert_equal before_open - 1, open_connections, "the killed enqueue's connection should be closed"
+      assert_equal "INSERTED", enqueue(3)[:status]
+      assert_equal 1, total_connections - before_total, "the next enqueue should open a new connection"
+    ensure
+      Backburner.configuration.job_serializer_proc = serializer if serializer
+    end
+
+    it "should replace a connection idle for longer than enqueue_connection_max_idle" do
+      max_idle = Backburner.configuration.enqueue_connection_max_idle
+      fresh_pool # one idle connection
+      before_total, before_open = total_connections, open_connections
+      Backburner.configuration.enqueue_connection_max_idle = 0.05
+      sleep 0.1
+      assert_equal "INSERTED", enqueue(1)[:status]
+      assert_equal 1, total_connections - before_total, "the expired connection should be replaced"
+      wait_for(5) { open_connections == before_open }
+      assert_equal before_open, open_connections, "the expired connection should be closed"
+      Backburner.configuration.enqueue_connection_max_idle = 60
+      assert_equal "INSERTED", enqueue(2)[:status]
+      assert_equal 1, total_connections - before_total, "a fresh connection should be reused"
+    ensure
+      Backburner.configuration.enqueue_connection_max_idle = max_idle
+    end
+
+    describe "when beanstalkd goes away" do
+      before do
+        pick_beanstalkd_port
+        @beanstalk_url = Backburner.configuration.beanstalk_url
+        Backburner.configuration.beanstalk_url = "beanstalk://127.0.0.1:#{@port}"
+        start_beanstalkd
+      end
+
+      after do
+        stop_beanstalkd
+        Backburner.configuration.beanstalk_url = @beanstalk_url if @beanstalk_url
+      end
+
+      it "should recover from a restart and from Beaneater::NotConnected" do
+        Thread.new do
+          assert_equal "INSERTED", Backburner::Worker.enqueue(TestJob, [1, 0])[:status]
+          stop_beanstalkd
+          start_beanstalkd
+          assert_equal "INSERTED", Backburner::Worker.enqueue(TestJob, [2, 0])[:status]
+          stop_beanstalkd
+          assert_raises(Beaneater::NotConnected) { Backburner::Worker.enqueue(TestJob, [3, 0]) }
+          start_beanstalkd
+          assert_equal "INSERTED", Backburner::Worker.enqueue(TestJob, [4, 0])[:status]
+        end.join
+      end
+    end # beanstalkd goes away
+  end # enqueue connection
+
+  describe "without a tube_namespace" do
+    before { @tube_namespace = Backburner.configuration.tube_namespace }
+    after { Backburner.configuration.tube_namespace = @tube_namespace }
+
+    def reserve_from(tube_name)
+      connection = beanstalk_connection
+      connection.tubes.watch!(tube_name)
+      job = connection.tubes.reserve(1)
+      job.delete
+      Backburner.configuration.job_parser_proc.call(job.body)
+    ensure
+      connection.close if connection
+    end
+
+    it "should enqueue on unprefixed tubes when tube_namespace is nil or false" do
+      [nil, false].each do |namespace|
+        Backburner.configuration.tube_namespace = namespace
+        Backburner::Worker.enqueue TestJob, [1, namespace.inspect]
+        Backburner::Worker.enqueue TestJob, [2, namespace.inspect], :queue => "test-no-namespace"
+        assert_equal [1, namespace.inspect], reserve_from("backburner-jobs")["args"]
+        assert_equal [2, namespace.inspect], reserve_from("test-no-namespace")["args"]
+      end
+    end
+
+    it "should enqueue on the tubes 1.7.0 used when tube_namespace is empty" do
+      Backburner.configuration.tube_namespace = ""
+      Backburner::Worker.enqueue TestJob, [1, 2]
+      Backburner::Worker.enqueue TestJob, [3, 4], :queue => "test-no-namespace"
+      assert_equal [1, 2], reserve_from(".backburner-jobs")["args"]
+      assert_equal [3, 4], reserve_from(".test-no-namespace")["args"]
+    end
+
+    it "should list existing unprefixed tubes for a worker given no tubes" do
+      Backburner.configuration.tube_namespace = false
+      Backburner::Worker.enqueue TestJob, [1, 2], :queue => "test-no-namespace"
+      assert_contains Backburner::Worker.new(nil).tube_names, "test-no-namespace"
+      reserve_from("test-no-namespace")
+    end
+  end # without a tube_namespace
+
+  describe "for a worker given no tubes" do
+    before do
+      @tube_namespace = Backburner.configuration.tube_namespace
+      @namespace_separator = Backburner.configuration.namespace_separator
+    end
+    after do
+      Backburner.configuration.tube_namespace = @tube_namespace
+      Backburner.configuration.namespace_separator = @namespace_separator
+    end
+
+    # Namespaces, separators and queue names (ActiveJob's queue_name_prefix gives "production_mailers") whose
+    # tubes the worker used to miss: it expanded the tube names it found on the server again ("a--b" raised)
+    it "should watch the tubes enqueued on for its namespace, under their names on the server" do
+      [["MyApp", ".", "default"], ["jobs(eu)", ".", "default"], ["app+", ".", "default"], ["bb-discovery", "_", "default"],
+       ["production", ".", "production_mailers"], ["bb-discovery", ".", "report_2026"], ["bb-discovery", ".", "a__b"]].each do |namespace, separator, queue|
+        Backburner.configuration.tube_namespace = namespace
+        Backburner.configuration.namespace_separator = separator
+        tube_name = Backburner::Worker.expand_tube_name(queue)
+        connection = beanstalk_connection # no jobs left in this namespace for the worker to take first
+        connection.tubes.all.select { |tube| tube.name.start_with?("#{namespace}#{separator}") }.each(&:clear)
+        connection.close
+        Backburner::Worker.enqueue TestJob, [1, 2], :queue => queue
+
+        [Backburner::Workers::Simple, Backburner::Workers::Forking, Backburner::Workers::Threading, Backburner::Workers::ThreadsOnFork].each do |worker_class|
+          worker = worker_class.new(nil)
+          capture_stdout { worker.prepare }
+          worker.connection.close
+          assert_contains worker.tube_names, tube_name, "#{worker_class.name} #{[namespace, separator, queue].inspect}"
+        end
+        $worker_test_count = 0
+        worker = Backburner::Workers::Simple.new(nil)
+        silenced(3) { worker.prepare; worker.work_one_job }
+        worker.connection.close
+        assert_equal 3, $worker_test_count, [namespace, separator, queue].inspect
+      end
+    end
+
+    # Another app's tubes on a shared server: the worker expanded them into tubes nobody enqueues on, so it never took
+    # their jobs, and mustn't start to
+    it "should leave out the tubes its namespace and separator can't give" do
+      [[["bb-discovery_admin", "_"], ["bb-discovery", "_"]], [["MyApp.Admin", "."], ["MyApp", "."]],
+       [["bb-other", "."], ["bb:disc", "."]]].each do |(other_namespace, other_separator), (namespace, separator)|
+        Backburner.configuration.tube_namespace = other_namespace
+        Backburner.configuration.namespace_separator = other_separator
+        other_tube = Backburner::Worker.expand_tube_name("reports")
+        begin
+          Backburner::Worker.enqueue TestJob, [1, 2], :queue => "reports"
+          Backburner.configuration.tube_namespace = namespace
+          Backburner.configuration.namespace_separator = separator
+          worker = Backburner::Workers::Simple.new(nil)
+          capture_stdout { worker.prepare }
+          worker.connection.close
+          refute_includes worker.tube_names, other_tube, namespace
+          assert_equal ["bb"], worker.tube_names, namespace if namespace == "bb:disc" # a ':' cuts every tube name to "bb"
+        ensure
+          connection = beanstalk_connection
+          connection.tubes.find(other_tube).clear
+          connection.close
+        end
+      end
+    end
+  end # given no tubes
+
   describe "for start class method" do
     it "should initialize and start the worker instance" do
       ech = stub
@@ -89,6 +412,28 @@ describe "Backburner::Worker module" do
     end
   end # start
 
+  describe "for gc_disabled_on_exit? class method" do
+    it "should be true only on CRuby 3.3, the Ruby whose forked children can crash as they exit" do
+      assert Backburner::Worker.gc_disabled_on_exit?("ruby", "3.3.6")
+      %w(2.7.8 3.2.6 3.4.1 4.0.0).each do |version|
+        refute Backburner::Worker.gc_disabled_on_exit?("ruby", version), version
+      end
+      refute Backburner::Worker.gc_disabled_on_exit?("jruby", "3.3.0")
+    end
+  end # gc_disabled_on_exit?
+
+  describe "with an anonymous subclass of a queue class" do
+    before { @anonymous = Class.new(TestNamedQueueJob) }
+    after { Backburner::Worker.known_queue_classes.delete(@anonymous) }
+
+    it "should leave it out of the known queues of a worker given no tubes" do
+      [Backburner::Workers::Simple, Backburner::Workers::Threading, Backburner::Workers::ThreadsOnFork].each do |worker_class|
+        assert_contains worker_class.new(nil).tube_names.map { |name| Backburner::Worker.expand_tube_name(name) },
+          Backburner::Worker.expand_tube_name("testnamedqueuejob"), worker_class.name
+      end
+    end
+  end # anonymous subclass
+
   describe "for tube_names accessor" do
     before do
       Backburner.default_queues << "baz"

data/test/workers/forking_worker_test.rb

@@ -70,11 +70,29 @@ describe "Backburner::Workers::Forking module" do
       @worker_class.any_instance.expects(:coolest_exit)
       Process.expects(:wait).with(fake_pid)
 
+      gc_was_disabled = GC.disable # the child's body runs in this process, and disables the GC as it ends
+      GC.enable unless gc_was_disabled
       silenced(2) do
         worker = @worker_class.new('bar.foo')
         worker.prepare
         worker.fork_one_job
       end
+    ensure
+      GC.enable unless gc_was_disabled
+    end
+
+    # A child leaves work_one_job by an exception when a job calls exit, on a TERM or INT, or on an
+    # error work_one_job doesn't rescue, and then exits through the interpreter's teardown
+    [:raise, :shutdown].each do |how|
+      it "should disable the GC in the child before the interpreter's teardown (#{how})" do
+        Backburner::Worker.stubs(:gc_disabled_on_exit?).returns(true) # as on Ruby 3.3
+        worker = @worker_class.new('bar.foo')
+        gc_disabled = gc_disabled_at_child_exit?(worker, how) do |body|
+          worker.define_singleton_method(:work_one_job) { |*| body.call }
+          worker.fork_one_job
+        end
+        assert gc_disabled, "the child's GC was still enabled when it exited"
+      end
     end
 
   end # fork_one_job
@@ -96,7 +114,7 @@ describe "Backburner::Workers::Forking module" do
 
     after do
       @templogger.close
-      Backburner.configuration.logger = nil
+      Backburner.configure { |config| config.max_job_retries = 0; config.retry_delay = 5; config.logger = nil }
       clear_jobs!('response')
       clear_jobs!('bar.foo.1', 'bar.foo.2', 'bar.foo.3', 'bar.foo.4', 'bar.foo.5')
     end