canvas-jobs 0.10.6 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c17b53cc20eeba1d6def3d6defed59ec2f4e6786
-  data.tar.gz: 462039f0631c4c8446e485ff09543c2430958fd9
+  metadata.gz: 1682d0b7ae6c1e398bab7b3ed4e93b45c5f667f6
+  data.tar.gz: 9bcfe44b61d28af0f81f9e9036832468d5aad5a8
 SHA512:
-  metadata.gz: 479c5177f7f37fa4c2f84caf850f214a316def2cc182f815bb59ef63f905490912e6b87396f57df6e87eee6af77b45047f4a2051ecf1076d467ebf963a0a01a7
-  data.tar.gz: 779faa887354c56f5dcba06e16e1bc52f20d0084c0b432d59c282afc0908a74d32eb51ca83e1067cdf833daa1d5461e44c1e78607bf0d9443aa16e02f5e27ccf
+  metadata.gz: 258d4db18ca5cdc41940d03488b3537ef39f5c95385bad4fe6a007013d3785746bea9cc13218db45ed04fcc0d6eb157cc0b052039e294e1d4a7a5bd4615acd76
+  data.tar.gz: 9e085133db62875654a88b6955a85e53f7e6aaeec14d067d04e912cf3728fcaacd65036b08266fb97f90ec9c53a32d7368f1ae753b2e2ea3a793e3b4ed481b67

data/lib/delayed/cli.rb

@@ -4,10 +4,8 @@ module Delayed
 class CLI
   def initialize(args = ARGV)
     @args = args
-    # config that will be applied on Settings
+    # config that will be applied on Settings and passed to the created Pool
     @config = {}
-    # worker configs that will be passed to the created Pool
-    @worker_configs = []
     # CLI options that will be kept to this class
     @options = {
       :config_file => Settings.default_worker_config_name,
@@ -56,7 +54,6 @@ class CLI
 
   def load_and_apply_config!
     @config = Settings.worker_config(@options[:config_file])
-    @worker_configs = @config.delete(:workers)
     Settings.apply_worker_config!(@config)
   end
 
@@ -88,7 +85,7 @@ class CLI
   def start
     load_rails
     tail_rails_log unless daemon.daemonized?
-    Delayed::Pool.new(@worker_configs).start
+    Delayed::Pool.new(@config).start
   end
 
   def load_rails

data/lib/delayed/lifecycle.rb

@@ -10,6 +10,7 @@ module Delayed
       :loop             => [:worker],
       :perform          => [:worker, :job],
       :pop              => [:worker],
+      :work_queue_pop   => [:work_queue],
     }
 
     def initialize

data/lib/delayed/pool.rb

@@ -6,13 +6,12 @@ class Pool
   attr_reader :workers
 
   def initialize(*args)
-    if args.size == 1 && args.first.is_a?(Array)
-      worker_configs = args.first
+    if args.first.is_a?(Hash)
+      @config = args.first
     else
       warn "Calling Delayed::Pool.new directly is deprecated. Use `Delayed::CLI.new.run()` instead."
     end
     @workers = {}
-    @config = { workers: worker_configs }
   end
 
   def run
@@ -66,16 +65,31 @@ class Pool
   def spawn_all_workers
     ActiveRecord::Base.connection_handler.clear_all_connections!
 
+    if @config[:work_queue] == 'parent_process'
+      @work_queue = WorkQueue::ParentProcess.new
+      spawn_work_queue
+    end
+
     @config[:workers].each do |worker_config|
       (worker_config[:workers] || 1).times { spawn_worker(worker_config) }
     end
   end
 
+  def spawn_work_queue
+    parent_pid = Process.pid
+    pid = fork_with_reconnects do
+      $0 = "delayed_jobs_work_queue#{Settings.pool_procname_suffix}"
+      @work_queue.server(parent_pid: parent_pid).run
+    end
+    workers[pid] = :work_queue
+  end
+
   def spawn_worker(worker_config)
     if worker_config[:periodic]
       return # backwards compat
     else
       worker_config[:parent_pid] = Process.pid
+      worker_config[:work_queue] = @work_queue.client if @work_queue
       worker = Delayed::Worker.new(worker_config)
     end
 
