inst-jobs 0.11.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bc63ba5e864d96838548c1219044e8f8a1cc9435
-  data.tar.gz: 94ba64f0cac98fafb26b46552267e0ad84197561
+  metadata.gz: fdcb9f78f236ad4d8c70bc96f61d50b9a1df60f1
+  data.tar.gz: c931fcff9a08ea2022b3984a210bf46fbe6fcea6
 SHA512:
-  metadata.gz: 277a619901441ba700552e5c6bff8c93117929d8615ce0a87aa7582f16c045572b33468e4b0e8a967421bc1ad7d3a5bdf5c2c201f95b9e1b9bedd3bf17fbf4f3
-  data.tar.gz: 3b2b21740daba532b04504f720601430e8603203e4815376d7522ec8bbd9ba9d7c836a9d041a15e84fdcf688709cfbabbe94fa4653b58ef008343d323e1bc41c
+  metadata.gz: d235844cce086cab4981aa6434c1300a482582a65570245f575405ec12079c24aa0178aa411e0a7628fbd4950bb8cea22d7b2543622e21746058d529da69433f
+  data.tar.gz: 476c8716bc4b1328bd502d1e7acc37fea629e468da21582d09ee62b7556fcfee506de88a6d50dfbe761638c86dc90e6869f550d755519c6c5eeb41342359ad24

data/lib/delayed/lifecycle.rb

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

data/lib/delayed/settings.rb

@@ -82,7 +82,7 @@ module Delayed
       root = if defined?(Rails) && Rails.root
         (Rails.root+"Gemfile").to_s
       else
-        ENV.fetch('BUNDLE_GEMFILE')
+        ENV.fetch('BUNDLE_GEMFILE', Dir.pwd+"/Gemfile")
       end
       File.expand_path("../#{path}", root)
     end

data/lib/delayed/version.rb

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

data/lib/delayed/work_queue/in_process.rb

@@ -3,9 +3,13 @@ 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)
+  def get_and_lock_next_available(worker_name, worker_config)
+    Delayed::Worker.lifecycle.run_callbacks(:work_queue_pop, self, worker_name, worker_config) do
+      Delayed::Job.get_and_lock_next_available(
+        worker_name,
+        worker_config[:queue],
+        worker_config[:min_priority],
+        worker_config[:max_priority])
     end
   end
 end

data/lib/delayed/work_queue/parent_process.rb

@@ -58,11 +58,11 @@ class ParentProcess
       @addrinfo = addrinfo
     end
 
-    def get_and_lock_next_available(name, queue_name, min_priority, max_priority)
+    def get_and_lock_next_available(worker_name, worker_config)
       @socket ||= @addrinfo.connect
-      Marshal.dump([name, queue_name, min_priority, max_priority], @socket)
+      Marshal.dump([worker_name, worker_config], @socket)
       response = Marshal.load(@socket)
-      unless response.nil? || (response.is_a?(Delayed::Job) && response.locked_by == name)
+      unless response.nil? || (response.is_a?(Delayed::Job) && response.locked_by == worker_name)
         raise(ProtocolError, "response is not a locked job: #{response.inspect}")
       end
       response
@@ -145,10 +145,14 @@ class ParentProcess
       # 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) }
+      worker_name, worker_config = 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)
+      Delayed::Worker.lifecycle.run_callbacks(:work_queue_pop, self, worker_name, worker_config) do
+        response = Delayed::Job.get_and_lock_next_available(
+          worker_name,
+          worker_config[:queue],
+          worker_config[:min_priority],
+          worker_config[:max_priority])
         @clients[socket].working = !response.nil?
       end
       client_timeout { Marshal.dump(response, socket) }

data/lib/delayed/worker.rb

@@ -30,14 +30,14 @@ class Worker
 
   def initialize(options = {})
     @exit = false
-    @config = options
     @parent_pid = options[:parent_pid]
-    @queue_name = 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
+    @work_queue = options.delete(:work_queue) || WorkQueue::InProcess.new
+    @config = options
     @job_count = 0
 
     app = Rails.application
@@ -95,7 +95,7 @@ class Worker
   def run
     self.class.lifecycle.run_callbacks(:loop, self) do
       job = self.class.lifecycle.run_callbacks(:pop, self) do
-        work_queue.get_and_lock_next_available(name, queue_name, min_priority, max_priority)
+        work_queue.get_and_lock_next_available(name, config)
       end
 
       if job

data/lib/delayed/yaml_extensions.rb

@@ -81,7 +81,7 @@ module Delayed
           rescue ActiveRecord::RecordNotFound
             raise Delayed::Backend::RecordNotFound, "Couldn't find #{klass} with id #{object.value.inspect}"
           end
-        when "tag:ruby.yaml.org,2002:Delayed::Periodic", "!ruby/Delayed::Periodic"
+        when "tag:ruby.yaml.org,2002:Delayed::Periodic", "!ruby/Delayed::Periodic", "!ruby/object:Delayed::Periodic"
           Delayed::Periodic.scheduled[object.value] || raise(NameError, "job #{object.value} is no longer scheduled")
         else
           super

