em-langrove 0.0.4.5

data/lib/langrove/ext/persistable.rb

@@ -0,0 +1,103 @@
+require 'resque'
+require 'yaml'
+
+# require 'updated_puppet_state'
+
+module LanGrove class Persistable
+  
+  def initialize( notifies = [] )
+    
+    @notifies = notifies
+    
+    @notifies.each do |worker|
+      
+      Object.const_set( 
+      
+        worker.camelize, Class.new 
+        
+      ) ### ??unless defined already??
+      
+    end
+    
+  end
+  
+  def load_hash( hash_instance, from_file )
+    #
+    # <hash_instance> as String (name of) variable storing the Hash
+    #
+    
+    @logger.debug "loading from: #{from_file}" if @logger
+    
+    #
+    # get the instance variable (late bind)
+    #
+    hash = self.instance_variable_get( hash_instance.to_sym )
+    hash ||= {}
+    
+    begin
+      
+      #
+      # load file contents, merge into hash and 
+      # store it at the instance variable
+      #
+      persisted = YAML.load_file( from_file )
+      hash.merge!( persisted ) if persisted.is_a?( Hash )
+      self.instance_variable_set( hash_instance.to_sym, hash )
+      
+      #
+      # set flag to 'already in storage'
+      #
+      @stored = true
+    
+    rescue Exception => e
+      @logger.error "FAILED loading from #{from_file} #{e}" if @logger
+      
+    end
+  end
+  
+  
+  def store_hash( hash_instance, to_file )
+    #
+    # <hash_instance> as String (name of) variable storing the Hash
+    #
+    
+    if @stored != nil && @stored
+      
+      @logger.debug "storing to: #{to_file} skipped - no change"
+      return
+      
+    end
+    
+    @logger.debug "storing to: #{to_file}"
+    
+    #
+    # get the instance variable (late bind)
+    #
+    hash = self.instance_variable_get( hash_instance.to_sym )
+    
+    begin
+    
+      File.open(to_file, 'w') do |f|
+  
+        YAML::dump( hash, f )
+        @stored = true
+        
+      end
+      
+      #@notifies.each do |worker|
+      #
+      #  Resque.enqueue(
+      #  
+      #    Object.const_get( worker.camelize ), to_file
+      #    
+      #  )
+      #  
+      #end
+    
+    rescue Exception => e
+      @logger.error "FAILED storing to: #{to_file} #{e}" if @logger
+      @stored = false
+      
+    end
+  end
+end; end

data/lib/langrove/ext/string.rb

@@ -0,0 +1,35 @@
+# extend ruby String class 
+
+class String
+  #
+  # from the rails inflector
+  # (de-camelize)
+  #
+  # ie. CamelThing becomes camel_thing
+  #
+  def underscore
+    gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+  
+#
+# unless already defined
+#  
+end unless String.method_defined?(:underscore)
+
+class String
+  #
+  # from the rails inflector
+  # (camelize)
+  #
+  # ie. CamelThing becomes camel_thing
+  #
+  def camelize(first_letter_in_uppercase = :upper)
+    s = gsub(/\/(.?)/){|x| "::#{x[-1..-1].upcase unless x == '/'}"}.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
+    s[0...1] = s[0...1].downcase unless first_letter_in_uppercase == :upper
+    s
+  end
+end unless String.method_defined?(:camelize)

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/handler/base.rb

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

data/lib/langrove/handler_base.rb

