LanGrove 0.0.1

data/lib/daemon_base.rb

@@ -0,0 +1,168 @@
+require 'eventmachine'
+
+require 'ext/string'
+
+class DaemonConfigException < Exception; end
+
+module Daemon class Base
+  
+  def listen
+    
+    #
+    # Handler, the CollectionOfClients,
+    # is passed through the adaptor to
+    # be assigned to the attaching sockets.
+    #
+    
+    @adaptor.listen( @handler )
+    
+  end
+  
+  def stop_daemon
+    
+    #
+    # Handle stopping daemon
+    #
+    @logger.info "#{self} received stop_daemon"
+    @handler.stop_daemon
+    
+  end
+  
+  def reload_daemon
+    
+    #
+    # TODO: Handle reloading daemon properly
+    # 
+    # [ !!complexities abound around reloading config!! ]
+    #
+    
+    @logger.info "#{self} received reload_daemon"
+    @handler.reload_daemon
+    
+  end
+  
+  def schedule
+    
+    EM::add_periodic_timer( @my_config['periodic'] ) do
+      
+      @logger.info "#{self} Scheduling periodic ...TODO..."
+      
+      #
+      # TODO: This can be a lot more usefull than
+      #       then one ticker to one function call
+      #
+      
+      @handler.periodic
+      
+    end if @my_config.has_key? 'periodic'
+    
+  end
+  
+  def run
+    
+    EventMachine::run do
+      
+      # 
+      # https://github.com/eventmachine/eventmachine/wiki/Protocol-Implementations
+      # 
+      
+      schedule
+      
+      listen if @server
+      
+    end
+    
+  end
+  
+  def initialize( config_hash, daemon_name, logger )
+    
+    @config      = config_hash
+    @daemon_name = daemon_name
+    @logger      = logger
+    @server      = true
+    
+    #
+    # A network connection.
+    #
+    @adaptor = nil
+    
+    #
+    # A handler to direct the traffic.
+    #
+    @handler = nil
+    
+    
+    begin
+      
+      @logger.info "Starting daemon: #{@daemon_name}"
+      
+    rescue
+      
+      #
+      # you shall not pass
+      #
+      raise DaemonConfigException.new( "Requires a logger" )
+      
+    end
+
+    begin
+
+      @my_config = config_hash['daemons'][daemon_name]
+      
+      @server    = @my_config['listen'] if @my_config.has_key? 'listen'
+      
+      adaptor    = @my_config['adaptor']['connection']   
+      
+      handler    = @my_config['handler']['collection']
+         
+    rescue
+      
+      error = "Missing config item for daemon: #{daemon_name}" 
+      
+      @logger.error "EXIT: #{error}"
+      
+      raise DaemonConfigException.new( 
+      
+        "Missing config item for daemon: #{daemon_name}" 
+        
+      )
+        
+    end
+    
+    #
+    # initialize the connection adaptor specified in config
+    # 
+    # daemons:
+    #   name_of_daemon:
+    #     adaptor:
+    #       connection: TcpServer  <----------
+    #     handler:
+    #       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 )
+    
+    
+    #
+    # bind to the handler collection specified in config
+    # 
+    # daemons:
+    #   name_of_daemon:
+    #     adaptor:
+    #       connection: TcpServer
+    #     handler:
+    #       collection: CollectionOfClients  <---------- 
+    #    
+    #  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 )
+    
+ 
+  end
+  
+end; end

data/lib/ext/config_item.rb

@@ -0,0 +1,35 @@
+class ConfigException < Exception
+  
+end
+
+class ConfigItem
+
+  def self.get(config_hash, key_array, mandatory = true)
+    
+    # raise ConfigException.new("match")
+    
+    hash = config_hash
+    
+    key_array.each do |key|
+      
+      if mandatory != false then
+        # raises a config exception if the item isnt present
+        raise ConfigException.new("Missing config item '#{key}'") unless hash.has_key?(key)
+      
+        # raises a config exception if the nested item isnt present NEITHER NOT
+       # raise ConfigException.new("Missing config item '#{key}'") if hash[key].empty?
+      
+        hash = hash[key]
+      
+        # raises a config exception if the key isnt present BLANK NEITHER
+        raise ConfigException.new("Missing config item '#{key}'") if hash == "" 
+      
+      end
+      
+    end
+    
+    return hash
+    
+  end
+
+end

data/lib/ext/config_loader.rb

@@ -0,0 +1,16 @@
+# TODO: spec
+
+require 'yaml'
+
+class ConfigLoader
+  
+  def self.yaml( file )
+    
+    # no rescue block
+    # daemon fails on missing config file
+    
+    YAML.load_file( file )
+      
+  end
+  
+end

data/lib/ext/persistable.rb

@@ -0,0 +1,103 @@
+require 'resque'
+require 'yaml'
+
+# require 'updated_puppet_state'
+
+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

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

@@ -0,0 +1 @@
+require 'handler_base'

data/lib/handler/socket_to_file.rb

