methodmissing-scrooge 1.0.4 → 2.0.0

data/lib/scrooge/strategy/stage.rb

@@ -1,77 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,161 +0,0 @@
-module Scrooge
-  module Tracker
-    class App < Scrooge::Tracker::Base
-      
-      # Application container for various Resources.
-      
-      GUARD = Monitor.new      
-      
-      AGGREGATION_BUCKET = 'scrooge_tracker_aggregation'.freeze
-      
-      attr_accessor :resources
-      
-      def initialize
-        super()
-        @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?
-        GUARD.synchronize do
-          !@resources.empty?
-        end  
-      end
-      
-      # Add a Resource instance to this tracker.
-      #      
-      def <<( resource )
-        GUARD.synchronize do
-          @resources << setup_resource( resource )
-        end
-      end
-      
-      def marshal_dump #:nodoc:
-        GUARD.synchronize do
-          dumped_resources()
-        end
-      end
-      
-      def marshal_load( data ) #:nodoc:
-        GUARD.synchronize do
-          @resources = Set.new( restored_resources( data ) )
-        end
-        self
-      end
-      
-      # Track a given Resource.
-      #
-      def track( resource )
-        begin
-          yield
-        ensure
-          self << resource if resource.any?
-        end     
-      end
-      
-      def inspect #:nodoc:
-        if any?
-          @resources.map{|r| r.inspect }.join( "\n\n" )
-        else
-          super
-        end  
-      end
-      
-      # If we've seen this resource before, return the original, else, returns
-      # the given 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 )
-          end
-        end
-      
-        def environment #:nodoc:
-          profile.framework.environment
-        end
-      
-        def restored_resources( data ) #:nodoc:
-          GUARD.synchronize do
-            data.map do |resource|
-              Resource.load( resource )
-            end
-          end
-        end
-      
-        def dumped_resources #:nodoc:
-          GUARD.synchronize do
-            @resources.to_a.map do |resource|
-              resource.marshal_dump
-            end
-          end
-        end
-            
-    end
-  end
-end

data/lib/scrooge/tracker/base.rb

@@ -1,66 +0,0 @@
-require 'set'
-
-module Scrooge
-  module Tracker
-    
-    autoload :App, 'scrooge/tracker/app'
-    autoload :Resource, 'scrooge/tracker/resource'
-    autoload :Model, 'scrooge/tracker/model'
-    
-    class Base < Scrooge::Base
-      include Comparable      
-      
-      # Scrooge Tracker base class.
-      
-      class NotImplemented < StandardError
-      end
-      
-      class << self
-        
-        # Marshal helper.
-        #
-        def load( data )
-          new.marshal_load( data )
-        end
-        
-      end
-      
-      attr_accessor :counter
-      
-      def initialize
-        @counter = 0
-      end
-      
-      def to_i
-        @counter  
-      end
-      
-      # Requires subclasses to implement a custom marshal_dump
-      #
-      def marshal_dump
-        raise NotImplemented
-      end
-
-      # Requires subclasses to implement a custom marshal_load
-      #      
-      def marshal_load( data )
-        raise NotImplemented
-      end
-      
-      # Compare trackers through their Marshal representations.
-      #
-      def ==( tracker )
-        compare_to( tracker )
-      end
-      alias :eql? :==
-      alias :<=> :==
-      
-      private
-        
-        def compare_to( tracker ) #:nodoc:
-          marshal_dump == tracker.marshal_dump
-        end
-          
-    end
-  end
-end

data/lib/scrooge/tracker/model.rb

@@ -1,150 +0,0 @@
-module Scrooge
-  module Tracker
-    class Model < Base
-      
-      GUARD = Monitor.new
-      
-      attr_accessor :model,
-                    :attributes 
-
-      def initialize( model )
-        super()
-        @model = model
-        @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?
-        GUARD.synchronize do
-          !@attributes.empty?
-        end  
-      end
-   
-      # Add a Model attribute to this tracker.
-      #
-      def <<( attribute )
-        GUARD.synchronize do
-          Array( attribute ).each do |attr|
-            attributes << attr
-          end
-        end  
-      end     
-      
-      def marshal_dump #:nodoc:
-        GUARD.synchronize do
-          { name() => @attributes.to_a }
-        end
-      end
-      
-      def marshal_load( data ) #:nodoc:
-        GUARD.synchronize do
-          @model = data.keys.first
-          @attributes = Set.new( data[@model] )
-          self
-        end
-      end
-
-      # Return a valid Rack middleware instance for this model.
-      #
-      def middleware( resource )
-        profile.orm.scope_resource_to_model( resource, self )
-        klass = Class.new
-        klass.class_eval(<<-EOS, __FILE__, __LINE__)
-          
-          class << self
-            
-            def inspect
-              "#<Scrooge::Middleware #{inspect}>"
-            end
-            
-            # Around Filter compatible implementation for Rails as Dispatcher is 
-            # the root Rack application and as such don't provide access to the Rails
-            # Routing internals from other middleware.
-            #
-            def filter( controller )
-              #{model.to_s}.#{profile.orm.resource_scope_method( resource ).to_s} do
-                yield
-              end
-            end
-            
-          end
-          
-          def initialize(app)
-            @app = app
-          end
-
-          def call(env)
-            if scope?( env )
-              #{model.to_s}.#{profile.orm.resource_scope_method( resource ).to_s} do
-                @app.call(env)
-              end
-            else
-              @app.call(env)
-            end  
-          end
-          
-          private
-            
-            def scope?( env )
-              Scrooge::Base.profile.orm.resource_scope_method( resource( env ) ) == :#{profile.orm.resource_scope_method( resource ).to_s}                 
-            end  
-            
-            def resource( env )
-              Scrooge::Base.profile.framework.resource( env )
-            end
-          
-        EOS
-        klass        
-      end
-      
-      # Memoize the name lookup.
-      #
-      def name
-        @name ||= profile.orm.name( @model )
-      end
-      
-      # Memoize the table name lookup.
-      #
-      def table_name
-        @table_name ||= profile.orm.table_name( @model )
-      end
-      
-      # Memoize the primary key lookup.
-      #
-      def primary_key
-        @primary_key ||= profile.orm.primary_key( @model )
-      end
-      
-      # Dump to a SQL SELECT snippet.
-      #
-      def to_sql
-        GUARD.synchronize do
-          attributes_with_primary_key().map{|a| "#{table_name}.#{a.to_s}" }.join(', ')
-        end
-      end
-      
-      def inspect #:nodoc:
-        "#<#{name()} #{attributes_for_inspect}>"
-      end
-      
-      private
-       
-        def attributes_for_inspect #:nodoc:
-          @attributes.map{|a| ":#{a}" }.join(', ')
-        end
-      
-        def attributes_with_primary_key #:nodoc:          
-          @attributes << primary_key
-        end
-      
-    end    
-  end
-end