@@ -0,0 +1,148 @@
+require 'langrove'
+
+module LanGrove::Handler class Base
+  
+  #
+  # One handler exists in the daemon with
+  # the primary purpose of housing through
+  # an addressable Hash the set of connected
+  # clients,
+  #
+  # 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 start_daemon
+  
+    #
+    # OVERRIDE 
+    #
+    # To prepare the Handler in any necessary 
+    # ways before the thread is handed over to 
+    # the socket listener, (or thing),
+    #
+    # The daemon has just started.
+    #
+
+  end
+  
+  def stop_daemon
+    
+    #
+    # OVERRIDE 
+    # 
+    # To perfom any necessties before process
+    # termination,
+    #
+    # The daemon has received a signal to stop.
+    #
+    
+  end
+  
+  def periodic
+    
+    #
+    # Call periodic on all clients
+    # in the collection
+    #
+    
+    @clients.each do |key, value|
+      
+      if value == 1 then
+        
+        key.periodic
+        
+        next
+        
+      end
+      
+      value.periodic
+      
+    end
+    
+  end
+  
+  def connect( client )
+    
+    #
+    # A client has connected at the Adaptor
+    # 
+    # It should be inserted into the collection
+    # of clients maintained here. 
+    #
+    @logger.debug "Client::#{client} registers with Handler#{self}"
+    
+    if client.respond_to?( :unique_key ) then
+      
+      @clients[ client.unique_key ] = client
+      return
+      
+    end
+    
+    @clients[ client ] = 1
+    
+  end
+  
+  def disconnect( client )
+    
+    #
+    # A client has disconnected
+    # 
+    # It should be removed from the collection.
+    #
+    
+    #
+    # TODO: There will likely be a callback
+    #       in the EM::Connection superclass
+    #       that can be used here.
+    # 
+    #       Client::Base extends EM::Connection
+    # 
+    
+    @logger.info( "TODO: implement #{self.classname}disconnect()" )
+    
+  end
+  
+  def initialize( config_hash, daemon_name, logger )
+    
+    @config        = config_hash
+    @daemon_name   = daemon_name
+    @logger        = logger
+    
+    @clients = {}
+    
+    begin
+    
+      @logger.info "TODO: fall back to default Handler::Base"
+      
+      @my_config     = @config[ :daemons ][ @daemon_name ][ :handler ]
+
+    rescue
+      
+      error = "Missing config item for daemon: #{@daemon_name}" 
+      
+      @logger.error "EXIT: #{error}"
+      
+      raise LanGrove::DaemonConfigException.new( 
+      
+        "Missing config item for daemon: #{@daemon_name}" 
+        
+      )
+      
+    end
+    
+  end
+  
+end; end

data/lib/langrove/job/base.rb

@@ -0,0 +1 @@
+require 'langrove/job_base'

data/lib/langrove/job_base.rb

@@ -0,0 +1,24 @@
+#
+# no spec 
+#
+module LanGrove
+  
+  module Job
+    
+    class Base
+      
+      def initialize( config, queue_name, logger)
+        
+        logger.info ( "starting unimplemented queuer") unless logger.nil?
+        
+      end
+   
+      def method_missing( symbol, *args, &block )
+        puts "#{self}.#{symbol}( #{args} )" unless @parameter == :silent
+      end
+      
+    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

data/lib/langrove/version.rb

@@ -0,0 +1,3 @@
+module LanGrove
+  Version = VERSION = '0.0.4.5'
+end

data/lib/langrove.rb

@@ -0,0 +1 @@
+require 'langrove/_base'

data/spec/functional/daemon/datagram_spec.rb

