langrove 0.0.4.5 → 0.0.5.3

data/lib/langrove/plugin/assessor.rb

@@ -0,0 +1,363 @@
+ASSESSOR_VERSION = 0
+
+module LanGrove
+  
+  module Plugin
+    
+    #
+    # This need a better home.
+    #
+    class Handler
+
+      attr_accessor :capsule
+      attr_accessor :key
+      attr_accessor :type
+      
+      def initialize( key, capsule = {} )
+        @type = :handler
+        @key = key
+        @capsule = capsule
+      end
+
+    end
+    
+    class Assessor < Base
+      
+      def self.type
+        
+        :assessor
+        
+      end
+
+      
+      #
+      # Assessor has an internal Persistor used to store|fetch
+      # the previous 'capsule' contents. 
+      #
+      attr_reader :persistor
+      
+      
+      #
+      # assess_present tests for presense of a key(s)
+      # between two hashes.
+      # 
+      # - If on the first(old) but not the second(new)
+      #   
+      #   an :off notification is generated
+      # 
+      # - If on both, 
+      # 
+      #   a :repeat: notification is generated
+      # 
+      # - If not on the first(old) but is on the second
+      # 
+      #   an :on notification is generated
+      #
+      def assess_present( old_val, new_val, key, &block )
+        
+        return if @reported.has_key?( key )
+        
+        delta = nil
+        
+        begin
+        
+          delta = new_val - old_val
+        
+        rescue; end
+        
+        if old_val.nil? 
+          
+          yield key, :on, new_val, delta unless new_val.nil?
+          
+        else
+          
+          yield key, :repeat, new_val, delta unless new_val.nil?
+          yield key, :off, new_val, delta if new_val.nil?
+          
+        end
+        
+        @reported[key] = 1
+        
+      end
+      
+      
+      
+      def assess( handler )
+
+        #
+        # The passed in handler will have the key attribute set.
+        # 
+        # Use the id from that key with the local persistors  
+        # configured table to collect the 'previous' contents 
+        # of the handlers capsule (as was passed through this
+        # collator last time the capsule changed). 
+        #
+        # 
+        begin 
+          
+          @logger.error( 
+        
+            "ERROR: Assessor encountered undefined #{handler.class}.key"
+        
+          )
+          
+          return
+          
+        end if handler.key.nil?
+        
+        key = handler.key
+        key['table'] = @persistor.instance_variable_get(:@table)
+        
+        previous = Handler.new( key )
+        
+        #
+        # Fetch previous 'capsule'
+        #
+        
+        unless persistor.fetch( previous )
+          
+          @logger.info "Persistor did/could not fetch previous, make this fail the job..."
+          
+          return
+          
+        end
+
+        each_change( previous.capsule, handler.capsule ) do |key, state, value, delta|
+          
+          #
+          # Assemble the notification
+          #
+          notifiation = {
+            
+            :source => handler.unique,
+            :system => @root.config.system,
+            :application => @root.config.application,
+            :key => key,
+            :state => state,
+            :value => value,
+            :delta => delta,
+            
+          }
+          
+          notifiation[:ref] = @refference unless @refference.nil?
+          
+          #
+          # Pass to the Handler for possible
+          # filtration. 
+          #
+          handler.event_filter( :notification, notifiation ) do |notify|
+
+            I.show notify
+            
+            #
+            # Filtered. 
+            # 
+            # Pass to trigger.
+            # 
+            # Note: It is passed in the capsule of a 
+            #       mini Handler, to stick to pattern.
+            #
+            @root.trigger( 
+            
+              Handler.new( nil, notifiation ), :handler, :notify
+              
+            )
+            
+          end
+          
+        end
+        
+        #
+        # Save the current to previous
+        #
+        previous.capsule = handler.capsule
+        persistor.store( previous )
+        
+      end
+      
+      
+      def initialize( root, config, name = nil )
+        
+        super( root, config, name )
+        
+        @refference = @config[:ref]
+        
+        validate_config
+        
+        @provides = {
+          
+          :assessor => {
+            
+            :version => ASSESSOR_VERSION
+            
+          }
+          
+        }
+      
+      end
+      
+      def assess_handler( handler )
+        
+        #
+        # Option to trigger :handler_assess:
+        #
+        
+        assess( handler )
+        
+        #
+        # Option to trigger :handler_after_assess:
+        #
+        
+      end
+      
+      
+      def validate_config
+        
+        config_exception( 
+        
+          "#{self.class} requires a nested Persistor :plugin:" 
+          
+        ) if (
+          @config[:plugin].nil? or
+          @persistor = @root.config.get_plugin( @config[:plugin] ) and
+          @persistor.nil?
+        
+        )
+        
+        config_exception( 
+        
+          "#{self.class} requires :assess: subconfig"
+        
+        ) unless (
+        
+          @config.has_key?( :assess ) and
+          @assess = @config[:assess]
+          
+        )
+        
+        @assess ||= {}
+        
+        config_exception( 
+        
+          "#{self.class} requires :assess: to contain a subconfig of dataitems to collate"
+        
+        ) unless (
+        
+          @assess.is_a?( Hash )
+        
+        )
+        
+      end
+      
+      def each_change( old_hash, new_hash, &block )
+        
+        @reported = {}
+        
+        @assess.each do |key_match, assess_type| 
+
+          #
+          # Search both hashes in tandem and yield the 
+          # values found at the match key,
+          #
+          # If the value at the matching key is a new
+          # hash, yield all subkeys from each in 
+          # tandem
+          # 
+          tandem_recurse( old_hash, new_hash, key_match ) do |o, n, key|
+            
+            self.send( 
+            
+              "assess_#{assess_type}".to_sym, 
+              o, n, key, &block 
+              
+            )
+            
+          end
+          
+        end
+        
+      end
+      
+      def tandem_recurse( oldh, newh, match, &block )
+        
+        if ( oldh.is_a?( Hash ) and oldh.has_key?( match ) ) or 
+           ( newh.is_a?( Hash ) and newh.has_key?( match ) )
+          
+          o = oldh[match] unless oldh.nil?
+          n = newh[match] unless newh.nil?
+          
+          unless o.is_a?( Hash ) or n.is_a?( Hash )
+            
+            yield o, n, match if block
+
+            return
+
+          end
+          
+          if n.is_a?( Hash )
+            
+            n.each do |key, value|
+              
+              oo = o[key] unless o.nil?
+            
+              yield oo, value, key if block
+              
+            end
+            
+          end
+
+          if o.is_a?( Hash )
+            
+            o.each do |key, value|
+              
+              nn = n[key] unless n.nil?
+            
+              yield value, nn, key if block
+              
+            end
+            
+          end
+          
+        end
+        
+        unless newh.nil? or newh.size == 0
+          
+          newh.each do |key, value|
+            
+            if value.is_a?( Hash )
+              
+              o = nil
+              o ||= oldh[key]
+              
+              tandem_recurse( o, value, match, &block )
+              
+            end
+            
+          end
+          
+        end
+        
+        unless oldh.nil? or oldh.size == 0
+          
+          oldh.each do |key, value|
+            
+            if value.is_a?( Hash )
+              
+              n = nil
+              n ||= newh[key]
+              
+              tandem_recurse( value, n, match, &block )
+              
+            end
+            
+          end
+          
+        end
+        
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/langrove/plugin/base.rb

