Ticket #11540: compilable_thread_safety.patch

actionpack/test/template/threading_test_explicit.rb

@@ +1 @@
+require 'abstract_unit'
+
+class ThreadedPartialTemplateTest < Test::Unit::TestCase
+  LOAD_PATH_ROOT = File.join(File.dirname(__FILE__), '..', 'fixtures')
+  ActionView::TemplateFinder.process_view_paths(LOAD_PATH_ROOT)
+
+  # You should let this run for "A Long Time" to be confident there aren't any race conditions
+  # and of course it will never give 100% confidence
+  def test_threading_with_partials_with_different_sets_of_local_assigns
+    orig, Thread.abort_on_exception = Thread.abort_on_exception, true
+  
+    template_content = (1..999).inject("") {|s, n| s << %{<%= local_#{n}  if defined? local_#{n} %>} }
+    File.open(File.join(LOAD_PATH_ROOT, "test/_threaded_partial.erb"), "w") {|f| f.write template_content }
+
+    # Uncomment to reproduce race condition
+#      ActionView::TemplateHandlers::Compilable.class_eval %{
+#        @@compile_guard = Object.new
+#        def @@compile_guard.synchronize; yield; end
+#      }
+
+    10000.times do
+      puts "working..."
+
+      ActionView::TemplateHandlers::ERB.template_args.clear
+      ActionView::TemplateHandlers::ERB.compile_time.clear
+      
+      threads = []
+      (1..999).each do |n|
+        threads << Thread.new do
+          view = ActionView::Base.new(LOAD_PATH_ROOT)
+          template = ActionView::PartialTemplate.new(view, 'test/threaded_partial', nil, {"local_#{n}".to_sym => n})
+          assert_equal "#{n}", template.render
+        end
+      end
+      threads.each {|t| t.join}
+    end
+  ensure
+    Thread.abort_on_exception = orig
+  end
+end

actionpack/lib/action_view/template_handlers/compilable.rb

@@ -1 +1 @@
-module ActionView
-  module TemplateHandlers
-    module Compilable
+      @@compile_guard = Mutex.new
-
-      def self.included(base)
-        base.extend ClassMethod
@@ -30 +31 @@
-      end
-
-      # Compile and evaluate the template's code
+      #
+      # RACE CONDITION: If 2+ threads create_template_source for the same method, and the first 
+      # thread (whose method has fewer local assigns than the second) module_evals last, it will
+      # clobber the method with the correct set of assigns.  The compile_guard mutex prevents this.
-      def compile_template(template)
-        return unless compile_template?(template)
-
-
-
-
+
+
+
+
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-          end
-
-
+
+
-        end
-
-        self.compile_time[render_symbol] = Time.now
-        # logger.debug "Compiled template #{file_name || template}\n  ==> #{render_symbol}" if logger
-      end
-
-      private
@@ -99 +106 @@
-
-        self.template_args[render_symbol] ||= {}
-        locals_keys = self.template_args[render_symbol].keys | template.locals.keys
+        # RACE CONDITION: If 2+ threads execute the line above before executing the line below, 
+        # one of their local_keys may be missing keys.  The compile_guard mutex prevents this.
-        self.template_args[render_symbol] = locals_keys.inject({}) { |h, k| h[k] = true; h }
-
-        locals_code = ""
@@ -125 +134 @@
-
-    end
-  end
-
+