langrove 0.0.2

data/lib/langrove/handler_base.rb

@@ -0,0 +1,141 @@
+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 daemon_start
+  
+    #
+    # 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 daemon_stop
+    
+    #
+    # OVERRIDE 
+    # 
+    # To perfom any necessties before process
+    # termination,
+    #
+    # The daemon has received a signal to stop.
+    #
+    
+  end
+  
+  def periodic
+    
+    #
+    # TODO: There shall not only be one
+    # 
+    #       Changes are pending.
+    #
+    # OVERRIDE 
+    #
+    # To perform activities at the interval
+    # defined in the config.
+    # 
+    
+  end
+  
+  def initialize( config_hash, daemon_name, logger )
+    
+    @config        = config_hash
+    @daemon_name   = daemon_name
+    @logger        = logger
+    
+    @my_config     = @config[ :daemons ][ @daemon_name ][ :handler ]
+    
+    protocol       = 'Base'
+    
+    if @my_config.has_key? :protocol then
+      
+      protocol = @my_config[ :protocol ]
+      
+    end
+    
+    #
+    # SIGNIFICANT DECISION
+    #
+    # - (currently) - There is one >>Instance<< of the protocol
+    #
+    # - It is an object ( has .new )
+    #
+    # - All attached socket traffic is directed through it for de/encode
+    # - 
+    # - ?.. ie. multiple TcpClients all routing through the same object..?
+    # - 
+    # - THIS MAY NEED TO CHANGE (thinks & thinks & thinks)
+    # 
+    # - (Thinks) - It may move to the Client::Base so that each attached
+    #              client is paired with its own instance of the protocol.
+    # 
+    # - For now it wil be instanciated here and binded to each client at 
+    #   connect - to be shared for the decoding. That should be fine for
+    #   as long as the protocol itself stores no state and is simply a
+    #   code path (Still, thinks & ... 
+    #  
+    
+    #
+    # initialize the protocol specified in config
+    # 
+    # daemons:
+    #
+    #   viking-invasion-early-warning-net_CoreHub_co_uk-D4RK1:
+    #
+    #     adaptor:
+    #       connection: TriFocalOcularRotisserie
+    #       lightsource: 
+    #         type: Fire
+    #         fuel: Peat
+    #
+    #     handler:
+    #       collection: ScottishCoastalVillages
+    #       protocol: MedievalLanternMorse <----------
+    #
+    # Note: This is the application layer protocol
+    #       and is therefore entirely agnostic of
+    #       transport and disassociated from the 
+    #       adapter in use.
+    #
+
+    @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

data/lib/langrove/version.rb

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

data/lib/langrove.rb

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

data/spec/functional/daemon/datagram_spec.rb

@@ -0,0 +1,115 @@
+require 'langrove'
+
+describe 'A daemon' do
+
+  #
+  # 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/datagram_spec.rb

@@ -0,0 +1,6 @@
+require 'langrove'
+
+describe LanGrove::Adaptor::Datagram do
+  
+  
+end

data/spec/langrove/adaptor_base_spec.rb

