inst-jobs 0.13.1 → 0.13.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 88d026d10899b3fcef92fba22bed66e9ba05bce9
-  data.tar.gz: 2dca6bebaa087750b6795277d0a16f998703ad03
+  metadata.gz: 9b0d5ed365c051a94b8b26f7fc43b66ddf472221
+  data.tar.gz: 53d13170b1a9f85ea4e9064932e674b6059063ba
 SHA512:
-  metadata.gz: 7284fd2de413d4743a095bc006c3250ddc8cab09e40d9c1c907d0417a6c51da77b6bbce6fe4c021684974100cca044356eb84c9ae1ab60b27be1f692cfeb7889
-  data.tar.gz: ea2690ae29842daefc978f32964508f18ce7664e9ac0b95bc4d12c864b4a93d06d57906405b659ed83c76c5858f9ae38c270711d9c23ea07a03439a829996693
+  metadata.gz: d911c43ce7aadb8d1373c96d82829ea2ecfc4ffecb1b8ea1243b713cbcb30aa57b6721fa77eea5446b72bb741db128dbf4ba7da9c4dcf57b6e34fa87261483d7
+  data.tar.gz: 02ba0072c4d9c1335fcf8d70e91368a47e34b9ae2d2748a2749def1f0f0e4d4ce76114ad0baf7da5bdf23e09abab0079466f1430076dec959adb096fd72698c8

data/lib/delayed/settings.rb

