inst-jobs 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2dad83034c6ca9ae9a7f7129581ecd36f64d1d51f93aa1126582ff2141068020
-  data.tar.gz: 8b155f2ed6ce13b956d8383bc484ef19ed3b661502bf2aed734a4618befebf40
+  metadata.gz: 6d65c567b52e2baf26955d266c9fededc001deab65d871e6e60a42a905d552e8
+  data.tar.gz: b4d487088aba583188c90650a42a20726f84230e346c321b4b94ddc5c25fe36e
 SHA512:
-  metadata.gz: 783af3d9f654e07a55a6be57691216a255bb548a720ae31d7c085ba0c70be20164a2a2c6a7b36767976468e034b5bafc6de427f577a05c2c70d0a6621301e86d
-  data.tar.gz: cbc4ff85dea6bc2f12d8eb2cecb25cecae4dc47e5e5155e46c63ebdbc4884e15f43f41b69b8611c44cbb42f4539843ecffe8cf5e96cab852bf9ace06a7a6b6fa
+  metadata.gz: 9ade674610c5a1a4a04e4a6078b45c38358e7c7af79a417d5e6941d968e1565bc5e217405ad1ca427b373ee0d89bdbc28772f8ed52047394e8760fc09a79b60a
+  data.tar.gz: 216706e128397e84ba87d495e4b09d30eb58f35ab4821e8ef6f484d5f6226a959cab04a8bfdfa22916f19dad53e7ee01bbe1128bd61fb402aad29885ac81839f

data/lib/delayed/message_sending.rb

@@ -7,32 +7,45 @@ end
 module Delayed
   module MessageSending
     class DelayProxy < BasicObject
-      def initialize(object, synchronous: false, public_send: false, **enqueue_args)
+      def initialize(object, synchronous: false, sender: nil, **enqueue_args)
         @object = object
         @enqueue_args = enqueue_args
         @synchronous = synchronous
-        @public_send = public_send
+        @sender = sender
       end
 
       def method_missing(method, *args, **kwargs)
+        # method doesn't exist? must be method_missing; assume private access
+        @sender = nil if !@sender.nil? &&
+         !@object.methods.include?(method) &&
+         !@object.protected_methods.include?(method) &&
+         !@object.private_methods.include?(method)
+
+        sender_is_object = @sender == @object
+        sender_is_class = @sender.is_a?(@object.class)
+
+        # even if the call is async, if the call is _going_ to generate an error, we make it synchronous
+        # so that the error is generated immediately, instead of waiting for it to fail in a job,
+        # which might go unnoticed
+        if !@sender.nil? && !@synchronous
+          @synchronous = true if !sender_is_object && @object.private_methods.include?(method)
+          @synchronous = true if !sender_is_class && @object.protected_methods.include?(method)
+        end
+
         if @synchronous
-          if @public_send
-            if kwargs.empty?
-              return @object.public_send(method, *args)
-            else
-              return @object.public_send(method, *args, **kwargs)
-            end
-          else
+          if @sender.nil? || sender_is_object || sender_is_class && @object.protected_methods.include?(method)
             if kwargs.empty?
               return @object.send(method, *args)
             else
               return @object.send(method, *args, **kwargs)
             end
           end
-        end
-
-        if @public_send && @object.private_methods.include?(method)
-          ::Kernel.raise ::NoMethodError.new("undefined method `#{method}' for #{@object}", method)
+          
+          if kwargs.empty?
+            return @object.public_send(method, *args)
+          else
+            return @object.public_send(method, *args, **kwargs)
+          end
         end
 
         ignore_transaction = @enqueue_args.delete(:ignore_transaction)
@@ -50,7 +63,8 @@ module Delayed
               ::Delayed::Job.enqueue(::Delayed::PerformableMethod.new(@object, method,
                                                                   args: args, kwargs: kwargs,
                                                                   on_failure: on_failure,
-                                                                  on_permanent_failure: on_permanent_failure),
+                                                                  on_permanent_failure: on_permanent_failure,
+                                                                  sender: @sender),
                                                                   **@enqueue_args)
             end
             return nil