data/lib/scrooge/tracker/resource.rb

@@ -1,181 +0,0 @@
-module Scrooge
-  module Tracker
-    class Resource < Base
-      
-      # A Resource tracker is scoped to a
-      #
-      # * controller
-      # * action
-      # * request method
-      # * content type
-      #
-      # and is a container for any Models referenced during the active
-      # request / response cycle.
-      
-      GET = /get/i
-      
-      GUARD = Monitor.new
-            
-      attr_accessor :controller,
-                    :action,
-                    :method,
-                    :format,
-                    :models,
-                    :is_public     
-      
-      def initialize
-        super()
-        @models = Set.new
-        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?
-        GUARD.synchronize do
-          !@models.empty?
-        end  
-      end
-
-      # Is this a public ( not authenticated ) resource ?
-      #
-      def public?
-        @is_public == true
-      end
-      
-      # Is this a private ( authenticated ) resource ?
-      #      
-      def private?
-        !public?
-      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
-        @signature ||= "#{controller.to_s}_#{action.to_s}_#{method.to_s}_#{private_or_public}"
-      end
-      
-      # Only track GET requests
-      #
-      def trackable?
-        !( method || '' ).to_s.match( GET ).nil?
-      end
-      
-      # Add a Model to this resource.
-      #
-      def <<( model )
-        GUARD.synchronize do
-          @models << track_model_from( model )
-        end
-      end
-      
-      def marshal_dump #:nodoc:
-        GUARD.synchronize do
-          { signature => { :controller => @controller,
-                           :action => @action,
-                           :method => @method,
-                           :format => @format,
-                           :models => dumped_models(),
-                           :is_public => @is_public } }
-        end
-      end      
-      
-      def marshal_load( data ) #:nodoc:
-        GUARD.synchronize do
-          data = data.to_a.flatten.last
-          @controller = data[:controller]
-          @action = data[:action]
-          @method = data[:method]
-          @format = data[:format]
-          @models = restored_models( data[:models] )
-          @is_public = data[:is_public]
-          self
-        end  
-      end
-      
-      # Yields a collection of Rack middleware to scope Model attributes to the
-      # tracked dataset.
-      #
-      def middleware
-        @middleware ||= begin
-          GUARD.synchronize do
-            models.map do |model|
-              model.middleware( self )
-            end
-          end  
-        end
-      end      
-
-      def inspect #:nodoc:
-        "#<#{@method.to_s.upcase} #{private_or_public} :#{@controller}/#{@action} (#{@format})\n#{models_for_inspect()}"
-      end
-      
-      private
-      
-        def private_or_public #:nodoc:
-          @is_public ? 'public' : 'private'
-        end
-      
-        def track_model_from( model ) #:nodoc:
-          model.is_a?( Array ) ? model_from_enumerable( model ) : setup_model( model )
-        end
-      
-        def model_from_enumerable( model ) #:nodoc:
-          model, attribute = model
-          model = setup_model( model )
-          model << attribute
-          model
-        end
-      
-        def models_for_inspect #:nodoc:
-          models.map{|m| " - #{m.inspect}" }.join( "\n" )
-        end
-      
-        def dumped_models #:nodoc:
-          GUARD.synchronize do
-            @models.to_a.map{|m| m.marshal_dump }
-          end
-        end
-        
-        def restored_models( models ) #:nodoc:
-          GUARD.synchronize do
-            models.map do |model|
-              m = model.keys.first # TODO: cleanup
-              Model.new( m ).marshal_load( model )
-            end.to_set
-          end  
-        end
-        
-        def setup_model( model ) #:nodoc:
-          GUARD.synchronize do
-            if model.is_a?( Scrooge::Tracker::Model )
-              model
-            else
-              model_for( model ) || Scrooge::Tracker::Model.new( model )
-            end
-          end       
-        end
-      
-        def model_for( model ) #:nodoc:
-          @models.detect{|m| m.model.name == model.name }
-        end
-      
-    end
-  end
-end

data/spec/fixtures/config/scrooge/scopes/1234567891/scope.yml

@@ -1,2 +0,0 @@
---- 
-test: []