methodmissing-scrooge 1.0.1 → 1.0.2

data/lib/scrooge/profile.rb

@@ -6,8 +6,7 @@ module Scrooge
     # A Profile for Scrooge that holds configuration, determines if we're tracking or
     # scoping and provides access to a Tracker, ORM, Storage and Framework instance. 
     
-    class Signature      
-    end
+    GUARD = Mutex.new
     
     class << self
       
@@ -44,8 +43,8 @@ module Scrooge
                
     attr_reader :options           
                
-    def initialize( options = {} )           
-      self.options = options            
+    def initialize( options = {} )       
+      self.options = options         
     end
     
     # options writer that attempts to reconfigure for any configuration changes.
@@ -67,6 +66,18 @@ module Scrooge
       @storage_instance ||= Scrooge::Storage::Base.instantiate( @storage )
     end
     
+    # Delegates to the Application Tracker.
+    #
+    def tracker
+      @tracker_instance ||= Scrooge::Tracker::App.new
+    end
+
+    # Yields a strategt instance.
+    #           
+    def strategy
+      @strategy_instance ||= "scrooge/strategy/#{@strategy.to_s}".to_const!  
+    end
+    
     # Delegates to the current framework.
     #
     def framework
@@ -75,76 +86,50 @@ module Scrooge
     
     # Log a message to the framework's logger.
     #
-    def log( message )
-      framework.log( message ) rescue ''
+    def log( message, flush = false )
+      framework.log( message, flush ) rescue ''
     end
-    
-    # Delegates to the Application Tracker.
+        
+    # Are we tracking ?
     #
-    def tracker
-      @tracker_instance ||= Scrooge::Tracker::App.new
+    def track?
+      GUARD.synchronize do
+        @track == true
+      end
     end
-      
-    # Determine if this is a tracking or scope profile.
-    #  
-    def track_or_scope!
-      if enabled?
-        track? ? track! : scope!
+
+    # Enable the tracking phase
+    #
+    def start_tracking!
+      GUARD.synchronize do
+        @track = true
       end
     end
     
-    # Are we tracking ?
+    # Disable the tracking phase
     #
-    def track?
-      if enabled?
-        @track ||= (@scope || '').match( /\d{10}/ ).nil?
-      else
-        false
-      end  
+    def stop_tracking!
+      GUARD.synchronize do
+        @track = false
+      end
     end
     
-    def track!
-      if track?
-        log "Tracking"
-        framework.install_tracking_middleware()
-        shutdown_hook!
-      end   
-    end      
-    
     # The active scope signature
     #
-    def scope_to
+    def scope
       @scope
-    end
-        
-    # Are we scoping ?
-    #
-    def scope?
-      if enabled?
-        !track?
-      else
-        false
-      end    
-    end        
-        
-    # Scope the tracker environment to a given scope signature.
-    #
-    def scope_to_signature!( scope_signature )
-      log "Scope to #{scope_signature}"
-      @tracker_instance = framework.from_scope!( scope_signature )
-    end
+    end     
     
-    # Scope the tracker environment to a given scope signature and install
-    # scoping middleware.
-    #
-    def scope_to!
-      if scope?
-        scope_to_signature!( @scope )
-        framework.install_scope_middleware( tracker )        
+    # Assign the current scope from a given signature or tracker
+    #    
+    def scope=( signature_or_tracker )
+      if signature_or_tracker.kind_of?( Scrooge::Tracker::Base )
+        scope_to_tracker!( signature_or_tracker )
+      else
+        scope_to_signature!( signature_or_tracker  )
       end
-    end
-    alias :scope! :scope_to!
-    
+    end    
+            
     # Should Scrooge inject itself ?
     #         
     def enabled?
@@ -155,20 +140,32 @@ module Scrooge
     #
     def raise_on_missing_attribute?
       @on_missing_attribute == :raise
-    end
+    end        
+    
+    # Expose the warmup phase during which tracking occur.
+    #  
+    def warmup            
+      @warmup
+    end            
                 
     private
     
-      def configure! #:nodoc:
+      def configure! #:nodoc:        
         @orm = configure_with( @options['orm'], [:active_record], :active_record )
         @storage = configure_with( @options['storage'], [:memory], :memory )
-        @scope = configure_with( @options['scope'].to_s, framework.scopes, ENV['scope'] )
+        @strategy = configure_with( @options['strategy'], [:track, :scope, :track_then_scope], :track )
+        @scope = configure_with( @options['scope'].to_s, framework_scopes, ENV['scope'] )
+        @warmup = configure_with( @options['warmup'], 0..14400, 0 )    
         @enabled = configure_with( @options['enabled'], [true, false], false )
         @on_missing_attribute = configure_with( @options['on_missing_attribute'], [:reload, :raise], :reload )
         reset_backends!
         memoize_backends!
       end        
       