@@ -61,14 +75,15 @@ module Delayed
                                                                     args: args,
                                                                     kwargs: kwargs,
                                                                     on_failure: on_failure,
-                                                                    on_permanent_failure: on_permanent_failure),
+                                                                    on_permanent_failure: on_permanent_failure,
+                                                                    sender: @sender),
                                                                     **@enqueue_args)
         result = nil unless ignore_transaction
         result
       end
     end
 
-    def delay(public_send: nil, **enqueue_args)
+    def delay(sender: nil, **enqueue_args)
       # support procs/methods as enqueue arguments
       enqueue_args.each do |k,v|
         if v.respond_to?(:call)
@@ -76,21 +91,15 @@ module Delayed
         end
       end
 
-      public_send ||= __calculate_public_send_for_delay
+      sender ||= __calculate_sender_for_delay
 
-      DelayProxy.new(self, public_send: public_send, **enqueue_args)
+      DelayProxy.new(self, sender: sender, **enqueue_args)
     end
 
-    def __calculate_public_send_for_delay
+    def __calculate_sender_for_delay
       # enforce public send in dev and test, but not prod (since it uses
       # debug APIs, it's expensive)
-      public_send = if ::Rails.env.test? || ::Rails.env.development?
-        sender = self.sender(1)
-        # if the caller isn't self, use public_send; i.e. enforce method visibility
-        sender != self
-      else
-        false
-      end
+      return sender(1) if ::Rails.env.test? || ::Rails.env.development?
     end
 
     module ClassMethods
@@ -114,7 +123,7 @@ module Delayed
               if synchronous
                 super(*args, **kwargs)
               else
-                delay(**enqueue_args).method_missing(method_name, *args, synchronous: true, **kwargs)
+                delay(sender: __calculate_sender_for_delay, **enqueue_args).method_missing(method_name, *args, synchronous: true, **kwargs)
               end
             end)
           end

data/lib/delayed/performable_method.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module Delayed
-  class PerformableMethod < Struct.new(:object, :method, :args, :kwargs, :fail_cb, :permanent_fail_cb, :public_send)
-    def initialize(object, method, args: [], kwargs: {}, on_failure: nil, on_permanent_failure: nil, public_send: true)
+  class PerformableMethod < Struct.new(:object, :method, :args, :kwargs, :fail_cb, :permanent_fail_cb, :sender)
+    def initialize(object, method, args: [], kwargs: {}, on_failure: nil, on_permanent_failure: nil, sender: nil)
       raise NoMethodError, "undefined method `#{method}' for #{object.inspect}" unless object.respond_to?(method, true)
 
       self.object = object
@@ -11,7 +11,13 @@ module Delayed
       self.method = method.to_sym
       self.fail_cb           = on_failure
       self.permanent_fail_cb = on_permanent_failure
-      self.public_send = public_send
+      self.sender = sender
+      begin
+        YAML.dump(sender)
+      rescue
+        # if for some reason you can't dump the sender, just drop it
+        self.sender = nil
+      end
     end
 
     def display_name
@@ -25,17 +31,21 @@ module Delayed
 
     def perform
       kwargs = self.kwargs || {}
-      if public_send
+
+      sender_is_object = sender == object
+      sender_is_class = sender.is_a?(object.class)
+
+      if sender.nil? || sender_is_object || sender_is_class && object.protected_methods.include?(method)
         if kwargs.empty?
-          object.public_send(method, *args)
+          object.send(method, *args)
         else
-          object.public_send(method, *args, **kwargs)
+          object.send(method, *args, **kwargs)
         end
       else
         if kwargs.empty?
-          object.send(method, *args)
+          object.public_send(method, *args)
         else
-          object.send(method, *args, **kwargs)
+          object.public_send(method, *args, **kwargs)
         end
       end
     end

data/lib/delayed/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Delayed
-  VERSION = "1.0.1"
+  VERSION = "1.0.2"
 end

data/spec/delayed/message_sending_spec.rb

@@ -8,21 +8,38 @@ RSpec.describe Delayed::MessageSending do
     allow(::Rails.env).to receive(:test?).and_return(true)
   end
 
-  let(:klass) do
-    Class.new do
+  before (:all) do
+    class SpecClass
       def call_private(**enqueue_args)
         delay(**enqueue_args).private_method
       end
 