@@ -125,8 +139,12 @@ class Pool
       child = Process.wait
       if workers.include?(child)
         worker = workers.delete(child)
-        if worker.is_a?(Symbol)
+        case worker
+        when :periodic_audit
           say "ran auditor: #{worker}"
+        when :work_queue
+          say "work queue exited, restarting", :info
+          spawn_work_queue
         else
           say "child exited: #{child}, restarting", :info
           # fork to handle unlocking (to prevent polluting the parent with worker objects)

data/lib/delayed/settings.rb

@@ -17,6 +17,7 @@ module Delayed
       :disable_periodic_jobs,
       :disable_automatic_orphan_unlocking,
       :last_ditch_logfile,
+      :parent_process_client_timeout,
     ]
     SETTINGS_WITH_ARGS = [ :num_strands ]
 
@@ -43,6 +44,7 @@ module Delayed
     self.fetch_batch_size = 5
     self.select_random_from_batch = false
     self.silence_periodic_log = false
+    self.parent_process_client_timeout = 10.0
 
     self.num_strands = ->(strand_name){ nil }
     self.default_job_options = ->{ Hash.new }

data/lib/delayed/version.rb

@@ -1,3 +1,3 @@
 module Delayed
-  VERSION = "0.10.6"
+  VERSION = "0.11.0"
 end

data/lib/delayed/work_queue/in_process.rb

@@ -0,0 +1,13 @@
+module Delayed
+module WorkQueue
+# The simplest possible implementation of a WorkQueue -- just turns around and
+# queries the queue inline.
+class InProcess
+  def get_and_lock_next_available(worker_name, queue_name, min_priority, max_priority)
+    Delayed::Worker.lifecycle.run_callbacks(:work_queue_pop, self) do
+      Delayed::Job.get_and_lock_next_available(worker_name, queue_name, min_priority, max_priority)
+    end
+  end
+end
+end
+end

data/lib/delayed/work_queue/parent_process.rb