@@ -0,0 +1,18 @@
+module LanGrove
+
+	module Plugin
+
+	end
+
+end
+
+require 'langrove/plugin/plugin_base'
+
+require 'langrove/plugin/persistor'
+require 'langrove/plugin/buffered_persistor'
+require 'langrove/plugin/yaml_file'
+
+require 'langrove/plugin/enqueuer'
+require 'langrove/plugin/assessor'
+require 'langrove/plugin/notifier'
+#require 'langrove/plugin/terminator'

data/lib/langrove/plugin/buffered_persistor.rb

@@ -0,0 +1,97 @@
+module LanGrove
+  
+  module Plugin
+
+    class BufferedPersistor < Persistor
+
+      def store_all
+
+        #
+        # OVERRIDE
+        # 
+        # To store all capsules accumulated in
+        # @capsules
+        #
+
+        @capsules.is_a? Hash
+
+      end
+
+      def validate_config
+
+        unless defined?( EM ) and EM.reactor_running?
+
+          raise LanGrove::PluginException.new(
+
+            "#{self.class} only runs inside EventMachine enabled daemons"
+
+          )
+
+        end
+
+        super
+
+        @capsules = {}
+        @stored = {} 
+
+        @interval = @config[:interval]
+
+        if @interval.nil?
+
+          #
+          # default to call store every 10 minutes
+          #
+
+          @logger.info "#{self.class} defaulting :interval: to 10 minutes"
+
+          @interfal = 600
+
+        end
+
+        EM.add_periodic_timer( @interval ) do
+
+          if @running
+
+            @logger.warn "#{self.class} already running store_all"
+
+            break
+
+          end
+
+          @running = true
+          
+          store_all
+
+          @running = false
+
+        end
+
+      end
+
+      def store( handler )
+
+        gen_key( handler ) if handler.key.nil?
+
+        @key_column = handler.key['key'].first[0]
+
+        key = handler.key['key'].first[1]
+
+        @stored[key] = false
+
+        @capsules[key] = YAML.load( 
+
+          #
+          # LAZY... deep copy through YAML serialize
+          # 
+
+          YAML.dump( handler.capsule ) 
+
+        )
+
+      end
+
+    end
+
+  end
+
+end