+      def framework_scopes #:nodoc:
+        framework.scopes rescue []
+      end
+    
       def configure_with( given, valid, default ) #:nodoc:
         if given
           valid.include?( given ) ? given : default
@@ -186,19 +183,21 @@ module Scrooge
       # Force constant lookups as autoload is not threadsafe.
       #
       def memoize_backends! #:nodoc:
-        framework()
+        framework() rescue nil
         orm()
         storage()
         tracker()
+      end         
+        
+      def scope_to_signature!( scope_signature ) #:nodoc:
+        log "Scope to signature #{scope_signature} ..."
+        @tracker_instance = framework.from_scope!( scope_signature )      
+      end
+
+      def scope_to_tracker!( tracker ) #:nodoc:
+        log "Scope to tracker #{tracker.inspect} ..."
+        @tracker_instance = tracker
       end
-                  
-      def shutdown_hook! #:nodoc:
-        # Registers an at_exit hook to persist the current application scope.
-        ::Kernel.at_exit do
-          log "shutdown ..."
-          framework.scope! if tracker.any? 
-        end        
-      end            
-                  
+                        
   end
 end

data/lib/scrooge/strategy/base.rb

@@ -0,0 +1,74 @@
+module Scrooge
+  module Strategy
+    
+    autoload :Controller, 'scrooge/strategy/controller'
+    autoload :Stage, 'scrooge/strategy/stage'
+    autoload :Scope, 'scrooge/strategy/scope'
+    autoload :Track, 'scrooge/strategy/track'
+    autoload :TrackThenScope, 'scrooge/strategy/track_then_scope'
+
+    class Base
+      
+      class NoStages < StandardError
+      end
+      
+      @@stages = Hash.new( [] )
+      @@stages[self.name] = []
+      
+      attr_reader :thread
+      
+      class << self
+        
+        # Stage definition macro.
+        #
+        # stage :track, :for => 10.minutes do
+        #   ....
+        # end
+        #
+        def stage( signature, options = {}, &block )
+          @@stages[self.name] << Scrooge::Strategy::Stage.new( signature, options, &block )
+        end
+        
+        # List all defined stages for this klass.
+        #
+        def stages
+          @@stages[self.name]
+        end
+        
+        # Are there any stages defined ?
+        #
+        def stages?
+          !stages.empty?
+        end
+        
+        # Test teardown helper.
+        #
+        def flush!
+          @@stages[self.name] = []
+        end
+        
+      end
+      
+      # Requires at least one stage definition.
+      #
+      def initialize
+        raise NoStages unless self.class.stages?
+      end 
+      
+      # Piggy back on stages defined for this klass.
+      #
+      def stages
+        self.class.stages
+      end
+      
+      # Enforce this strategy
+      #
+      def execute!
+        if Scrooge::Base.profile.enabled?
+          @thread = Scrooge::Strategy::Controller.new( self ).run!
+        end
+      end
+      
+    end
+  end
+end

data/lib/scrooge/strategy/controller.rb

@@ -0,0 +1,29 @@
+module Scrooge
+  module Strategy
+    class Controller
+      
+      attr_accessor :strategy
+      attr_reader :thread
+                    
+      def initialize( strategy )
+        @strategy = strategy
+      end
+      
+      def run!
+        @thread = Thread.new do
+          Thread.current.abort_on_exception = true
+          stages.map do |stage|
+            stage.execute!
+          end
+        end
+      end
+      
+      private
+      
+        def stages #:nodoc:
+          @strategy.stages
+        end
+      
+    end
+  end
+end

data/lib/scrooge/strategy/scope.rb

@@ -0,0 +1,14 @@
+module Scrooge
+  module Strategy
+    class Scope < Base
+    
+      stage :scope do
+        log( "Scope ...", true )
+        self.scope = scope if framework.scope?( scope )
+        framework.install_scope_middleware( tracker )
+       
+      end    
+      
+    end
+  end
+end

data/lib/scrooge/strategy/stage.rb

@@ -0,0 +1,77 @@
+module Scrooge
+  module Strategy
+    class Stage
+      
+      # Represents a duration sensitive stage / phase of execution.
+      
+      STATES = { :initialized => 0, 
+                 :execute => 1,
+                 :terminated => 2 }
+      
+      attr_accessor :signature,
+                    :duration,
+                    :payload 
+      
+      # Requires a unique signature and stores a payload for later execution.
+      #
+      # Valid options is
+      # * :for : the phase / stage duration, in seconds 
+      #               
+      def initialize( signature, options = {}, &block )
+        @signature = signature                  
+        @duration = options[:for] || 0 
+        @payload = block
+        @state = :initialized
+      end
+      
+      # Always executeable when initialized and not yet terminated.
+      #
+      def executeable?
+        initialized? && !terminated?
+      end
+      
+      # Enter the :execute state, call the payload and sleep for the defined duration.
+      # Returns the payload result on completion and ensures that the current state is
+      # :terminated.
+      #
+      def execute!
+        begin
+          Scrooge::Base.profile.log( "Execute stage #{signature.inspect} ...", true)
+          @state = :execute
+          result = call!
+          sleep( @duration )      
+          result
+        ensure
+          @state = :terminated
+        end
+      end
+      alias :run! :execute!
+      
+      # Are we running ?
+      #
+      def execute?
+        @state == :execute
+      end
+      alias :running? :execute?
+      
+      # Is this stage pending execution ?
+      #
+      def initialized?
+        @state == :initialized
+      end
+      
+      # Has this stage already terminated ?
+      #
+      def terminated?
+        @state == :terminated
+      end
+      
+      private
+      
+        def call! #:nodoc:
+          Scrooge::Base.profile.instance_eval( &@payload )
+        end
+      
+    end
+  end
+end

data/lib/scrooge/strategy/track.rb

@@ -0,0 +1,19 @@
+module Scrooge
+  module Strategy
+    class Track < Base
+      
+      stage :track, :for => Scrooge::Base.profile.warmup do
+        
+        log( "Tracking", true )
+        framework.install_tracking_middleware()
+        start_tracking!
+        ::Kernel.at_exit do
+          log( "Shutdown ...", true )
+          framework.scope! if tracker.any?
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/scrooge/strategy/track_then_scope.rb

@@ -0,0 +1,41 @@
+module Scrooge
+  module Strategy
+    class TrackThenScope < Base
+      
+      stage :track, :for => Scrooge::Base.profile.warmup do
+
+        log( "Installing tracking middleware ... ", true )
+        framework.install_tracking_middleware()
+        log( "Start tracking ... ", true )        
+        start_tracking!
+      
+      end
+      
+      stage :synchronize, :for => 10 do
+
+        log( "Uninstalling tracking middleware ... ", true )
+        framework.uninstall_tracking_middleware
+        log( "Stop tracking ... ", true )
+        stop_tracking!
+        log( "Synchronize results with other processes ...", true )
+        tracker.synchronize!
+      
+      end
+      
+      stage :aggregate, :for => 10 do
+
+        log( "Aggregate results from other processes ...", true )  
+        tracker.aggregate!
+      
+      end      
+      
+      stage :scope do
+
+        log( "Scope ...", true ) 
+        framework.install_scope_middleware( tracker )
+      
+      end            
+      
+    end
+  end
+end

data/lib/scrooge/tracker/app.rb

@@ -6,6 +6,8 @@ module Scrooge
       
       GUARD = Monitor.new      
       
+      AGGREGATION_BUCKET = 'scrooge_tracker_aggregation'.freeze
+      
       attr_accessor :resources
       
       def initialize
@@ -13,6 +15,45 @@ module Scrooge
         @resources = Set.new
       end
       
+      # Push this tracker instance to the framework's cache store. 
+      # A synchronization signature unique for this Process is also logged in a synchronization 
+      # bucket which maintain references to each Process's tracker.
+      #
+      def synchronize!
+        GUARD.synchronize do
+          write_cache( synchronization_signature, marshal_dump )
+          register_synchronization_signature!
+        end
+      end
+      
+      # Process previously synchronized tracking data by recursively merging all trackers from
+      # all Processes to have a Tracker representative of the whole cluster.
+      #
+      def aggregate!
+        GUARD.synchronize do
+          read_cache( AGGREGATION_BUCKET ).each do |tracker|
+            tracker_data = read_cache( tracker )
+            merge( self.class.load( tracker_data ) )
+          end  
+        end  
+      end
+      
+      # Merge this Tracker with another Tracker ( multi-process aggregation ) 
+      #      
+      def merge( other_tracker )
+        return unless other_tracker
+        resources.merge( other_tracker.resources )
+        resources.each do |res|
+          res.merge( other_tracker.resource( res )  )
+        end
+      end
+
+      # Find a given resource instance
+      #      
+      def resource( resource )
+        resources.detect{|r| r.signature == resource.signature }
+      end
+      
       # Has any Resources been tracked ? 
       #
       def any?
@@ -45,7 +86,6 @@ module Scrooge
       # Track a given Resource.
       #
       def track( resource )