@@ -0,0 +1,180 @@
+require 'socket'
+require 'tempfile'
+require 'timeout'
+
+module Delayed
+module WorkQueue
+# ParentProcess is a WorkQueue implementation that spawns a separate worker
+# process for querying the queue. Each Worker child process sends requests to
+# the ParentProcess via IPC, and receives responses. This centralized queue
+# querying cuts down on db queries and lock contention, and allows the
+# possibility for other centralized logic such as notifications when all workers
+# are idle.
+#
+# The IPC implementation uses Unix stream sockets and Ruby's built-in Marshal
+# functionality. The ParentProcess creates a Unix socket on the filesystem in
+# the tmp directory, so that if a worker process dies and is restarted it can
+# reconnect to the socket.
+#
+# While Unix and IP sockets are API compatible, we take a lot of shortcuts
+# because we know it's just a local Unix socket. If we ever wanted to swap this
+# out for a TCP/IP socket and have the WorkQueue running on another host, we'd
+# want to be a lot more robust about partial reads/writes and timeouts.
+class ParentProcess
+  class ProtocolError < RuntimeError
+  end
+
+  def initialize
+    @path = self.class.generate_socket_path
+  end
+
+  def self.generate_socket_path
+    # We utilize Tempfile as a convenient way to get a socket filename in the
+    # writeable temp directory. However, since we destroy the normal file and
+    # write a unix socket file to the same location, we lose the hard uniqueness
+    # guarantees of Tempfile. This is OK for this use case, we only generate one
+    # Tempfile with this prefix.
+    tmp = Tempfile.new("canvas-jobs-#{Process.pid}-")
+    path = tmp.path
+    tmp.close!
+    path
+  end
+
+  def server(parent_pid: nil)
+    # The unix_server_socket method takes care of cleaning up any existing
+    # socket for us if the work queue process dies and is restarted.
+    listen_socket = Socket.unix_server_socket(@path)
+    Server.new(listen_socket, parent_pid: parent_pid)
+  end
+
+  def client
+    Client.new(Addrinfo.unix(@path))
+  end
+
+  class Client
+    attr_reader :addrinfo
+
+    def initialize(addrinfo)
+      @addrinfo = addrinfo
+    end
+
+    def get_and_lock_next_available(name, queue_name, min_priority, max_priority)
+      @socket ||= @addrinfo.connect
+      Marshal.dump([name, queue_name, min_priority, max_priority], @socket)
+      response = Marshal.load(@socket)
+      unless response.nil? || (response.is_a?(Delayed::Job) && response.locked_by == name)
+        raise(ProtocolError, "response is not a locked job: #{response.inspect}")
+      end
+      response
+    rescue SystemCallError, IOError
+      # The work queue process died. Return nil to signal the worker
+      # process should sleep as if no job was found, and then retry.
+      @socket = nil
+      nil
+    end
+  end
+
+  class Server
+    attr_reader :listen_socket
+
+    def initialize(listen_socket, parent_pid: nil)
+      @listen_socket = listen_socket
+      @parent_pid = parent_pid
+      @clients = {}
+    end
+
+    def connected_clients
+      @clients.size
+    end
+
+    def all_workers_idle?
+      !@clients.any? { |_, c| c.working }
+    end
+
+    def say(msg, level = :debug)
+      if defined?(Rails.logger) && Rails.logger
+        Rails.logger.send(level, "[#{Process.pid}]Q #{msg}")
+      else
+        puts(msg)
+      end
+    end
+
+    # run the server queue worker
+    # this method does not return, only exits or raises an exception
+    def run
+      say "Starting work queue process"
+
+      while !exit?
+        run_once
+      end
+
+    rescue => e
+      say "WorkQueue Server died: #{e.inspect}"
+      raise
+    end
+
+    def run_once
+      handles = @clients.keys + [@listen_socket]
+      readable, _, _ = IO.select(handles, nil, nil, 1)
+      if readable
+        readable.each { |s| handle_read(s) }
+      end
+    end
+
+    def handle_read(socket)
+      if socket == @listen_socket
+        handle_accept
+      else
+        handle_request(socket)
+      end
+    end
+
+    # Any error on the listen socket other than WaitReadable will bubble up
+    # and terminate the work queue process, to be restarted by the parent daemon.
+    def handle_accept
+      client, _addr = @listen_socket.accept_nonblock
+      if client
+        @clients[client] = ClientState.new(false)
+      end
+    rescue IO::WaitReadable
+      # ignore and just try accepting again next time through the loop
+    end
+
+    def handle_request(socket)
+      # There is an assumption here that the client will never send a partial
+      # request and then leave the socket open. Doing so would leave us hanging
+      # here forever. This is only a reasonable assumption because we control
+      # the client.
+      request = client_timeout { Marshal.load(socket) }
+      response = nil
+      Delayed::Worker.lifecycle.run_callbacks(:work_queue_pop, self) do
+        response = Delayed::Job.get_and_lock_next_available(*request)
+        @clients[socket].working = !response.nil?
+      end
+      client_timeout { Marshal.dump(response, socket) }
+    rescue SystemCallError, IOError, Timeout::Error
+      # this socket went away
+      begin
+        socket.close
+      rescue IOError
+      end
+      @clients.delete(socket)
+    end
+
+    def exit?
+      parent_exited?
+    end
+
+    def parent_exited?
+      @parent_pid && @parent_pid != Process.ppid
+    end
+
+    def client_timeout
+      Timeout.timeout(Settings.parent_process_client_timeout) { yield }
+    end
+
+    ClientState = Struct.new(:working)
+  end
+end
+end
+end

data/lib/delayed/worker.rb

@@ -6,7 +6,7 @@ require 'tmpdir'
 require 'set'
 
 class Worker
-  attr_reader :config, :queue, :min_priority, :max_priority
+  attr_reader :config, :queue_name, :min_priority, :max_priority, :work_queue
 
   # Callback to fire when a delayed job fails max_attempts times. If this
   # callback is defined, then the value of destroy_failed_jobs is ignored, and
@@ -32,11 +32,12 @@ class Worker
     @exit = false
     @config = options
     @parent_pid = options[:parent_pid]
-    @queue = options[:queue] || Settings.queue
+    @queue_name = options[:queue] || Settings.queue
     @min_priority = options[:min_priority]
     @max_priority = options[:max_priority]
     @max_job_count = options[:worker_max_job_count].to_i
     @max_memory_usage = options[:worker_max_memory_usage].to_i
