langrove 0.0.4.5 → 0.0.5.3

data/lib/langrove/ext/fake_config.rb

@@ -0,0 +1,121 @@
+module LanGrove
+
+  class FakeConfig
+
+    #
+    # for easy spec setup
+    #
+
+    attr_accessor :system
+
+    attr_accessor :application
+
+    attr_accessor :plugins
+
+    attr_accessor :daemons
+
+    def initialize
+
+      flush
+
+    end
+
+    def flush
+
+      @system = 'system'
+      @application = 'application'
+      @plugins = {}
+      @daemons = {}
+
+    end
+
+    def []( key )
+
+      return self.send( key )
+
+    end
+
+    def hash
+
+      config = {
+
+        :system => 'system',
+        :application => 'application',
+        :plugins => @plugins,
+        :daemons => @daemons
+
+      }
+
+      return config
+
+    end
+
+    def create_behaviour( daemon, behaviour, plugin, trigger = :handler_after_receive, action = nil )
+
+      init_daemon_config( daemon )
+
+      @daemons[daemon][:server][:behaviours] = {} if 
+        @daemons[daemon][:server][:behaviours].nil?
+
+      behaviours = @daemons[daemon][:server][:behaviours]
+
+      behaviours[behaviour] = {} if 
+        behaviours[behaviour].nil?
+
+      this = behaviours[behaviour]
+
+      this[:plugin] = plugin
+
+      this[:at] = { 
+        trigger => action
+      }
+
+    end
+
+    def create( daemon_name, module_name, module_class, module_config = {} )
+
+      init_daemon_config( daemon_name )
+
+      @daemons[daemon_name][module_name] = {
+
+        :class => module_class
+
+      }
+
+      @daemons[daemon_name][module_name].merge!( module_config )
+      
+
+    end
+
+    def get_plugin_config( name )
+
+      @plugins[ name ]
+
+    end
+
+    def get_plugin( name )
+
+      config = LanGrove::Config::Base.new( ROOT, hash, LOG )
+      config.get_plugin( name )
+
+    end
+
+    private 
+
+    def init_daemon_config( daemon_name )
+
+      if @daemons[daemon_name].nil?
+
+        @daemons[daemon_name] = {}
+        @daemons[daemon_name][:adaptor] = nil
+        @daemons[daemon_name][:handler] = nil
+        @daemons[daemon_name][:protocol] = nil
+        @daemons[daemon_name][:server] = {}
+
+      end
+
+    end
+
+  end
+
+end

data/lib/langrove/ext/fake_logger.rb

@@ -1,8 +1,51 @@
-module LanGrove class FakeLogger
-  def initialize( parameter = :noisey )
-    @parameter = parameter
+module LanGrove 
+
+  class FakeLogger
+
+    #
+    # for easy spec setup
+    #
+
+    class << self
+    
+      def on
+
+        @silent = false
+      
+      end
+      
+      def off
+      
+        @silent = true
+      
+      end
+
+      def debug( msg )
+      
+        puts "LOG.debug: [#{msg}]" unless @silent
+      
+      end
+      
+      def info( msg )
+      
+        puts "LOG.info: [#{msg}]" unless @silent
+      
+      end
+      
+      def warn( msg )
+      
+        puts "LOG.warn: [#{msg}]" unless @silent
+      
+      end
+
+      def error( msg )
+      
+        puts "LOG.error: [#{msg}]" unless @silent
+      
+      end
+    
+    end
+
   end
-  def method_missing( symbol, *args, &block )
-    puts "#{symbol}: #{args}" unless @parameter == :silent
-  end
-end; end
+
+end

data/lib/langrove/ext/fake_root.rb

@@ -0,0 +1,38 @@
+module LanGrove 
+  
+  class FakeRoot
+
+    #
+    # for easy spec setup
+    #
+    
+    attr_accessor :logger
+    attr_accessor :config
+    
+    def initialize( config = {
+
+      #
+      # Fake Config
+      #
+
+      :system => 'system',
+      :application => 'application'
+
+    }, logger = FakeLogger )
+      
+      @logger = logger
+      @config = LanGrove::Config::Base.new( self, config, logger )
+
+    end
+
+
+    
+    def method_missing( symbol, *args, &block )
+      
+      logger.info "call to ROOT.#{symbol}( #{args})" unless logger.nil?
+      
+    end
+    
+  end
+  
+end

data/lib/langrove/ext/hash.rb

