LanGrove 0.0.1 → 0.0.2

data/lib/langrove/daemon/base.rb

@@ -0,0 +1,2 @@
+module LanGrove::Daemon; end
+require 'langrove/daemon_base'

data/lib/{daemon_base.rb → langrove/daemon_base.rb}

@@ -1,20 +1,17 @@
 require 'eventmachine'
 
-require 'ext/string'
+require 'langrove'
 
-class DaemonConfigException < Exception; end
-
-module Daemon class Base
+module LanGrove::Daemon class Base
   
   def listen
     
     #
-    # Handler, the CollectionOfClients,
-    # is passed through the adaptor to
-    # be assigned to the attaching sockets.
+    # Handler - The CollectionOfClients, is passed 
+    #           through the adaptor to be assigned 
+    #           to the attaching Clients.
     #
-    
-    @adaptor.listen( @handler )
+    @adaptor.listen( @handler, @handler.protocol )
     
   end
   
@@ -101,29 +98,29 @@ module Daemon class Base
       #
       # you shall not pass
       #
-      raise DaemonConfigException.new( "Requires a logger" )
+      raise LanGrove::DaemonConfigException.new( "Requires a logger" )
       
     end
 
     begin
 
-      @my_config = config_hash['daemons'][daemon_name]
+      @my_config = @config[ :daemons ][ @daemon_name ]
       
-      @server    = @my_config['listen'] if @my_config.has_key? 'listen'
+      @server    = @my_config[ :server ] if @my_config.has_key? :server
       
-      adaptor    = @my_config['adaptor']['connection']   
+      adaptor    = @my_config[ :adaptor ][ :connection ]
       
-      handler    = @my_config['handler']['collection']
+      handler    = @my_config[ :handler ][ :collection ]
          
     rescue
       
-      error = "Missing config item for daemon: #{daemon_name}" 
+      error = "Missing config item for daemon: #{@daemon_name}" 
       
       @logger.error "EXIT: #{error}"
       