+    @work_queue = options[:work_queue] || WorkQueue::InProcess.new
     @job_count = 0
 
     app = Rails.application
@@ -93,14 +94,9 @@ class Worker
 
   def run
     self.class.lifecycle.run_callbacks(:loop, self) do
-      job =
-          self.class.lifecycle.run_callbacks(:pop, self) do
-            Delayed::Job.get_and_lock_next_available(
-              name,
-              queue,
-              min_priority,
-              max_priority)
-          end
+      job = self.class.lifecycle.run_callbacks(:pop, self) do
+        work_queue.get_and_lock_next_available(name, queue_name, min_priority, max_priority)
+      end
 
       if job
         configure_for_job(job) do
@@ -122,7 +118,7 @@ class Worker
           end
         end
       else
-        set_process_name("wait:#{Settings.worker_procname_prefix}#{@queue}:#{min_priority || 0}:#{max_priority || 'max'}")
+        set_process_name("wait:#{Settings.worker_procname_prefix}#{@queue_name}:#{min_priority || 0}:#{max_priority || 'max'}")
         sleep(Settings.sleep_delay + (rand * Settings.sleep_delay_stagger))
       end
     end

data/lib/delayed_job.rb

@@ -35,6 +35,8 @@ require 'delayed/periodic'
 require 'delayed/plugin'
 require 'delayed/pool'
 require 'delayed/worker'
+require 'delayed/work_queue/in_process'
+require 'delayed/work_queue/parent_process'
 
 require 'delayed/engine'
 

data/spec/active_record_job_spec.rb

@@ -19,7 +19,7 @@ describe 'Delayed::Backed::ActiveRecord::Job' do
     allow(Delayed::Job::Failed).to receive(:create).and_raise(RuntimeError)
     job = "test".send_later_enqueue_args :reverse, no_delay: true
     job_id = job.id
-    proc { job.fail! }.should raise_error
+    proc { job.fail! }.should raise_error(RuntimeError)
     proc { Delayed::Job.find(job_id) }.should raise_error(ActiveRecord::RecordNotFound)
     Delayed::Job.count.should == 0
   end
@@ -77,11 +77,11 @@ describe 'Delayed::Backed::ActiveRecord::Job' do
       end
 
       it "should raise error when holding failed jobs" do
-        expect { Delayed::Job.bulk_update('hold', :flavor => 'failed', :query => @query) }.to raise_error
+        expect { Delayed::Job.bulk_update('hold', :flavor => 'failed', :query => @query) }.to raise_error(RuntimeError)
       end
 
       it "should raise error unholding failed jobs" do
-        expect { Delayed::Job.bulk_update('unhold', :flavor => 'failed', :query => @query) }.to raise_error
+        expect { Delayed::Job.bulk_update('unhold', :flavor => 'failed', :query => @query) }.to raise_error(RuntimeError)
       end
     end
 

data/spec/delayed/work_queue/in_process_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+RSpec.describe Delayed::WorkQueue::InProcess do
+  before :all do
+    Delayed.select_backend(Delayed::Backend::ActiveRecord::Job)
+  end
+
+  after :all do
+    Delayed.send(:remove_const, :Job)
+  end
+
+  after :each do
+    Delayed::Worker.lifecycle.reset!
+  end
+
+  let(:subject) { described_class.new }
+  let(:args) { ["worker_name", "queue_name", 1, 2] }
+
+  it 'triggers the lifecycle event around the pop' do
+    called = false
+    Delayed::Worker.lifecycle.around(:work_queue_pop) do |queue, &cb|
+      expect(queue).to eq(subject)
+      expect(Delayed::Job).to receive(:get_and_lock_next_available).with(*args).and_return(:job)
+      called = true
+      cb.call(queue)
+    end
+    job = subject.get_and_lock_next_available(*args)
+    expect(job).to eq(:job)
+    expect(called).to eq(true)
+  end
+end

data/spec/delayed/work_queue/parent_process_spec.rb