+      def call_protected(**enqueue_args)
+        other = self.class.new
+        other.delay(**enqueue_args).protected_method
+      end
+
       private
 
       def private_method
       end
+
+      protected
+
+      def protected_method
+      end
     end
   end
 
+  after(:all) do
+    Object.send(:remove_const, :SpecClass)
+  end
+
+  let(:klass) { SpecClass }
+
   it "allows an object to send a private message to itself" do
-    klass.new.call_private
+    job = klass.new.call_private(ignore_transaction: true)
+    job.invoke_job
   end
 
   it "allows an object to send a private message to itself synchronouosly" do
@@ -48,4 +65,37 @@ RSpec.describe Delayed::MessageSending do
     allow(::Rails.env).to receive(:development?).and_return(false)
     klass.new.delay(synchronous: true).private_method
   end
+
+  it "allows an object to send a protected message to itself" do
+    job = klass.new.call_protected(ignore_transaction: true)
+    job.invoke_job
+  end
+
+  it "allows an object to send a protected message to itself synchronouosly" do
+    klass.new.call_protected(synchronous: true)
+  end
+
+  it "warns about directly sending a protected message asynchronously" do
+    expect { klass.new.delay.protected_method }.to raise_error(NoMethodError)
+  end
+
+  it "warns about directly sending a protected message synchronusly" do
+    expect { klass.new.delay(synchronous: true).protected_method }.to raise_error(NoMethodError)
+  end
+
+  it "doesn't explode if you can't dump the sender" do
+    klass = Class.new do
+      def delay_something
+        Kernel.delay.sleep(1)
+      end
+
+      def encode_with(encoder)
+        raise "yaml encoding failed"
+      end
+    end
+
+    obj = klass.new
+    expect { YAML.dump(obj) }.to raise_error("yaml encoding failed")
+    expect { obj.delay_something }.not_to raise_error
+  end
 end

data/spec/shared/delayed_method.rb

@@ -82,11 +82,11 @@ shared_examples_for 'random ruby objects' do
         obj = klass.new
         method = double()
 
-        expect(Delayed::PerformableMethod).to receive(:new).with(obj, :test_method, args: [1,2,3], kwargs: {synchronous: true}, on_failure: nil, on_permanent_failure: nil).and_return(method)
+        expect(Delayed::PerformableMethod).to receive(:new).with(obj, :test_method, args: [1,2,3], kwargs: {synchronous: true}, on_failure: nil, on_permanent_failure: nil, sender: obj).and_return(method)
         expect(Delayed::Job).to receive(:enqueue).with(method, :enqueue_arg_1 => :thing)
         obj.test_method(1,2,3)
 
-        expect(Delayed::PerformableMethod).to receive(:new).with(obj, :test_method, args: [4], kwargs: {:synchronous=>true}, on_failure: nil, on_permanent_failure: nil).and_return(method)
+        expect(Delayed::PerformableMethod).to receive(:new).with(obj, :test_method, args: [4], kwargs: {:synchronous=>true}, on_failure: nil, on_permanent_failure: nil, sender: obj).and_return(method)
         expect(Delayed::Job).to receive(:enqueue).with(method, :enqueue_arg_1 => :thing)
         obj.test_method(4)
 

data/spec/spec_helper.rb

@@ -35,6 +35,15 @@ RSpec.configure do |config|
   end
 end
 
+module NoYamlDump
+  def encode_with(coder)
+  end
+end
+# example groups are often the sender, and if we try to serialize them,
+# the resultant object is then encoded in the sender, and then we serialize
+# again, and it just keeps getting bigger and bigger and bigger...
+RSpec::Core::ExampleGroup.include(NoYamlDump)
+
 ENV['TEST_ENV_NUMBER'] ||= '1'
 ENV['TEST_DB_HOST'] ||= 'localhost'
 ENV['TEST_DB_DATABASE'] ||= "inst-jobs-test-#{ENV['TEST_ENV_NUMBER']}"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: inst-jobs
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Tobias Luetke
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-10-28 00:00:00.000000000 Z
+date: 2020-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord