inst-jobs 1.0.0 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c754ed71778d5b3f08641e133be947fae204a56dcee71aef08a7780a7d6afa5
-  data.tar.gz: 10949318e78e8e9d56b92ee7f2d14bfd647da20ff70578d894e4d1e85441d2fe
+  metadata.gz: b7018574b89f64cc8e0a8e601ba594b2ae346cd1fed66237a62b02a71cdaa14c
+  data.tar.gz: bb5865eb7e5933717394ef47e85904827d4e065a2994de2eb9d7c4a43790da80
 SHA512:
-  metadata.gz: 1a014e191bc0d6ccd083340b6d5c4bca0b7e03439aca459f79a5a704d93d16c42dd9e4855ca5985f7b1e4fb1fe62eead160cb6cb356c73b00ac297dc30112d8a
-  data.tar.gz: 53997c66017cf6db561104054379cb9e7e934fcc56c54d552b7629ff29eeb58de37c8674088661ba683e7e4d8b19234f26021819753ac06a6c738dd435c3f169
+  metadata.gz: 9eeed8f4e9f853ed216c1c1817ab499f27ca6fe4c66837ce07b6e54e4d81f5ada261f19180403f9c6cf211f32daec480559ae9566f5d76b5c975196fe7998688
+  data.tar.gz: fea866765cec29e00c5b94da17d5ce3f0b432ca6d79111325d5fee2829a33b3bc445896079fe93d0a70537a59abc0dddd45d8869a32ab1c1e0e6ab3c24848482

data/lib/delayed/core_ext/kernel.rb

@@ -0,0 +1,9 @@
+module Kernel
+  def sender(i = 0)
+    frame_self = nil
+    # 3. one for the block, one for this method, one for the method calling this
+    # method, and _then_ we get to the self for who sent the message we want
+    RubyVM::DebugInspector.open { |dc| frame_self = dc.frame_self(3 + i) }
+    frame_self
+  end
+end

data/lib/delayed/message_sending.rb

@@ -1,14 +1,53 @@
 # frozen_string_literal: true
 
+if ::Rails.env.test? || ::Rails.env.development?
+  require 'debug_inspector'
+end
+
 module Delayed
   module MessageSending
     class DelayProxy < BasicObject
-      def initialize(object, enqueue_args)
+      def initialize(object, synchronous: false, sender: nil, **enqueue_args)
         @object = object
         @enqueue_args = enqueue_args
+        @synchronous = synchronous
+        @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 @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
+          
+          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)
         on_failure = @enqueue_args.delete(:on_failure)
         on_permanent_failure = @enqueue_args.delete(:on_permanent_failure)
@@ -24,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
@@ -35,24 +75,31 @@ 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(**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)
           enqueue_args[k] = v.call(self)
         end
       end
-      if enqueue_args.delete(:synchronous)
-        return self
-      end
-      DelayProxy.new(self, enqueue_args)
+
+      sender ||= __calculate_sender_for_delay
+
+      DelayProxy.new(self, sender: sender, **enqueue_args)
+    end
+
+    def __calculate_sender_for_delay
+      # enforce public send in dev and test, but not prod (since it uses
+      # debug APIs, it's expensive)
+      return sender(1) if ::Rails.env.test? || ::Rails.env.development?
     end
 
     module ClassMethods
@@ -76,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)
-    def initialize(object, method, args: [], kwargs: {}, on_failure: nil, on_permanent_failure: nil)
+  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,6 +11,13 @@ module Delayed
       self.method = method.to_sym
       self.fail_cb           = on_failure
       self.permanent_fail_cb = on_permanent_failure