@@ -0,0 +1,56 @@
+class Hash
+
+
+  def sym_key_sub( sub = '_' )
+
+    #
+    # Substitutes all :symkeys with '_symkeys'
+    #
+
+    replace( inject({}) do |hash, (key,val) | 
+
+        val.sym_key_sub( sub ) if val.is_a?( Hash )
+
+        if key.is_a?( Symbol )
+
+          hash["#{sub}#{key.to_s}"] = val
+        
+        else
+
+          hash[key] = val
+
+        end
+
+        hash
+        
+      end
+
+    )
+
+  end
+
+  def sym_key_usub( sub = '_')
+
+    replace( inject({}) do |hash, (key,val) | 
+
+        val.sym_key_usub( sub ) if val.is_a?( Hash )
+
+        if key[0] == '_'
+
+          hash[key[1..-1].to_sym] = val
+        
+        else
+
+          hash[key] = val
+
+        end
+
+        hash
+        
+      end
+
+    )
+
+  end
+
+end 

data/lib/langrove/ext/i.rb

@@ -0,0 +1,43 @@
+require 'awesome_print'
+
+class I
+  
+  def self.show( variable )
+    
+    ap variable
+  
+  end
+
+  def self.shoe( variable )
+
+    #
+    # i keep writing shoe, support it... ;)
+    #
+    
+    ap variable
+  
+  end
+  
+  def self.notify( logger, need_description, tags = [] )
+    
+    #
+    # log reminders into the running server 
+    #
+    do_it = "["
+    tags.each do |tag|
+      
+
+      
+      do_it = "#{do_it}:#{tag}, "
+      
+    end
+    
+    done = do_it.chop.chop
+    
+    logger.info( "#{done}] (todo) #{need_description}" )
+    
+  end
+
+end unless defined?( I ) # unlikely 
+
+Unimplemented = I

data/lib/langrove/ext/log_monitor.rb

