why use wait_for_termination method will stuck the code #1004

Activity

1. bensheldon commented on Jul 14, 2023

   

   bensheldon

   on Jul 14, 2023

   Contributor

   More actions

   @banzhihang1 can you share the implementation of ClassFactory.create_dynamic_model? I'm imagining that its likely to be the problem here (i.e. not thread safe).

   It would be most helpful if you can share a self-contained reproduction script without private/external dependencies.
2. banzhihang1 commented on Jul 17, 2023

   

   banzhihang1

   on Jul 17, 2023

   Last edited by banzhihang1

   Author

   More actions

   @bensheldon this is code

   class ClassFactory
     def self.create_dynamic_model(database_name, table_name, deletable=false)
       new_class = self.name + database_name.camelize + table_name.singularize.camelize
       
       if deletable
         existing_classes = ActiveRecord::Base.descendants.reject(&:abstract_class).select{ |m| m.table_name == table_name && m.database_name == database_name }
   
         if existing_classes.length == 1
           include_delete_restore(existing_classes[0])
           return existing_classes[0]
         end
   
         if existing_classes.length > 1
           primary = find_primary_existing_class(existing_classes)
           if primary.present?
             include_delete_restore(primary)
             return primary
           end
         end
       end
   
       existing_class = begin
         k = Module.const_get(new_class)
         if k.database_name == database_name && k.table_name == table_name
           k
         end
       rescue NameError
         nil
       end
       
       if existing_class
         include_delete_restore(existing_class) if deletable
         return existing_class
       end
       
       Object.const_set(new_class, Class.new(database_name == 'one_eye' ? ActiveRecord::Base : "#{database_name.camelcase}DatabaseRecord".constantize))
       klass = new_class.constantize
       klass.table_name = table_name
       klass.inheritance_column = nil
   
       if klass.primary_key == nil
         # Rails can't handle composite PKs.
         # We have to retrieve from the schema cache and explicitly set
         key = klass.connection.schema_cache.primary_keys(table_name)
         klass.primary_key = key
       end
   
       include_delete_restore(klass) if deletable
       klass
     end
   
     private
   
     def self.include_delete_restore(klass)
       klass.include(DeleteRestore::Deletable)
       klass.include(DeleteRestore::Restorable)
     end
   
     def self.find_primary_existing_class(existing_classes)
       # First check to see if any have been marked as primary
       primary = existing_classes.select { |c| c.instance_variable_defined?(:@primary_model_for_table) && c.instance_variable_get(:@primary_model_for_table) }
       return primary[0] if primary.length == 1
   
       # Then check to see if only one implements Deletable
       deletable = existing_classes.select { |c| c < DeleteRestore::Deletable }
       return deletable[0] if deletable.length == 1
   
       # Check to see if only one override the delete_batch method
       overriding = existing_classes.select { |c| c.respond_to?(:delete_batch) && c.method(:delete_batch).owner != DeleteRestore::Deletable::ClassMethods } 
       return overriding[0] if overriding.length == 1
   
       # If we can't narrow it down, return nil
       return nil
     end
   end

   The code did not run in, but got stuck in an external call