+      self.sender = sender
+      begin
+        YAML.load(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
@@ -24,10 +31,22 @@ module Delayed
 
     def perform
       kwargs = self.kwargs || {}
-      if kwargs.empty?
-        object.send(method, *args)
+
+      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.send(method, *args)
+        else
+          object.send(method, *args, **kwargs)
+        end
       else
-        object.send(method, *args, **kwargs)
+        if kwargs.empty?
+          object.public_send(method, *args)
+        else
+          object.public_send(method, *args, **kwargs)
+        end
       end
     end
 
@@ -54,7 +73,8 @@ module Delayed
 
     def full_name
       obj_name = object.is_a?(ActiveRecord::Base) ? "#{object.class}.find(#{object.id}).#{method}" : display_name
-      kwargs_str = kwargs.map { |(k, v)| ", #{k}: #{deep_de_ar_ize(v)}"}.join("")
+      kgs = kwargs || {}
+      kwargs_str = kgs.map { |(k, v)| ", #{k}: #{deep_de_ar_ize(v)}"}.join("")
       "#{obj_name}(#{args.map { |a| deep_de_ar_ize(a) }.join(', ')}#{kwargs_str})"
     end
   end

data/lib/delayed/version.rb

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

data/lib/delayed/worker/consul_health_check.rb

@@ -13,7 +13,7 @@ module Delayed
       DEFAULT_SERVICE_NAME = 'inst-jobs_worker'.freeze
       attr_reader :agent_client, :catalog_client
 
-      def initialize(*args)
+      def initialize(*, **)
         super
         # Because we don't want the consul client to be a hard dependency we're
         # only requiring it once it's absolutely needed

data/lib/delayed_job.rb

@@ -19,6 +19,8 @@ require 'active_support/core_ext/module/attribute_accessors'
 require 'active_record'
 require 'after_transaction_commit'
 
+require 'delayed/core_ext/kernel'
+
 require 'delayed/settings'
 require 'delayed/yaml_extensions'
 

data/spec/active_record_job_spec.rb

@@ -7,10 +7,6 @@ describe 'Delayed::Backed::ActiveRecord::Job' do
     Delayed.select_backend(Delayed::Backend::ActiveRecord::Job)
   end
 
-  after :all do
-    Delayed.send(:remove_const, :Job)
-  end
-
   before do
     Delayed::Testing.clear_all!
   end

data/spec/delayed/message_sending_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'debug_inspector'
+
+RSpec.describe Delayed::MessageSending do
+  before do
+    allow(::Rails.env).to receive(:test?).and_return(true)
+  end
+
+  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
+    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
+    klass.new.call_private(synchronous: true)
+  end
+
+  it "warns about directly sending a private message asynchronously" do
+    expect { klass.new.delay.private_method }.to raise_error(NoMethodError)
+  end
+
+  it "warns about directly sending a private message synchronusly" do
+    expect { klass.new.delay(synchronous: true).private_method }.to raise_error(NoMethodError)
+  end
+
+  it "does not warn about directly sending a private message in production" do
+    allow(::Rails.env).to receive(:test?).and_return(false)
+    allow(::Rails.env).to receive(:development?).and_return(false)
+    klass.new.delay.private_method
+  end
+
+  it "does not warn about directly sending a private message synchronously in production" do
+    allow(::Rails.env).to receive(:test?).and_return(false)
+    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/delayed/server_spec.rb

@@ -20,10 +20,6 @@ RSpec.describe Delayed::Server, sinatra: true do
     Delayed.select_backend(Delayed::Backend::ActiveRecord::Job)
   end
 
-  after :all do
-    Delayed.send(:remove_const, :Job)
-  end
-
   describe "get '/running'" do
     before do
       3.times do |i|

data/spec/delayed/work_queue/in_process_spec.rb

@@ -7,10 +7,6 @@ RSpec.describe Delayed::WorkQueue::InProcess 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

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

@@ -16,10 +16,6 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Client do
     Delayed.select_backend(Delayed::Backend::ActiveRecord::Job)
   end
 
-  after :all do
-    Delayed.send(:remove_const, :Job)
-  end
-
   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(:eof?).and_return(false)

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

@@ -31,7 +31,6 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Server do
   end
 
   after :all do
-    Delayed.send(:remove_const, :Job)
     Delayed::Settings.parent_process = {}
   end
 

data/spec/delayed/work_queue/parent_process_spec.rb

@@ -13,7 +13,6 @@ RSpec.describe Delayed::WorkQueue::ParentProcess do
   end
 
   after :all do
-    Delayed.send(:remove_const, :Job)
     Delayed::Settings.parent_process = {}
   end
 

data/spec/delayed/worker/consul_health_check_spec.rb

@@ -17,7 +17,7 @@ RSpec.describe Delayed::Worker::ConsulHealthCheck do
 
   describe '#initialize' do
     it 'must use the default agent client when the config is mostly empty' do
-      check = Delayed::Worker::ConsulHealthCheck.new({worker_name: 'foobar'})
+      check = Delayed::Worker::ConsulHealthCheck.new(worker_name: 'foobar')
       expect(check.agent_client).to eq Imperium::Agent.default_client
     end
 

data/spec/redis_job_spec.rb

@@ -7,10 +7,6 @@ describe 'Delayed::Backend::Redis::Job' do
     Delayed.select_backend(Delayed::Backend::Redis::Job)
   end
 
-  after :all do
-    Delayed.send(:remove_const, :Job)
-  end
-
   before do
     Delayed::Testing.clear_all!
   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/shared/performable_method.rb

@@ -65,4 +65,10 @@ shared_examples_for 'Delayed::PerformableMethod' do
     p.send(:on_permanent_failure, 'fail_frd')
     story.text.should == 'fail_frd'
   end
+
+  it "can still generate a name with no kwargs" do
+    story = Story.create :text => 'wat'
+    p = Delayed::PerformableMethod.new(story, :tell, kwargs: nil)
+    expect(p.full_name).to eq("Story.find(#{story.id}).tell()")
+  end
 end

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,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: inst-jobs
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.4
 platform: ruby
 authors:
 - Tobias Luetke
 - Brian Palmer
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-10-26 00:00:00.000000000 Z
+date: 2020-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -115,6 +115,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: debug_inspector
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.3
 - !ruby/object:Gem::Dependency
   name: bump
   requirement: !ruby/object:Gem::Requirement
@@ -311,7 +325,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.4.0
-description:
+description: 
 email:
 - brianp@instructure.com
 executables:
@@ -361,6 +375,7 @@ files:
 - lib/delayed/backend/redis/tickle_strand.lua
 - lib/delayed/batch.rb
 - lib/delayed/cli.rb
+- lib/delayed/core_ext/kernel.rb
 - lib/delayed/daemon.rb
 - lib/delayed/engine.rb
 - lib/delayed/job_tracking.rb
@@ -396,6 +411,7 @@ files:
 - spec/active_record_job_spec.rb
 - spec/delayed/cli_spec.rb
 - spec/delayed/daemon_spec.rb
+- spec/delayed/message_sending_spec.rb
 - spec/delayed/server_spec.rb
 - spec/delayed/settings_spec.rb
 - spec/delayed/work_queue/in_process_spec.rb
@@ -406,15 +422,10 @@ files:
 - spec/delayed/worker/health_check_spec.rb
 - spec/delayed/worker_spec.rb
 - spec/gemfiles/42.gemfile
-- spec/gemfiles/42.gemfile.lock
 - spec/gemfiles/50.gemfile
-- spec/gemfiles/50.gemfile.lock
 - spec/gemfiles/51.gemfile
-- spec/gemfiles/51.gemfile.lock
 - spec/gemfiles/52.gemfile
-- spec/gemfiles/52.gemfile.lock
 - spec/gemfiles/60.gemfile
-- spec/gemfiles/60.gemfile.lock
 - spec/migrate/20140924140513_add_story_table.rb
 - spec/redis_job_spec.rb
 - spec/sample_jobs.rb
@@ -429,7 +440,7 @@ files:
 homepage: https://github.com/instructure/inst-jobs
 licenses: []
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -444,23 +455,18 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key:
+rubygems_version: 3.0.3
+signing_key: 
 specification_version: 4
 summary: Instructure-maintained fork of delayed_job
 test_files:
 - spec/sample_jobs.rb
 - spec/spec_helper.rb
 - spec/redis_job_spec.rb
-- spec/gemfiles/51.gemfile.lock
-- spec/gemfiles/60.gemfile.lock
-- spec/gemfiles/42.gemfile.lock
-- spec/gemfiles/50.gemfile.lock
 - spec/gemfiles/60.gemfile
 - spec/gemfiles/42.gemfile
 - spec/gemfiles/52.gemfile
 - spec/gemfiles/50.gemfile
-- spec/gemfiles/52.gemfile.lock
 - spec/gemfiles/51.gemfile
 - spec/shared_jobs_specs.rb
 - spec/shared/performable_method.rb
@@ -474,6 +480,7 @@ test_files:
 - spec/delayed/cli_spec.rb
 - spec/delayed/daemon_spec.rb
 - spec/delayed/worker_spec.rb
+- spec/delayed/message_sending_spec.rb
 - spec/delayed/settings_spec.rb
 - spec/delayed/work_queue/in_process_spec.rb
 - spec/delayed/work_queue/parent_process_spec.rb