@@ -0,0 +1,272 @@
+module LanGrove
+  
+  module LogMonitor
+
+    def log_monitor_config( config, hash = nil )
+      
+      # 
+      # <hash> as the state storage (capsule)
+      #
+      
+      #
+      # <config> as hash, as loaded from the
+      # relevant cofig branch.
+      # 
+      # :success: regex match
+      # :error: regex match
+      # :known_errors:
+      #    :short_name: regex_match
+      #    :nother_name: nother match
+      # :versions:
+      #    :version_name: regex match
+      # 
+      # Errors that match :error: but no :known_error: are
+      # tracked as unknown errors.
+      # 
+      # Errors that match a :known_errors: are tracked by name
+      # 
+      # Success match will reset all errors.... (GONE!)
+      # and set :success: to true on the capsule.
+      # 
+      # last_run_at is updated with each log message. 
+      # 
+
+      raise LanGrove::DaemonConfigException.new(
+      
+        "#{self.class} requires :success:, :error:, and :known_errors: config."
+      
+      ) unless (
+      
+        config.has_key?( :success ) and
+        config.has_key?( :error ) and
+        config.has_key?( :known_errors )
+      
+      )
+      
+      # 
+      # Mandatory config 
+      # 
+      @success_match = config[:success]
+      @error_match = config[:error]
+      
+      
+      #
+      # Optional config
+      #
+      @known_error_matchers = config[:known_errors]
+      @known_error_matchers ||= {}
+      
+      @version_matchers = config[:versions]
+      @version_matchers ||= {}
+      
+      @known_error_matchers.each do |name, matcher|
+        
+        raise LanGrove::DaemonConfigException.new(
+
+          "#{self.class} :known_error:#{name}: has no regex matcher"
+
+        ) if matcher.nil?
+        
+      end
+      
+      #
+      # Move unknown_errors that are now in config
+      # to known_errors.
+      #
+      
+      hash['unknown_errors'].each do |error_name, count|
+        
+        known_error = known_error?( error_name )
+        
+        unless known_error.nil?
+          
+          hash['known_errors'] = {} if hash['known_errors'].nil?
+          
+          hash['known_errors'][known_error] = count
+          
+          hash['unknown_errors'].delete error_name
+          
+        end
+        
+      end if (
+        
+        not hash.nil? and 
+        hash.has_key?( 'unknown_errors' )
+      
+      )
+      
+      
+      #
+      # Clear known_errors from state that
+      # are no longer in config
+      # 
+      
+      hash['known_errors'].each_key do |error_name|
+        
+        unless @known_error_matchers.has_key?( error_name )
+        
+          hash['known_errors'].delete error_name
+        
+        end
+        
+      end if (
+      
+        not hash.nil? and 
+        hash.has_key?( 'known_errors' )
+        
+      )
+      
+    end
+    
+    def log_monitor_event( hash, event )
+      
+      changed = false
+      
+      hash['known_errors'] = {} if hash['known_errors'].nil?
+      hash['unknown_errors'] = {} if hash['unknown_errors'].nil?
+      
+      hash['last_ran_at'] = event[:timestamp]
+      
+      changed = update_versions( hash, event )
+      
+      success_match = /#{@success_match}/.match( event[:event] )
+      
+      unless success_match.nil?
+        
+        hash['success'] = true
+        
+        hash['success_at'] = event[:timestamp]
+        
+        changed = log_monitor_reset( hash )
+        
+        return changed
+        
+      end
+      
+      error_match = /#{@error_match}/.match( event[:event] )
+      error_type = 'unknown_errors'
+      error_name = nil
+      
+      unless error_match.nil?
+        
+        #
+        # Success to false on error
+        #
+        
+        hash['success'] = false
+        
+        error_name = event[:event]
+        
+        known_error = known_error?( error_name )
+        
+        unless known_error.nil?
+          
+          error_type = 'known_errors'
+          error_name = known_error
+          
+        end
+      
+      end
+      
+      unless error_name.nil?
+        
+        if hash[ error_type ].nil?
+          
+          hash[ error_type ] = {}
+          
+        end
+        
+        if hash[ error_type ][ error_name ].nil?
+          
+          hash[ error_type ][ error_name ] = 0
+          
+        end
+        
+        hash[ error_type ][ error_name ] = 
+          hash[ error_type ][ error_name ] + 1
+        
+        changed = true
+        
+      end
+      
+      return changed
+      
+    end
+    
+    def log_monitor_reset( hash )
+      
+      hash.delete 'unknown_errors'
+      
+      hash['unknown_errors'] = {}
+      
+      hash.delete 'known_errors'
+      
+      hash['known_errors'] = {}
+      
+      return true
+      
+    end
+    
+    
+    private
+    
+    
+    def update_versions( hash, event )
+      
+      @version_matchers.each do |version_name, match_regex|
+
+        version_match = /#{match_regex}/.match( event[:event] )
+        
+        unless version_match.nil?
+          
+          version_number = version_match[1]
+
+          return false if version_number.nil?  # bad regex... did not match 'out' an actual version number
+        
+          hash[version_name] = {} if hash[version_name.to_sym].nil?
+          
+          hash[version_name]['latest'] = version_number
+          
+          #
+          # Over time this (collected date of version change / her host)
+          # may get quite long
+          #
+          hash[version_name][version_number] = event[:timestamp]
+          
+          return true
+          
+        end
+        
+      end
+      
+      return false
+      
+    end
+    
+    
+    def known_error?( event )
+      
+      known_error = nil
+      
+      @known_error_matchers.each do |key, value|
+      
+        known_error = /#{value}/.match( event )
+        
+        unless known_error.nil?
+        
+          error_type = :known_errors
+          error_name = key
+          
+          return key
+          
+        end
+      
+      end
+      
+      return nil
+      
+    end
+    
+  end
+  
+end

data/lib/langrove/ext/module_loader.rb

@@ -0,0 +1,52 @@
+module LanGrove
+  class ModuleLoader
+    class << self
+
+      def create(args={})
+        
+        #
+        # args = {
+        # 
+        #   :config => <hash of config>,
+        #   :key    => <daemon_root_component_key>,
+        #   :mandatory => <default true>
+        # 
+        # }
+        #
+        
+
+        # if the config has no 'module key'
+        unless args[:config].has_key?(args[:key])
+
+          mandatory = args[:mandatory]
+          mandatory = true if mandatory.nil?    #stu defaults to correct
+
+          if mandatory
+            raise DaemonConfigException, "Cannot find key with '#{args[:key]}'"
+          else
+            # just exit
+            return nil
+          end
+        end
+
+        params = { 
+          :class => "Default", 
+          :module => args[:key].to_s.camelize
+        }
+        
+        begin
+          class_name = args[:config][args[:key]][:class]
+        rescue
+          #class_name = 'Base' if args[:config].has_key?( args[:key] )
+        end
+        
+        params.merge!(:class => class_name) unless class_name.nil?
+        
+
+
+        ClassLoader.create(params, args[:logger])
+      end
+
+    end
+  end
+end