@@ -33,12 +33,10 @@ module Delayed
     mattr_accessor(*SETTINGS_WITH_ARGS)
 
     PARENT_PROCESS_DEFAULTS = {
-      server_receive_timeout: 10.0,
       server_socket_timeout: 10.0,
       pending_jobs_idle_timeout: 30.0,
 
       client_connect_timeout: 2.0,
-      client_receive_timeout: 10.0,
 
       # We'll accept a partial, relative path and assume we want it inside
       # Rails.root with inst-jobs.sock appended if provided a directory.

data/lib/delayed/version.rb

@@ -1,3 +1,3 @@
 module Delayed
-  VERSION = "0.13.1"
+  VERSION = "0.13.2"
 end

data/lib/delayed/work_queue/parent_process/client.rb

@@ -9,7 +9,6 @@ class ParentProcess
     def initialize(addrinfo, config: Settings.parent_process)
       @addrinfo = addrinfo
       @connect_timeout = config['client_connect_timeout'] || 2
-      @receive_timeout = config['client_receive_timeout'] || 10
     end
 
     def get_and_lock_next_available(worker_name, worker_config)
@@ -19,15 +18,11 @@ class ParentProcess
       # to wait for anything to be available on the 'wire', this is a valid
       # assumption because we control the server and it's a Unix domain socket,
       # not TCP.
-      if socket.wait_readable(@receive_timeout)
-        return reset_connection if socket.eof? # Other end closed gracefully, so should we
-        Marshal.load(socket).tap do |response|
-          unless response.nil? || (response.is_a?(Delayed::Job) && response.locked_by == worker_name)
-            raise(ProtocolError, "response is not a locked job: #{response.inspect}")
-          end
+      return reset_connection if socket.eof? # Other end closed gracefully, so should we
+      Marshal.load(socket).tap do |response|
+        unless response.nil? || (response.is_a?(Delayed::Job) && response.locked_by == worker_name)
+          raise(ProtocolError, "response is not a locked job: #{response.inspect}")
         end
-      else
-        reset_connection
       end
     rescue SystemCallError, IOError => ex
       logger.error("Work queue connection lost, reestablishing on next poll. (#{ex})")

data/lib/delayed/work_queue/parent_process/server.rb

@@ -15,7 +15,6 @@ class ParentProcess
 
       @config = config
       @client_timeout = config['server_socket_timeout'] || 10.0 # left for backwards compat
-      @receive_timeout = config['server_receive_timeout'] || 10.0
     end
 
     def connected_clients
@@ -82,19 +81,13 @@ class ParentProcess
       # 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
       # in Marshal.load forever. This is only a reasonable assumption because we
-      # control the client. Also, in theory, we shouldn't need to call
-      # #wait_readable to ensure there is data available since we just used
-      # select(2) to get this handle but it's better to be safe than sorry.
-      if socket.wait_readable(@receive_timeout)
-        worker_name, worker_config = Marshal.load(socket)
-        client = @clients[socket]
-        client.name = worker_name
-        client.working = false
-        (@waiting_clients[worker_config] ||= []) << client
-      else
-        drop_socket(socket)
-      end
-
+      # control the client.
+      return drop_socket(socket) if socket.eof?
+      worker_name, worker_config = Marshal.load(socket)
+      client = @clients[socket]
+      client.name = worker_name
+      client.working = false
+      (@waiting_clients[worker_config] ||= []) << client
     rescue SystemCallError, IOError => ex
       logger.error("Receiving message from client (#{socket}) failed: #{ex.inspect}")
       drop_socket(socket)
@@ -114,8 +107,10 @@ class ParentProcess
           end
           begin
             client_timeout { Marshal.dump(job, client.socket) }
-          rescue SystemCallError, IOError, Timeout::Error
+          rescue SystemCallError, IOError, Timeout::Error => ex
+            logger.error("Failed to send pre-fetched job to #{client.name}: #{ex.inspect}")
             drop_socket(client.socket)
+            Delayed::Job.unlock([job])
           end
         end
 
@@ -142,8 +137,10 @@ class ParentProcess
             @waiting_clients[worker_config].delete(client)
             begin
               client_timeout { Marshal.dump(job, client.socket) }
-            rescue SystemCallError, IOError, Timeout::Error
+            rescue SystemCallError, IOError, Timeout::Error => ex
+              logger.error("Failed to send job to #{client.name}: #{ex.inspect}")
               drop_socket(client.socket)
+              Delayed::Job.unlock([job])
             end
           end
         end

data/spec/delayed/work_queue/parent_process/client_spec.rb

@@ -20,7 +20,6 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Client do
 
   it 'marshals the given arguments to the server and returns the response' do
     expect(addrinfo).to receive(:connect).once.and_return(connection)
-    expect(connection).to receive(:wait_readable).with(10.0).and_return(connection)
     expect(connection).to receive(:eof?).and_return(false)
     expect(Marshal).to receive(:dump).with(args, connection).ordered
     expect(Marshal).to receive(:load).with(connection).and_return(job).ordered
@@ -28,23 +27,6 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Client do
     expect(response).to eq(job)
   end
 
-  it 'returns nil and then reconnects on receive timeout' do
-    expect(addrinfo).to receive(:connect).once.and_return(connection)
-    expect(connection).to receive(:wait_readable).with(10.0).and_return(nil)
-    expect(Marshal).to receive(:dump).with(args, connection).ordered
-    expect(connection).to receive(:close)
-    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(connection).to receive(:wait_readable).with(10.0).and_return(connection)
-    expect(connection).to receive(:eof?).and_return(false)
-    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 'returns nil and then reconnects on socket write error' do
     expect(addrinfo).to receive(:connect).once.and_return(connection)
     expect(Marshal).to receive(:dump).and_raise(SystemCallError.new("failure"))
@@ -54,7 +36,6 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Client do
 
     expect(addrinfo).to receive(:connect).once.and_return(connection)
     expect(Marshal).to receive(:dump).with(args, connection)
-    expect(connection).to receive(:wait_readable).with(10.0).and_return(connection)
     expect(connection).to receive(:eof?).and_return(false)
     expect(Marshal).to receive(:load).with(connection).and_return(job)
     response = subject.get_and_lock_next_available(*args)
@@ -63,7 +44,6 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Client do
 
   it 'returns nil and then reconnects when the socket indicates eof' do
     expect(addrinfo).to receive(:connect).once.and_return(connection)
-    expect(connection).to receive(:wait_readable).with(10.0).and_return(true)
     expect(connection).to receive(:eof?).and_return(true)
     expect(Marshal).to receive(:dump).with(args, connection).ordered
     expect(connection).to receive(:close)
@@ -72,7 +52,6 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Client do
 
     expect(addrinfo).to receive(:connect).once.and_return(connection)
     expect(Marshal).to receive(:dump).with(args, connection)
-    expect(connection).to receive(:wait_readable).with(10.0).and_return(connection)
     expect(connection).to receive(:eof?).and_return(false)
     expect(Marshal).to receive(:load).with(connection).and_return(job)
     response = subject.get_and_lock_next_available(*args)
@@ -83,7 +62,6 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Client 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(connection).to receive(:wait_readable).with(10.0).and_return(connection)
     expect(connection).to receive(:eof?).and_return(false)
 
     expect { subject.get_and_lock_next_available(*args) }.to raise_error(Delayed::WorkQueue::ParentProcess::ProtocolError)
@@ -94,7 +72,6 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Client do
     expect(Marshal).to receive(:dump).with(args, connection)
     job.locked_by = "somebody_else"
     expect(Marshal).to receive(:load).with(connection).and_return(job)
-    expect(connection).to receive(:wait_readable).with(10.0).and_return(connection)
     expect(connection).to receive(:eof?).and_return(false)
 
     expect { subject.get_and_lock_next_available(*args) }.to raise_error(Delayed::WorkQueue::ParentProcess::ProtocolError)

data/spec/delayed/work_queue/parent_process/server_spec.rb

@@ -107,7 +107,7 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Server do
     expect { subject.run_once }.to change(subject, :connected_clients).by(-1)
   end
 
-  it 'drops the client on timeout' do
+  it 'drops the client when the client disconnects' do
     client = Socket.unix(subject.listen_socket.local_address.unix_path)
     subject.run_once
 
@@ -115,7 +115,7 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Server do
 
     server_client_socket = subject.clients.keys.first
 
-    expect(server_client_socket).to receive(:wait_readable).and_return(false)
+    expect(server_client_socket).to receive(:eof?).and_return(true)
     expect { subject.run_once }.to change(subject, :connected_clients).by(-1)
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: inst-jobs
 version: !ruby/object:Gem::Version
-  version: 0.13.1
+  version: 0.13.2
 platform: ruby
 authors:
 - Tobias Luetke
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-26 00:00:00.000000000 Z
+date: 2017-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: after_transaction_commit