@@ -0,0 +1,159 @@
+require 'spec_helper'
+
+RSpec.describe Delayed::WorkQueue::ParentProcess do
+  before :all do
+    Delayed.select_backend(Delayed::Backend::ActiveRecord::Job)
+  end
+
+  after :all do
+    Delayed.send(:remove_const, :Job)
+  end
+
+  after :each do
+    Delayed::Worker.lifecycle.reset!
+  end
+
+  let(:subject) { described_class.new }
+
+  it 'generates a server listening on a valid unix socket' do
+    server = subject.server
+    expect(server).to be_a(Delayed::WorkQueue::ParentProcess::Server)
+    expect(server.listen_socket.local_address.unix?).to be(true)
+    expect { server.listen_socket.accept_nonblock }.to raise_error(IO::WaitReadable)
+  end
+
+  it 'generates a client connected to the server unix socket' do
+    server = subject.server
+    client = subject.client
+    expect(client).to be_a(Delayed::WorkQueue::ParentProcess::Client)
+    expect(client.addrinfo.unix?).to be(true)
+    expect(client.addrinfo.unix_path).to eq(server.listen_socket.local_address.unix_path)
+  end
+
+  describe Delayed::WorkQueue::ParentProcess::Client do
+    let(:subject) { described_class.new(addrinfo) }
+    let(:addrinfo) { double('Addrinfo') }
+    let(:connection) { double('Socket') }
+    let(:args) { ["worker_name", "queue_name", 1, 2] }
+    let(:job) { Delayed::Job.new(locked_by: "worker_name") }
+
+    it 'marshals the given arguments to the server and returns the response' do
+      expect(addrinfo).to receive(:connect).once.and_return(connection)
+      expect(Marshal).to receive(:dump).with(args, connection).ordered
+      expect(Marshal).to receive(:load).with(connection).and_return(job).ordered
+      response = subject.get_and_lock_next_available(*args)
+      expect(response).to eq(job)
+    end
+
+    it 'returns nil and then reconnects on socket error' do
+      expect(addrinfo).to receive(:connect).once.and_return(connection)
+      expect(Marshal).to receive(:dump).and_raise(SystemCallError.new("failure"))
+      response = subject.get_and_lock_next_available(*args)
+      expect(response).to be_nil
+
+      expect(addrinfo).to receive(:connect).once.and_return(connection)
+      expect(Marshal).to receive(:dump).with(args, connection)
+      expect(Marshal).to receive(:load).with(connection).and_return(job)
+      response = subject.get_and_lock_next_available(*args)
+      expect(response).to eq(job)
+    end
+
+    it 'errors if the response is not a locked job' do
+      expect(addrinfo).to receive(:connect).once.and_return(connection)
+      expect(Marshal).to receive(:dump).with(args, connection)
+      expect(Marshal).to receive(:load).with(connection).and_return(:not_a_job)
+      expect { subject.get_and_lock_next_available(*args) }.to raise_error(Delayed::WorkQueue::ParentProcess::ProtocolError)
+    end
+
+    it 'errors if the response is a job not locked by this worker' do
+      expect(addrinfo).to receive(:connect).once.and_return(connection)
+      expect(Marshal).to receive(:dump).with(args, connection)
+      job.locked_by = "somebody_else"
+      expect(Marshal).to receive(:load).with(connection).and_return(job)
+      expect { subject.get_and_lock_next_available(*args) }.to raise_error(Delayed::WorkQueue::ParentProcess::ProtocolError)
+    end
+  end
+
+  describe Delayed::WorkQueue::ParentProcess::Server do
+    let(:subject) { described_class.new(listen_socket) }
+    let(:listen_socket) { Socket.unix_server_socket(Delayed::WorkQueue::ParentProcess.generate_socket_path) }
+    let(:args) { [1,2,3] }
+    let(:job) { :a_job }
+
+    it 'accepts new clients' do
+      client = Socket.unix(subject.listen_socket.local_address.unix_path)
+      expect { subject.run_once }.to change(subject, :connected_clients).by(1)
+    end
+
+    it 'queries the queue on client request' do
+      client = Socket.unix(subject.listen_socket.local_address.unix_path)
+      subject.run_once
+
+      expect(Delayed::Job).to receive(:get_and_lock_next_available).with(*args).and_return(job)
+      Marshal.dump(args, client)
+      subject.run_once
+      expect(Marshal.load(client)).to eq(job)
+    end
+
+    it 'drops the client on i/o error' do
+      client = Socket.unix(subject.listen_socket.local_address.unix_path)
+      subject.run_once
+
+      Marshal.dump(args, client)
+
+      expect(Marshal).to receive(:load).and_raise(IOError.new("socket went away"))
+      expect { subject.run_once }.to change(subject, :connected_clients).by(-1)
+    end
+
+    it 'drops the client on timeout' do
+      client = Socket.unix(subject.listen_socket.local_address.unix_path)
+      subject.run_once
+
+      Marshal.dump(args, client)
+
+      expect(Marshal).to receive(:load).and_raise(Timeout::Error.new("socket timed out"))
+      expect(Timeout).to receive(:timeout).with(Delayed::Settings.parent_process_client_timeout).and_yield
+      expect { subject.run_once }.to change(subject, :connected_clients).by(-1)
+    end
+
+    it 'tracks when clients are idle' do
+      expect(subject.all_workers_idle?).to be(true)
+
+      client = Socket.unix(subject.listen_socket.local_address.unix_path)
+      subject.run_once
+      expect(subject.all_workers_idle?).to be(true)
+
+      expect(Delayed::Job).to receive(:get_and_lock_next_available).with(*args).and_return(job)
+      Marshal.dump(args, client)
+      subject.run_once
+      expect(subject.all_workers_idle?).to be(false)
+
+      expect(Delayed::Job).to receive(:get_and_lock_next_available).with(*args).and_return(nil)
+      Marshal.dump(args, client)
+      subject.run_once
+      expect(subject.all_workers_idle?).to be(true)
+    end
+
+    it 'triggers the lifecycle event around the pop' do
+      called = false
+      client = Socket.unix(subject.listen_socket.local_address.unix_path)
+      subject.run_once
+
+      Delayed::Worker.lifecycle.around(:work_queue_pop) do |queue, &cb|
+        expect(subject.all_workers_idle?).to be(true)
+        expect(queue).to eq(subject)
+        expect(Delayed::Job).to receive(:get_and_lock_next_available).with(*args).and_return(job)
+        called = true
+        res = cb.call(queue)
+        expect(subject.all_workers_idle?).to be(false)
+        res
+      end
+
+      Marshal.dump(args, client)
+      subject.run_once
+
+      expect(Marshal.load(client)).to eq(job)
+      expect(called).to eq(true)
+    end
+  end
+end