@@ -0,0 +1,121 @@
+require 'langrove'
+
+describe 'A daemon' do
+  
+  #
+  # HINT: tail -f functional/log/development.log 
+  #       
+  #       To see this test in action.
+  #
+
+  #
+  # Use the demos in ./functional dir for integration tests
+  # 
+  # Note: This uses the init.d style start|stop functionality
+  #       as provided by DaemonKit
+  #   
+  #       Therefore, bugs that may exist in DaemonKit could be 
+  #       exposed here.
+  # 
+  #       I have not directly ovbserved any thus far.
+  # 
+
+  before :all do
+    
+    @daemon_name = 'datagram'
+    
+    #
+    # cd - to get the rvm environment up
+    # 
+    @daemon_root = File.expand_path("../../../../functional",  __FILE__)
+    @daemon_stub = "./bin/#{@daemon_name}"
+    
+    #
+    # Daemon is configured with Handler::SocketToFile
+    # 
+    # The test sends a message to the daemon and then
+    # verifies the presence of the file.
+    #
+    @file = "#{@daemon_root}/tmp/datagram.txt"
+    @mesg = "Hello Datagram To File"
+    
+    #
+    # remove the file ahead of testing
+    #
+    `rm -f #{@file}`
+    
+    #
+    # call shell to start daemon
+    #
+    
+    `cd #{@daemon_root} && #{@daemon_stub} start`
+    
+    #
+    # give it a moment to start
+    # 
+    sleep 1
+    
+  end
+  
+  after :all do
+    
+    #
+    # call shell to stop daemon
+    #
+    `cd #{@daemon_root} && #{@daemon_stub} stop`
+    
+  end
+  
+  context 'running a server' do 
+    
+    it 'receives a message' do
+
+      require "eventmachine"
+      
+      class Sender < EventMachine::Connection
+      
+        def send( data )
+      
+          send_datagram( data, '127.0.0.1', 12701 )
+      
+        end
+      
+      end
+      
+      EM.run do
+      
+        sender = nil
+      
+        EM.add_periodic_timer(1) do
+      
+            sender.send( "#{@file}|#{@mesg}" )
+            EM.stop
+      
+        end
+      
+        EM.open_datagram_socket "127.0.0.1", 0, Sender do |connected|
+      
+          sender = connected
+      
+        end
+      
+      end
+      
+      #
+      # Give the daemon a moment to write the file
+      #
+      sleep 1
+      
+      File.file?( @file ).should == true
+      
+      File.open( @file, 'r' ).each_line do |line|
+      
+        line.should == @mesg
+      
+      end
+
+    end
+    
+  end
+
+end

data/spec/langrove/adaptor_base_spec.rb

@@ -0,0 +1,63 @@
+require 'langrove'
+
+describe LanGrove::Adaptor::Base do
+  
+  before :each do
+    
+    @logger = LanGrove::FakeLogger.new
+    
+    @extendhandler =  'ExtendedHandler'
+    
+    @config = {
+      
+      :iface     => '111.111.111.111',
+      
+      :port      => 11111,
+      
+      :connector => @extendhandler,
+      
+      :transport => 'udp'
+    }
+    
+  end
+  
+  
+  
+  it 'assigns the session layer protocol as udp' do
+    
+    subject = LanGrove::Adaptor::Base.new( @config, @logger )
+    subject.instance_variable_get( :@em_server_call ).should == :open_datagram_socket
+    
+  end
+  
+  it 'assigns the session layer protocol as tcp by default' do
+    
+    @config.delete :transport
+    
+    subject = LanGrove::Adaptor::Base.new( @config, @logger )
+    
+    subject.instance_variable_get( :@em_server_call ).should == :start_server
+    
+  end
+  
+  pending 'may need to override default connection handler' do
+    
+    LanGrove::Adaptor.const_set( @extendhandler, Class.new )
+    
+    subject = LanGrove::Adaptor::Base.new( @config, @logger )
+    connector = subject.instance_variable_get( :@handler )
+    
+    connector.should == LanGrove::Adaptor.const_get( @extendhandler )
+    
+  end
+  
+  pending 'assigns defaults' do
+    
+    subject = LanGrove::Adaptor::Base.new( {}, @logger )
+    connector = subject.instance_variable_get( :@connector )
+    
+    connector.should  == LanGrove::Adaptor::SocketHandler
+    
+  end
+  
+end

data/spec/langrove/client/datagram_spec.rb

@@ -0,0 +1 @@
+require 'langrove/client/datagram'

data/spec/langrove/client_base_spec.rb

@@ -0,0 +1,5 @@
+require 'langrove'
+
+describe LanGrove::Client::Base do
+    
+end