@@ -0,0 +1,48 @@
+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,
+      
+      :client => {
+        
+       :class => 'Base'
+       
+      }
+    }
+    
+  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 be_a( 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

data/spec/langrove/daemon_base_spec.rb

@@ -0,0 +1,101 @@
+require 'langrove'
+
+describe LanGrove::Daemon::Base do
+  
+  before :each do
+    
+    @logger = LanGrove::FakeLogger.new  :silent
+    
+    @daemon_name = 'pretend_daemon'
+    
+    @adaptor_class = 'Base'
+    @collection_class = 'Base'
+    @client_class = 'Base'
+    
+    @config = {
+      
+      :daemons => {
+        
+        @daemon_name => {
+          
+          :server => false,
+          
+          :adaptor => {
+            
+            :connection => @adaptor_class,
+            
+            :client => {
+              
+              :class => @client_class
+              
+            }
+          },
+          
+          :handler => {
+            
+            :collection => @collection_class
+            
+          }
+        }
+      }
+    }
+    
+  end
+  
+  subject do
+    
+    LanGrove::Daemon::Base.new( @config, @daemon_name, @logger )
+    
+  end
+  
+  it 'requires a logger' do
+    
+    expect {
+    
+      LanGrove::Daemon::Base.new( @config, @daemon_name, nil )
+    
+    }.to raise_error( LanGrove::DaemonConfigException, /Requires a logger/ )
+    
+  end
+  
+  it 'requires a configuration' do
+    
+    expect {
+      
+      LanGrove::Daemon::Base.new( {}, @daemon_name, @logger )
+      
+    }.to raise_error( LanGrove::DaemonConfigException, /Missing config item/ )
+    
+  end
+  
+  it 'latebinds an adaptor by config' do
+    
+    adaptor = subject.instance_variable_get( :@adaptor )
+    
+    adaptor.should be_a( LanGrove::Adaptor.const_get( @adaptor_class ) )
+    
+  end
+  
+  it 'latebinds a handler by config' do
+    
+    handler = subject.instance_variable_get( :@handler )
+    
+    handler.should be_a( LanGrove::Handler.const_get( @collection_class ) )
+    
+  end
+  
+  it 'it schedules periodics' 
+  
+  it 'when run, it calls to listen if server is true' do
+    
+    expect {
+      
+      subject.instance_variable_set( :@server, true )
+      
+      subject.run
+      
+    }.to raise_error( LanGrove::DaemonConfigException, "NotYetExtended: undefined listen()" )
+    
+  end
+
+end

data/spec/langrove/ext/class_loader_spec.rb

@@ -0,0 +1,83 @@
+require 'langrove/ext/class_loader'
+require 'langrove/ext/fake_logger'
+
+describe LanGrove::ClassLoader do
+  
+  before :all do
+    
+    @logger = LanGrove::FakeLogger.new :silent
+    
+  end
+  
+  it 'raises on missing class definition file' do
+    
+    expect {
+    
+      LanGrove::ClassLoader.create( {
+     
+        :module => 'Protocol',
+        :class => 'MedievalLanternMorse' 
+      
+        }, @logger )
+    
+    }.to raise_error( 
+    
+      LanGrove::ClassLoaderException, 
+      
+      "no such file to load -- protocol/medieval_lantern_morse.rb"
+    
+    )
+  end
+  
+  it 'raises on missing ModuleName' do
+    
+    expect {
+      
+      LanGrove::ClassLoader.create( {
+
+       :class => 'MedievalLanternMorse' 
+
+      }, @logger )
+      
+    }.to raise_error( 
+    
+      LanGrove::ClassLoaderException, /:module/ 
+      
+    )
+    
+  end
+  
+  it 'raises on missing ClassName' do
+    
+    expect {
+      
+      LanGrove::ClassLoader.create( {
+
+       :module => 'Protocol'
+
+      }, @logger )
+      
+    }.to raise_error( 
+    
+      LanGrove::ClassLoaderException, /:class/ 
+      
+    )
+    
+  end
+  
+  it 'returns a constantized class definition' do
+    
+    test = LanGrove::ClassLoader.create( {
+   
+      :module => 'Protocol',
+      :class => 'Base' 
+    
+    }, @logger ).new( nil, @logger )
+    
+    test.should be_a( LanGrove::Protocol::Base )
+    
+  end
+  
+  it 'also works on local implementation'
+  
+end

data/spec/langrove/ext/config_item_spec.rb

@@ -0,0 +1,81 @@
+require 'langrove/ext'
+
+describe LanGrove::ConfigItem do
+  
+  before :each do
+    @config_hash = {
+      'root' => "3",  
+      'BLANK' => "",
+      :daemons => {
+        'puppet_log' => {
+          :handler => {
+            :collection   => 'SyslogStateMachines'            
+          }
+        }
+      }
+    }
+  end
+  
+  it 'accesses config items' do
+    LanGrove::ConfigItem.get(@config_hash, ['root']).should == '3'
+  end
+  
+  it 'accesses nested config items' do
+    LanGrove::ConfigItem.get(@config_hash, 
+    
+      [:daemons , 'puppet_log', :handler, :collection]
+    
+    ).should == 'SyslogStateMachines'
+  end
+  
+  it 'raises a config exception if the key isnt present' do
+    
+    expect {
+      
+      LanGrove::ConfigItem.get(@config_hash, ['NOT'])
+      
+    }.to raise_error( LanGrove::ConfigException, /Missing config item 'NOT'/ )
+    
+  end
+  
+  it 'raises a config exception if the key isnt present' do
+    
+    expect {
+      
+      LanGrove::ConfigItem.get(@config_hash, ['BLANK'])
+      
+    }.to raise_error( LanGrove::ConfigException, /Missing config item 'BLANK'/ )
+    
+  end
+  
+  it 'raises a config exception if the value isnt present' do
+    
+    expect {
+      
+      LanGrove::ConfigItem.get(@config_hash, ['BLANK'], false)
+      
+    }.to_not raise_error( LanGrove::ConfigException, /Missing config item 'BLANK'/ )
+    
+  end
+  
+  it 'raises a config exception if the nested item isnt present' do
+    
+    expect {
+      
+      LanGrove::ConfigItem.get(@config_hash, [ :daemons, 'NEITHER', 'this'])
+      
+    }.to raise_error( LanGrove::ConfigException, /Missing config item 'NEITHER'/ )
+    
+  end
+  
+  it 'does not raise on not mandatory fields' do
+    
+    expect {
+      
+      LanGrove::ConfigItem.get(@config_hash, [ :daemons, 'NEITHER' ], false)
+      
+    }.to_not raise_error( LanGrove::ConfigException )
+    
+  end
+  
+end

data/spec/langrove/ext/config_loader_spec.rb

@@ -0,0 +1,5 @@
+require 'langrove/ext'
+
+describe LanGrove::ConfigLoader do
+    
+end