-        profile.log "Track with resource #{resource.inspect}"
         begin
           yield
         ensure
@@ -64,12 +104,32 @@ module Scrooge
       # If we've seen this resource before, return the original, else, returns
       # the given resource.
       #
-      def resource_for( resource )
-        @resources.detect{|r| r.signature == resource.signature } || resource
+      def resource_for( res )
+        resource( res ) || res
       end
       
       private
       
+        def read_cache( key ) #:nodoc:
+          Scrooge::Base.profile.framework.read_cache( key )
+        end
+        
+        def write_cache( key, value ) #:nodoc:
+          Scrooge::Base.profile.framework.write_cache( key, value )
+        end
+      
+        def register_synchronization_signature! #:nodoc:
+          if bucket = read_cache( AGGREGATION_BUCKET )
+            write_cache( AGGREGATION_BUCKET, (bucket << synchronization_signature) )
+          else
+            write_cache( AGGREGATION_BUCKET, [synchronization_signature] )
+          end   
+        end
+      
+        def synchronization_signature #:nodoc:
+          @synchronization_signature ||= "#{Thread.current.object_id}_#{Process.pid}_#{rand(1000000)}"
+        end
+      
         def setup_resource( resource ) #:nodoc:
           GUARD.synchronize do
             resource_for( resource )

data/lib/scrooge/tracker/base.rb

@@ -15,6 +15,16 @@ module Scrooge
       class NotImplemented < StandardError
       end
       
+      class << self
+        
+        # Marshal helper.
+        #
+        def load( data )
+          new.marshal_load( data )
+        end
+        
+      end
+      
       attr_accessor :counter
       
       def initialize

data/lib/scrooge/tracker/model.rb

@@ -13,6 +13,13 @@ module Scrooge
         @attributes = Set.new 
       end
 
+      # Merge this Tracker with another Tracker for the same model ( multi-process / cluster aggregation ) 
+      #
+      def merge( other_model )
+        return unless other_model
+        attributes.merge( other_model.attributes )
+      end
+
       # Has any Attributes been tracked ? 
       #
       def any?

data/lib/scrooge/tracker/resource.rb

@@ -28,6 +28,16 @@ module Scrooge
         yield self if block_given?
       end
 
+      # Merge this Tracker with another Tracker for the same resource ( multi-process / cluster aggregation ) 
+      #      
+      def merge( other_resource )
+        return unless other_resource
+        models.merge( other_resource.models )
+        models.each do |model|
+          model.merge( other_resource.model( model ) )
+        end
+      end
+
       # Has any Models been tracked ? 
       #
       def any?
@@ -36,6 +46,12 @@ module Scrooge
         end  
       end
       
+      # Search for a given model instance
+      #
+      def model( model )
+        models.detect{|m| m.name == model.name }
+      end
+      
       # Generates a signature / lookup key.
       #
       def signature
@@ -111,7 +127,6 @@ module Scrooge
             #
             def filter( controller, &block )
               #{model.model.to_s}.#{profile.orm.resource_scope_method( resource ).to_s} do
-                Scrooge::Base.profile.log "Scope for Model #{model.inspect}"
                 block.call
               end
             end
@@ -178,7 +193,7 @@ module Scrooge
             models.map do |model|
               m = model.keys.first # TODO: cleanup
               Model.new( m ).marshal_load( model )
-            end
+            end.to_set
           end  
         end
         

data/lib/scrooge.rb

@@ -59,4 +59,5 @@ require 'scrooge/profile'
 require 'scrooge/storage/base'
 require 'scrooge/orm/base'
 require 'scrooge/framework/base'
-require 'scrooge/tracker/base'
+require 'scrooge/tracker/base'
+require 'scrooge/strategy/base'

data/rails/init.rb

@@ -6,5 +6,5 @@ Scrooge::Framework::Rails
 Scrooge::Base.profile = Scrooge::Profile.setup!
 Scrooge::Base.profile.framework.initialized do
   Scrooge::Base.profile.log "Initialized"
-  Scrooge::Base.profile.track_or_scope!
+  Scrooge::Base.profile.strategy.execute!
 end

data/spec/fixtures/config/scrooge.yml

@@ -3,10 +3,14 @@ production:
   storage: :memory
   scope: 1234567891 
   on_missing_attribute: :reload
+  strategy: :track_then_scope
+  warmup: 600 # warmup / track for 10 minutes
   enabled: true  
 test:
   orm: :active_record
   storage: :memory
   scope: 
   on_missing_attribute: :reload      
-  enabled: true      
+  strategy: :track_then_scope
+  warmup: 600 # warmup / track for 10 minutes
+  enabled: true