-      raise DaemonConfigException.new( 
+      raise LanGrove::DaemonConfigException.new( 
       
-        "Missing config item for daemon: #{daemon_name}" 
+        "Missing config item for daemon: #{@daemon_name}" 
         
       )
         
@@ -140,9 +137,14 @@ module Daemon class Base
     #       collection: CollectionOfClients 
     #
 
-    @logger.info "Initialize connection: Adaptor::#{adaptor}.new( @my_config['adaptor'], logger )"
-    eval "require 'adaptor/#{adaptor.underscore}'"
-    @adaptor = Adaptor.const_get(adaptor).new( @my_config['adaptor'], logger )
+    @logger.info "Initialize instance: Adaptor::#{adaptor}.new( @my_config[ :adaptor ], logger )"
+    
+    @adaptor = LanGrove::ClassLoader.create( {
+      
+      :module => 'Adaptor',
+      :class  => adaptor
+      
+    } ).new( @my_config[ :adaptor ], logger )
     
     
     #
@@ -158,9 +160,14 @@ module Daemon class Base
     #  CollectionOfClients ---> is the handler passed into listen()                       
     #
 
-    @logger.info "Initialize collection: #{handler}.new( config_hash, daemon_name, logger )"
-    eval "require 'handler/#{handler.underscore}'"
-    @handler = Handler.const_get(handler).new( config_hash, daemon_name, logger )
+    @logger.info "Initialize instance: Handler::#{handler}.new( config_hash, '#{daemon_name}', logger )"
+    
+    @handler = LanGrove::ClassLoader.create( {
+      
+      :module => 'Handler',
+      :class  => handler
+      
+    } ).new( @config, @daemon_name, @logger )
     
  
   end

data/lib/langrove/ext.rb

@@ -0,0 +1,7 @@
+module Langrove; end
+require 'langrove/ext/class_loader'
+require 'langrove/ext/config_item'
+require 'langrove/ext/config_loader'
+require 'langrove/ext/fake_logger'
+require 'langrove/ext/persistable'
+require 'langrove/ext/string'

data/lib/langrove/ext/class_loader.rb

@@ -0,0 +1,146 @@
+require 'langrove/ext/string'
+module LanGrove
+  
+  class ClassLoaderException < Exception; end
+  
+  class ClassLoader
+  
+    def self.create( class_config, logger = nil )
+      
+      logger.info( "#{self} is loading Class with #{class_config.inspect}" ) unless logger.nil?
+      
+      #
+      # When <config> = {
+      # 
+      #   :module => 'ModuleName'
+      #   :class  => 'ClassName'
+      #
+      # }
+      #
+      # Then this will return the constantized
+      # definition instance of ClassName as 
+      # loaded from the F1RST found .rb file
+      # according to:
+      # 
+      # - lib/module_name/class_name.rb
+      # - langrove/module_name/class_name.rb
+      #
+      # Which then facilitates the following
+      # construct:
+      #
+      # planet = ClassLoader.create(
+      # 
+      #    :module => 'Planet',
+      #    :class  => 'Mercury'
+      #
+      # ).new( *initializer_parameters )
+      #
+      
+      raise ClassLoaderException.new( 
+      
+        "class_config requires :module" 
+        
+      ) unless class_config.has_key? :module
+      
+      raise ClassLoaderException.new( 
+      
+        "class_config requires :class" 
+        
+      ) unless class_config.has_key? :class
+      
+      
+      module_name = class_config[:module]
+      class_name  = class_config[:class]
+      
+      
+      #
+      # SIGNIFICANT DECISION
+      #
+      # - Late binding to the extent of also calling
+      #   to require the actual class.rb file could 
+      #   potentially be avoided by
+      # 
+      #    << using this layer in the abstraction >>
+      #
+      #   to do the necessary requiring for the specific
+      #   daemon being spawned.
+      #
+      # - Obviously there are downsides to eval...
+      #
+      # - But there are upsides to having this layer
+      #   totally aliteral - it leaves the window open
+      #   to the later posibility of collecting the class
+      #   definition itself from across the network. 
+      #
+      # 
+      #   Which was the cental purpose behind daemons
+      #   by configuration in the first place.
+      #
+      #   Taking latebinding to a whole new level...
+      #
+      
+      
+      #
+      # First try local implementation root
+      #
+      
+      exception = nil
+      
+      location = nil
+      
+      begin
+        
+        location = "#{module_name.underscore}/#{class_name.underscore}"
+        
+        eval "require '#{location}'"
+        
+        return Object.const_get( module_name ).const_get( class_name )
+        
+      rescue LoadError => e
+        
+        exception = e
+        
+        logger.error "Missing class definition in lib/#{location}.rb" unless logger.nil?
+        
+      #rescue Exception => e 
+      #  
+      #  #
+      #  # Incase of more... (discovery phase)
+      #  #
+      #
+      
+        
+      end
+      
+      #
+      # Fall back to langrove gem lib
+      #
+      
+      begin
+        
+        location = "langrove/#{module_name.underscore}/#{class_name.underscore}"
+        
+        eval "require '#{location}'"
+        
+        return LanGrove.const_get( module_name ).const_get( class_name )
+        
+      rescue Exception => e
+        
+        #
+        # Raise from the original exception to
+        # inform the local implementation
+        # it is missing a module/class .rb
+        # "no such file 'module/class"
+        #
+        # And not confuse the issue by raising
+        # "no such file 'langrove/module/class"
+        #
+        raise ClassLoaderException.new "#{exception.message}.rb"
+        
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/{ext → langrove/ext}/config_item.rb

@@ -1,8 +1,7 @@
-class ConfigException < Exception
-  
-end
 
-class ConfigItem
+module LanGrove class ConfigException < Exception; end; end
+
+module LanGrove class ConfigItem
 
   def self.get(config_hash, key_array, mandatory = true)
     
@@ -32,4 +31,4 @@ class ConfigItem
     
   end
 
-end
+end; end

data/lib/{ext → langrove/ext}/config_loader.rb

@@ -2,7 +2,7 @@
 
 require 'yaml'
 
-class ConfigLoader
+module LanGrove class ConfigLoader
   
   def self.yaml( file )
     
@@ -13,4 +13,4 @@ class ConfigLoader
       
   end
   
-end
+end; end

data/lib/langrove/ext/fake_logger.rb

@@ -0,0 +1,8 @@
+module LanGrove class FakeLogger
+  def initialize( parameter = :noisey )
+    @parameter = parameter
+  end
+  def method_missing( symbol, *args, &block )
+    puts "#{symbol}: #{args}" unless @parameter == :silent
+  end
+end; end

data/lib/{ext → langrove/ext}/persistable.rb

@@ -3,7 +3,7 @@ require 'yaml'
 
 # require 'updated_puppet_state'
 
-class Persistable
+module LanGrove class Persistable
   
   def initialize( notifies = [] )
     
@@ -100,4 +100,4 @@ class Persistable
       
     end
   end
-end
+end; end

data/lib/langrove/handler/base.rb

@@ -0,0 +1,2 @@
+module LanGrove::Handler; end
+require 'langrove/handler_base'

data/lib/{handler_base.rb → langrove/handler_base.rb}

@@ -1,7 +1,6 @@
-require 'protocol/base'
-require 'ext/string'
+require 'langrove'
 
-module Handler class Base
+module LanGrove::Handler class Base
   
   #
   # One handler exists in the daemon with
@@ -11,8 +10,19 @@ module Handler class Base
   #
   # In this:
   # 
+  # but, NOT YET
+  #
   attr_writer :clients
   
+  #
+  # The protocol defininition per the config is
+  # loaded by this Handler, but not instanciated.
+  # 
+  # This definition is then exposed,
+  # 
+  # By this:
+  #
+  attr_reader :protocol
   
   def daemon_start
   
@@ -59,15 +69,16 @@ module Handler class Base
   def initialize( config_hash, daemon_name, logger )
     
     @config        = config_hash
-    @my_config     = @config['daemons'][daemon_name]['handler']
     @daemon_name   = daemon_name
     @logger        = logger
     
+    @my_config     = @config[ :daemons ][ @daemon_name ][ :handler ]
+    
     protocol       = 'Base'
     
-    if @my_config.has_key? 'protocol' then
+    if @my_config.has_key? :protocol then
       
-      protocol = @my_config['protocol']
+      protocol = @my_config[ :protocol ]
       
     end
     
@@ -116,10 +127,15 @@ module Handler class Base
     #       adapter in use.
     #
 
-    @logger.info "Initialize protocol: Protocol::#{protocol}.new( logger )"
-    eval "require 'protocol/#{protocol.underscore}'"
-    @protocol = Protocol.const_get(protocol).new( logger )
+    @logger.info "Load definition: Protocol::#{protocol}"
     
+    @protocol = LanGrove::ClassLoader.create( {
+      
+      :module => 'Protocol', 
+      :class  => protocol
+      
+    } )
+
   end
   
 end; end

data/lib/langrove/protocol/base.rb

@@ -0,0 +1,2 @@
+module LanGrove::Protocol; end
+require 'langrove/protocol_base'

data/lib/langrove/protocol/syslog.rb

@@ -0,0 +1,32 @@
+require 'date'
+require 'langrove'
+
+module LanGrove::Protocol class Syslog
+  
+  def decode( message )
+    
+    #
+    # eg:
+    # 
+    # <NN>Apr  4 11:00:06 fw.school1950.gp-online.net puppet[29206]: Autoloaded file blahblahblah
+    #
+ 
+    pass     = message.split('>')[1].split()
+    time     = DateTime.parse(pass[0..2].join(' '))
+    hostname = pass[3]
+    message  = pass[4..-1].join(' ').split(': ',2)
+
+    hostname.gsub!( /vlan[\d]*\./, '')
+    
+    @decoded = {
+      :timestamp => time,         # DateTime object
+      :hostname  => hostname,     # without prepended vlanN
+      :tag       => message[0],   # includes[PID]
+      :event     => message[1]    # everything after the colon after the tag
+    }
+    
+    return @decoded
+    
+  end
+  
+end; end

data/lib/langrove/protocol_base.rb

@@ -0,0 +1,32 @@
+require 'langrove'
+
+module LanGrove::Protocol 
+  
+  class Base
+    
+    def initialize( place_mark_protocol_config, logger )
+      
+      @logger = logger
+      
+    end
+    
+    def decode( data )
+      
+      #
+      # OVERRIDE 
+      #
+      # To decode the data ahead of passing it
+      # into the <Handler>.receive() function.
+      #
+      
+      {
+        
+        :data => data
+        
+      }
+      
+    end
+    
+  end
+  
+end