data/spec/delayed/work_queue/in_process_spec.rb

@@ -14,13 +14,16 @@ RSpec.describe Delayed::WorkQueue::InProcess do
   end
 
   let(:subject) { described_class.new }
-  let(:args) { ["worker_name", "queue_name", 1, 2] }
+  let(:worker_config) { {queue: "test", min_priority: 1, max_priority: 2} }
+  let(:args) { ["worker_name", worker_config] }
 
   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)
+      expect(Delayed::Job).to receive(:get_and_lock_next_available).
+        with("worker_name", "test", 1, 2).
+        and_return(:job)
       called = true
       cb.call(queue)
     end

data/spec/delayed/work_queue/parent_process_spec.rb

@@ -14,6 +14,9 @@ RSpec.describe Delayed::WorkQueue::ParentProcess do
   end
 
   let(:subject) { described_class.new }
+  let(:worker_config) { { queue: "queue_name", min_priority: 1, max_priority: 2 } }
+  let(:args) { ["worker_name", worker_config] }
+  let(:job_args) { ["worker_name", "queue_name", 1, 2] }
 
   it 'generates a server listening on a valid unix socket' do
     server = subject.server
@@ -34,7 +37,6 @@ RSpec.describe Delayed::WorkQueue::ParentProcess 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
@@ -77,7 +79,6 @@ RSpec.describe Delayed::WorkQueue::ParentProcess do
   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
@@ -89,7 +90,7 @@ RSpec.describe Delayed::WorkQueue::ParentProcess 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)
+      expect(Delayed::Job).to receive(:get_and_lock_next_available).with(*job_args).and_return(job)
       Marshal.dump(args, client)
       subject.run_once
       expect(Marshal.load(client)).to eq(job)
@@ -123,12 +124,12 @@ RSpec.describe Delayed::WorkQueue::ParentProcess do
       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)
+      expect(Delayed::Job).to receive(:get_and_lock_next_available).with(*job_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)
+      expect(Delayed::Job).to receive(:get_and_lock_next_available).with(*job_args).and_return(nil)
       Marshal.dump(args, client)
       subject.run_once
       expect(subject.all_workers_idle?).to be(true)
@@ -142,7 +143,7 @@ RSpec.describe Delayed::WorkQueue::ParentProcess do
       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)
+        expect(Delayed::Job).to receive(:get_and_lock_next_available).with(*job_args).and_return(job)
         called = true
         res = cb.call(queue)
         expect(subject.all_workers_idle?).to be(false)

data/spec/delayed/worker_spec.rb

@@ -2,15 +2,27 @@ require_relative "../spec_helper"
 
 module Delayed
   describe Worker do
+    let(:worker_config) { {
+        queue: "test", min_priority: 1, max_priority: 2, stuff: "stuff",
+    }.freeze }
+    subject { described_class.new(worker_config.dup) }
+
     describe "#perform" do
       it "fires off an error callback when a job raises an exception" do
         fired = false
         Worker.lifecycle.before(:error) {|worker, exception| fired = true}
-        worker = Worker.new
         job = double(:last_error= => nil, attempts: 1, reschedule: nil)
-        worker.perform(job)
+        subject.perform(job)
         expect(fired).to be_truthy
       end
     end
+
+    describe "#run" do
+      it "passes extra config options through to the WorkQueue" do
+        expect(subject.work_queue).to receive(:get_and_lock_next_available).
+          with(subject.name, worker_config).and_return(nil)
+        subject.run
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: inst-jobs
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.11.1
 platform: ruby
 authors:
 - Tobias Luetke
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-23 00:00:00.000000000 Z
+date: 2016-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: after_transaction_commit
@@ -253,11 +253,11 @@ description:
 email:
 - brianp@instructure.com
 executables:
-- inst_job
+- inst_jobs
 extensions: []
 extra_rdoc_files: []
 files:
-- bin/inst_job
+- bin/inst_jobs
 - db/migrate/20101216224513_create_delayed_jobs.rb
 - db/migrate/20110208031356_add_delayed_jobs_tag.rb
 - db/migrate/20110426161613_add_delayed_jobs_max_attempts.rb
@@ -341,7 +341,7 @@ files:
 - spec/shared/worker.rb
 - spec/shared_jobs_specs.rb
 - spec/spec_helper.rb
-homepage: http://www.instructure.com
+homepage: https://github.com/instructure/inst-jobs
 licenses: []
 metadata: {}
 post_install_message: 
@@ -360,7 +360,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.4.7
 signing_key: 
 specification_version: 4
 summary: Instructure-maintained fork of delayed_job
@@ -388,3 +388,4 @@ test_files:
 - spec/shared/worker.rb
 - spec/shared_jobs_specs.rb
 - spec/spec_helper.rb
+has_rdoc: