Publish AS::Executor and AS::Reloader APIs

These should allow external code to run blocks of user code to do
"work", at a similar unit size to a web request, without needing to get
intimate with ActionDipatch.

4 files changed, 69 insertions, 35 deletions

diff --git a/railties/lib/rails/application.rb b/railties/lib/rails/application.rb
index bff33ff42e..d05d610ee1 100644
--- a/railties/lib/rails/application.rb
+++ b/railties/lib/rails/application.rb
@@ -113,7 +113,7 @@ module Rails
 
     attr_accessor :assets, :sandbox
     alias_method :sandbox?, :sandbox
-    attr_reader :reloaders
+    attr_reader :reloaders, :reloader, :executor
 
     delegate :default_url_options, :default_url_options=, to: :routes
 
@@ -131,6 +131,10 @@ module Rails
       @message_verifiers = {}
       @ran_load_hooks    = false
 
+      @executor          = Class.new(ActiveSupport::Executor)
+      @reloader          = Class.new(ActiveSupport::Reloader)
+      @reloader.executor = @executor
+
       # are these actually used?
       @initial_variable_values = initial_variable_values
       @block = block
diff --git a/railties/lib/rails/application/default_middleware_stack.rb b/railties/lib/rails/application/default_middleware_stack.rb
index 4f1cc0703d..381e548730 100644
--- a/railties/lib/rails/application/default_middleware_stack.rb
+++ b/railties/lib/rails/application/default_middleware_stack.rb
@@ -34,22 +34,10 @@ module Rails
             # handling: presumably their code is not threadsafe
 
             middleware.use ::Rack::Lock
-
-          elsif config.allow_concurrency == :unsafe
-            # Do nothing, even if we know this is dangerous. This is the
-            # historical behaviour for true.
-
-          else
-            # Default concurrency setting: enabled, but safe
-
-            unless config.cache_classes && config.eager_load
-              # Without cache_classes + eager_load, the load interlock
-              # is required for proper operation
-
-              middleware.use ::ActionDispatch::LoadInterlock
-            end
           end
 
+          middleware.use ::ActionDispatch::Executor, app.executor
+
           middleware.use ::Rack::Runtime
           middleware.use ::Rack::MethodOverride unless config.api_only
           middleware.use ::ActionDispatch::RequestId
@@ -61,7 +49,7 @@ module Rails
           middleware.use ::ActionDispatch::RemoteIp, config.action_dispatch.ip_spoofing_check, config.action_dispatch.trusted_proxies
 
           unless config.cache_classes
-            middleware.use ::ActionDispatch::Reloader, lambda { reload_dependencies? }
+            middleware.use ::ActionDispatch::Reloader, app.reloader
           end
 
           middleware.use ::ActionDispatch::Callbacks
@@ -83,10 +71,6 @@ module Rails
 
       private
 
-        def reload_dependencies?
-          config.reload_classes_only_on_change != true || app.reloaders.map(&:updated?).any?
-        end
-
         def load_rack_cache
           rack_cache = config.action_dispatch.rack_cache
           return unless rack_cache
diff --git a/railties/lib/rails/application/finisher.rb b/railties/lib/rails/application/finisher.rb
index 64ec539564..34f2265108 100644
--- a/railties/lib/rails/application/finisher.rb
+++ b/railties/lib/rails/application/finisher.rb
@@ -38,16 +38,16 @@ module Rails
         app.routes.define_mounted_helper(:main_app)
       end
 
-      initializer :add_to_prepare_blocks do
+      initializer :add_to_prepare_blocks do |app|
         config.to_prepare_blocks.each do |block|
-          ActionDispatch::Reloader.to_prepare(&block)
+          app.reloader.to_prepare(&block)
         end
       end
 
       # This needs to happen before eager load so it happens
       # in exactly the same point regardless of config.cache_classes
-      initializer :run_prepare_callbacks do
-        ActionDispatch::Reloader.prepare!
+      initializer :run_prepare_callbacks do |app|
+        app.reloader.prepare!
       end
 
       initializer :eager_load! do
@@ -62,13 +62,47 @@ module Rails
         ActiveSupport.run_load_hooks(:after_initialize, self)
       end
 
+      initializer :configure_executor_for_concurrency do |app|
+        if config.allow_concurrency == false
+          # User has explicitly opted out of concurrent request
+          # handling: presumably their code is not threadsafe
+
+          mutex = Mutex.new
+          app.executor.to_run(prepend: true) do
+            mutex.lock
+          end
+          app.executor.to_complete(:after) do
+            mutex.unlock
+          end
+
+        elsif config.allow_concurrency == :unsafe
+          # Do nothing, even if we know this is dangerous. This is the
+          # historical behaviour for true.
+
+        else
+          # Default concurrency setting: enabled, but safe
+
+          unless config.cache_classes && config.eager_load
+            # Without cache_classes + eager_load, the load interlock
+            # is required for proper operation
+
+            app.executor.to_run(prepend: true) do
+              ActiveSupport::Dependencies.interlock.start_running
+            end
+            app.executor.to_complete(:after) do
+              ActiveSupport::Dependencies.interlock.done_running
+            end
+          end
+        end
+      end
+
       # Set routes reload after the finisher hook to ensure routes added in
       # the hook are taken into account.
-      initializer :set_routes_reloader_hook do
+      initializer :set_routes_reloader_hook do |app|
         reloader = routes_reloader
         reloader.execute_if_updated
         self.reloaders << reloader
-        ActionDispatch::Reloader.to_prepare do
+        app.reloader.to_run do
           # We configure #execute rather than #execute_if_updated because if
           # autoloaded constants are cleared we need to reload routes also in
           # case any was used there, as in
@@ -78,18 +112,27 @@ module Rails
           # This means routes are also reloaded if i18n is updated, which
           # might not be necessary, but in order to be more precise we need
           # some sort of reloaders dependency support, to be added.
+          require_unload_lock!
           reloader.execute
         end
       end
 
       # Set clearing dependencies after the finisher hook to ensure paths
       # added in the hook are taken into account.
-      initializer :set_clear_dependencies_hook, group: :all do
+      initializer :set_clear_dependencies_hook, group: :all do |app|
         callback = lambda do
-          ActiveSupport::Dependencies.interlock.unloading do
-            ActiveSupport::DescendantsTracker.clear
-            ActiveSupport::Dependencies.clear
+          ActiveSupport::DescendantsTracker.clear
+          ActiveSupport::Dependencies.clear
+        end
+
+        if config.cache_classes
+          app.reloader.check = lambda { false }
+        elsif config.reload_classes_only_on_change
+          app.reloader.check = lambda do
+            app.reloaders.map(&:updated?).any?
           end
+        else
+          app.reloader.check = lambda { true }
         end
 
         if config.reload_classes_only_on_change
@@ -99,15 +142,19 @@ module Rails
           # Prepend this callback to have autoloaded constants cleared before
           # any other possible reloading, in case they need to autoload fresh
           # constants.
-          ActionDispatch::Reloader.to_prepare(prepend: true) do
+          app.reloader.to_run(prepend: true) do
             # In addition to changes detected by the file watcher, if routes
             # or i18n have been updated we also need to clear constants,
             # that's why we run #execute rather than #execute_if_updated, this
             # callback has to clear autoloaded constants after any update.
-            reloader.execute
+            class_unload! do
+              reloader.execute
+            end
           end
         else
-          ActionDispatch::Reloader.to_cleanup(&callback)
+          app.reloader.to_complete do
+            class_unload!(&callback)
+          end
         end
       end
 
diff --git a/railties/lib/rails/console/app.rb b/railties/lib/rails/console/app.rb
index ac5836a588..9ad77e0a80 100644
--- a/railties/lib/rails/console/app.rb
+++ b/railties/lib/rails/console/app.rb
@@ -29,8 +29,7 @@ module Rails
     # reloads the environment
     def reload!(print=true)
       puts "Reloading..." if print
-      ActionDispatch::Reloader.cleanup!
-      ActionDispatch::Reloader.prepare!
+      Rails.application.reloader.reload!
       true
     end
   end