data/lib/langrove/plugin/enqueuer.rb

@@ -0,0 +1,186 @@
+ENQUEUER_VERSION = 0
+
+module LanGrove
+  
+  module Plugin
+    
+    class Enqueuer < Base
+      
+      def self.type
+        
+        :enqueuer
+        
+      end
+      
+      def initialize( root, config, name = nil )
+        
+        super( root, config, name )
+        
+        validate_config
+        
+        @provides = {
+          
+          :enqueuer => {
+            
+            :version => ENQUEUER_VERSION
+            
+          }
+          
+        }
+      
+      end
+      
+      def enqueue_key( handler )
+        
+        #
+        # Enqueue a job into a work queue
+        # Insert the capsule.key as payload
+        # 
+        
+        header = queue_header( :get_capsule, handler )
+        data = handler.key
+        
+        # enqueue( header, data )
+
+        raise LanGrove::PluginException.new(
+
+          "#{self.class}.enqueue_key() not implemented."
+          
+        )
+
+      end
+      
+      def enqueue_capsule( handler )
+        
+        #
+        # Enqueue a job into a work queue
+        # Insert the capsule.capsule as payload
+        # 
+        
+        header = queue_header( :load_capsule, handler )
+        data = handler.capsule
+        
+        # enqueue( header, data )
+
+        raise LanGrove::PluginException.new(
+
+          "#{self.class}.enqueue_casule() not implemented."
+          
+        )
+
+      end
+      
+      def enqueue_key_handler( handler )
+        
+        @root.trigger( handler, :handler, :enqueue )
+        
+        enqueue_key( handler )
+        
+        @root.trigger( handler, :handler, :after_enqueue )
+        
+      end
+      
+      def enqueue_capsule_handler( handler )
+        
+        @root.trigger( handler, :handler, :enqueue )
+        
+        enqueue_capsule( handler )
+        
+        @root.trigger( handler, :handler, :after_enqueue )
+        
+      end
+      
+      def queue_header( action, handler, routing_flags = 'none' )
+        
+        #
+        # Jobs inserted into a work queue should contain 
+        # as first paremeter the following header:
+        # 
+        #
+
+        context = "#{@root.config.system}:#{@root.config.application}:#{routing_flags}"
+        
+        return {
+
+          'context' => context,
+          
+          #
+          # Required - A timestamp, 
+          # 
+          # - Allows for monitoring of queue lag.
+          # 
+          # - Allows for a future QueueMarshal which
+          #   can redirect by age into a :do_immediately
+          #   and a :do_later_because_old_data_isnot_urgent
+          #   
+          #
+          'created_at'  => Time.now,
+          
+          #
+          # Optional - A dequeue action,
+          # 
+          # The worker dequeueing the Job will make a call 
+          # to whatever function is specified ahead of
+          # yielding the Job to be processed
+          #
+          #
+          'action' => action,
+          
+          #
+          # Optional - A sequence number, 
+          # 
+          # - Allows for the ability to 'expire' jobs.
+          # 
+          # eg.  A sequence on the persisted capsule differing 
+          #      from the sequence in the key on the associated 
+          #      Job as queued would mean a subsequent update to 
+          #      the persisted capsule has ocurred, 
+          #      
+          #      And an additional Job has been queued to process 
+          #      it, so the first job can therefore be skipped in 
+          #      the cases where:
+          # 
+          #      A. Only the most recent state is relevant 
+          #         for processing.
+          #  
+          #      B. The capsule is persisted from a single 
+          #         source, all other processes access it
+          #         from a read only capacity.
+          #
+          #      Z. The Job is quick, or sufficiently not slow,
+          #         or being queued by something possibly faster, 
+          #         but also queueing jobs against enough separate
+          #         persistables in a manner that will ensure that 
+          #         the possibility of the queue worker never ever
+          #         catching up to a 'latest' capsule, and therefore
+          #         permanently collecting and skipping jobs, is
+          #         sufficiently unlikely.
+          # 
+          #
+          'sequence' => handler.capsule['persisted_seq']
+          
+        }
+        
+      end
+      
+      def validate_config
+        
+        #
+        # Deferrer requires :worker specified
+        # as the WorkerClass that will consume
+        # jobs from the queue
+        #
+        
+        config_exception( 
+        
+          "#{self.class} requires :job:" 
+          
+        ) unless @job = @config[ :job ]
+        
+      end
+      
+    end
+    
+  end
+  
+end