@@ -0,0 +1,30 @@
+#
+# Mainly to facilitate functional tests
+#
+
+require 'handler/base'
+
+module Handler
+  
+  class SocketToFile < Base
+    
+    def message( data )
+      
+      @logger.debug( "Received: #{data}" )
+      
+      filename     = data.split('|')[0]
+      filecontents = data.split('|',2)[1]
+      
+      File.open( filename, 'w' ) do |f|
+        
+        f.write( filecontents )
+        
+      end
+      
+      @logger.debug "Wrote file: #{filename}"
+      
+    end
+    
+  end
+  
+end

data/lib/handler_base.rb

@@ -0,0 +1,125 @@
+require 'protocol/base'
+require 'ext/string'
+
+module 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:
+  # 
+  attr_writer :clients
+  
+  
+  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
+    @my_config     = @config['daemons'][daemon_name]['handler']
+    @daemon_name   = daemon_name
+    @logger        = logger
+    
+    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 "Initialize protocol: Protocol::#{protocol}.new( logger )"
+    eval "require 'protocol/#{protocol.underscore}'"
+    @protocol = Protocol.const_get(protocol).new( logger )
+    
+  end
+  
+end; end

data/lib/jobs/jobs.rb

@@ -0,0 +1 @@
+require 'jobs/updated_puppet_state'

data/lib/jobs/updated_puppet_state.rb

@@ -0,0 +1,17 @@
+class UpdatedPuppetState
+  
+  # 
+  # Name of the queue these jobs 
+  # are waiting in.
+  #
+  @queue = :updated_puppet_state
+  
+  def self.perform( id, parameters )
+
+    #
+    # Process for changes.
+    #
+      
+  end
+  
+end

data/lib/protocol_base.rb

@@ -0,0 +1,5 @@
+module Protocol class Base
+  
+  
+  
+end; end

data/libexec/daemon.rb

@@ -0,0 +1,57 @@
+require 'ext/string'
+require 'ext/config_loader'
+
+CLASS_NAME  = DAEMON_NAME.camelize
+CONFIG_FILE = "#{DAEMON_ROOT}/config/daemons.yml"
+CONFIG_HASH = ConfigLoader.yaml( CONFIG_FILE )
+
+daemon = nil
+
+DaemonKit::Application.running! do |config|
+  
+  DaemonKit.logger.info "Spawing #{DAEMON_NAME} at pidfile #{config.pid_file}"
+
+  #
+  # setup signal traps 
+  #
+  config.trap( 'TERM', Proc.new { 
+    
+    #
+    # Handle stop signal from os
+    #
+    daemon.stop_daemon
+    
+  } )
+  
+  config.trap( 'INT', Proc.new { 
+    
+    #
+    # Handle ^C from user (eg. developer) running un-daemonized 
+    #
+    daemon.stop_daemon
+    
+  } )
+  
+  #
+  # Have not yet '''suitably''' succeeded in getting a sigHUP
+  # into a daemon with the monit/daemonkit combo yet....
+  #
+  # grumbles...
+  #
+  config.trap( 'HUP', Proc.new { 
+    
+    #
+    # Handle reload 
+    #
+    daemon.reload_daemon 
+    
+  } )
+  
+  #
+  # Latebind the daemon class
+  #
+  require "daemon/#{DAEMON_NAME}"
+  daemon = Object.const_get( CLASS_NAME ).new( CONFIG_HASH, DAEMON_NAME, DaemonKit.logger )
+  daemon.run
+  
+end

data/spec/adaptor/datagram_spec.rb

@@ -0,0 +1,6 @@
+require 'adaptor/datagram'
+
+describe Adaptor::Datagram do
+  
+  
+end

data/spec/adaptor/socket_handler_spec.rb

@@ -0,0 +1,5 @@
+require 'adaptor/socket_handler'
+
+describe Adaptor::SocketHandler do
+    
+end

data/spec/adaptor_base_spec.rb

@@ -0,0 +1,45 @@
+require 'adaptor/base'
+
+require 'ext/fake_logger'
+
+describe Adaptor::Base do
+  
+  before :each do
+    
+    @logger = FakeLogger.new
+    
+    @extendhandler =  'ExtendedHandler'
+    
+    @config = {
+      
+      'iface'     => '111.111.111.111',
+      
+      'port'      => 11111,
+      
+      'connector' => @extendhandler
+      
+    }
+    
+  end
+  
+  pending 'may need to override default connection handler' do
+    
+    Adaptor.const_set( @extendhandler, Class.new )
+    
+    subject = Adaptor::Base.new( @config, @logger )
+    connector = subject.instance_variable_get( :@handler )
+    
+    connector.should be_a( Adaptor.const_get( @extendhandler ) )
+    
+  end
+  
+  it 'assigns defaults' do
+    
+    subject = Adaptor::Base.new( {}, @logger )
+    connector = subject.instance_variable_get( :@connector )
+    
+    connector.should  == Adaptor::SocketHandler
+    
+  end
+  
+end

data/spec/client_base_spec.rb

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