data/spec/shared/delayed_batch.rb

@@ -29,7 +29,7 @@ shared_examples_for 'Delayed::Batch' do
       }
       Delayed::Job.jobs_count(:current).should == 1
       job = Delayed::Job.find_available(1).first
-      expect{ job.invoke_job }.to raise_error
+      expect{ job.invoke_job }.to raise_error(RuntimeError)
     end
 
     it "should create valid jobs" do

data/spec/shared/performable_method.rb

@@ -1,12 +1,12 @@
 shared_examples_for 'Delayed::PerformableMethod' do
-  
+
   it "should not ignore ActiveRecord::RecordNotFound errors because they are not always permanent" do
     story = Story.create :text => 'Once upon...'
     p = Delayed::PerformableMethod.new(story, :tell, [])
     story.destroy
-    lambda { YAML.load(p.to_yaml) }.should raise_error
+    lambda { YAML.load(p.to_yaml) }.should raise_error(Delayed::Backend::RecordNotFound)
   end
-  
+
   it "should store the object using native YAML even if its an active record" do
     story = Story.create :text => 'Once upon...'
     p = Delayed::PerformableMethod.new(story, :tell, [])
@@ -16,7 +16,7 @@ shared_examples_for 'Delayed::PerformableMethod' do
     p.args.should    == []
     p.perform.should == 'Once upon...'
   end
-  
+
   it "should allow class methods to be called on ActiveRecord models" do
     Story.create!(:text => 'Once upon a...')
     p = Delayed::PerformableMethod.new(Story, :count, [])
@@ -32,7 +32,7 @@ shared_examples_for 'Delayed::PerformableMethod' do
     p = Delayed::PerformableMethod.new(MyReverser, :reverse, ["ohai"])
     lambda { p.send(:perform).should == "iaho" }.should_not raise_error
   end
-  
+
   it "should store arguments as native YAML if they are active record objects" do
     story = Story.create :text => 'Once upon...'
     reader = StoryReader.new

data/spec/shared/shared_backend.rb

@@ -429,10 +429,10 @@ shared_examples_for 'a backend' do
         Delayed::Periodic.scheduled = {}
         expect { Delayed::Periodic.cron('my ChangedJob', '*/5 * * * * *') do
           Delayed::Job.enqueue(SimpleJob.new)
-        end }.to raise_error
+        end }.to raise_error(ArgumentError)
       end
 
-      expect { Delayed::Periodic.add_overrides({ 'my ChangedJob' => '*/10 * * * * * *' }) }.to raise_error
+      expect { Delayed::Periodic.add_overrides({ 'my ChangedJob' => '*/10 * * * * * *' }) }.to raise_error(ArgumentError)
     end
   end
 
@@ -451,12 +451,12 @@ shared_examples_for 'a backend' do
 
   it "should fail on job creation if an unsaved AR object is used" do
     story = Story.new :text => "Once upon..."
-    lambda { story.send_later(:text) }.should raise_error
+    lambda { story.send_later(:text) }.should raise_error(RuntimeError)
 
     reader = StoryReader.new
-    lambda { reader.send_later(:read, story) }.should raise_error
+    lambda { reader.send_later(:read, story) }.should raise_error(RuntimeError)
 
-    lambda { [story, 1, story, false].send_later(:first) }.should raise_error
+    lambda { [story, 1, story, false].send_later(:first) }.should raise_error(RuntimeError)
   end
 
   # the sort order of current_jobs and list_jobs depends on the back-end

data/spec/shared/worker.rb

@@ -285,14 +285,14 @@ shared_examples_for 'Delayed::Worker' do
       queue_name = "default_queue"
       Delayed::Settings.queue = queue_name
       worker = worker_create(:queue=>nil)
-      worker.queue.should == queue_name
+      worker.queue_name.should == queue_name
     end
 
     it "should override default queue name if specified in initialize" do
       queue_name = "my_queue"
       Delayed::Settings.queue = "default_queue"
       worker = worker_create(:queue=>queue_name)
-      worker.queue.should == queue_name
+      worker.queue_name.should == queue_name
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: canvas-jobs
 version: !ruby/object:Gem::Version
-  version: 0.10.6
+  version: 0.11.0
 platform: ruby
 authors:
 - Tobias Luetke
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-04 00:00:00.000000000 Z
+date: 2016-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: after_transaction_commit
@@ -157,14 +157,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.1.0
+        version: 3.4.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.1.0
+        version: 3.4.0
 - !ruby/object:Gem::Dependency
   name: test_after_commit
   requirement: !ruby/object:Gem::Requirement
@@ -313,6 +313,8 @@ files:
 - lib/delayed/settings.rb
 - lib/delayed/testing.rb
 - lib/delayed/version.rb
+- lib/delayed/work_queue/in_process.rb
+- lib/delayed/work_queue/parent_process.rb
 - lib/delayed/worker.rb
 - lib/delayed/yaml_extensions.rb
 - lib/delayed_job.rb
@@ -321,6 +323,8 @@ files:
 - spec/delayed/daemon_spec.rb
 - spec/delayed/server_spec.rb
 - spec/delayed/settings_spec.rb
+- spec/delayed/work_queue/in_process_spec.rb
+- spec/delayed/work_queue/parent_process_spec.rb
 - spec/delayed/worker_spec.rb
 - spec/gemfiles/32.gemfile
 - spec/gemfiles/40.gemfile
@@ -366,6 +370,8 @@ test_files:
 - spec/delayed/daemon_spec.rb
 - spec/delayed/server_spec.rb
 - spec/delayed/settings_spec.rb
+- spec/delayed/work_queue/in_process_spec.rb
+- spec/delayed/work_queue/parent_process_spec.rb
 - spec/delayed/worker_spec.rb
 - spec/gemfiles/32.gemfile
 - spec/gemfiles/40.gemfile