langrove 0.0.2

data/lib/langrove/client_base.rb

@@ -0,0 +1,114 @@
+require 'eventmachine'
+require 'langrove'
+
+module LanGrove
+  
+  module Client 
+    
+    class Base < EventMachine::Connection
+    
+      #
+      # Misnomer.
+      #
+      # 
+      # This is not the client,
+      # 
+      # 
+      # It is the server's perspective of the client,
+      # 
+      # These are generally stored in the daemon's
+      # handler collection, 
+      # 
+      # Which contains this and all similar clients,
+      # 
+      # Each bonded through the daemon's connection
+      # adaptor to the socket that couples them to 
+      # their actual client..
+      # 
+     
+      #
+      # The handler collection specified in config
+      # is bound to this attribute after connect.
+      #
+      attr_accessor :handler
+      attr_accessor :protocol
+      attr_accessor :config
+      
+      #
+      # Data arriving through the Adaptor is passed
+      # through the config assigned protocol and 
+      # then arrives here in whatever format the 
+      # <Protocol>.decode() method returned.
+      #
+      # 
+      def receive( decoded_data ) 
+
+        #
+        # OVERRIDE
+        # 
+        #   - Inbound data arrived at the adaptor
+        #
+        #   - It has passed through the protocol as
+        #     defined in config.
+        #
+        #     The protocol arranged the data into 
+        #     a Hash of: 
+        #  
+        #       - key and value pairs
+        # 
+        #       - key and more_complicated_thing pairs.
+        # 
+        #   - The decoded data was then passed into
+        #     this function.
+        #
+        # 
+
+      end
+
+      def receive_data( data )
+
+        #
+        # Note: The protocol currently lives on the Handler
+        #       
+        #       It MIG(  ...in progress...  )HT move,
+        # 
+        #       To a separate instance of the protocol object
+        #       residing in each Client::ClientType instance 
+        #       in the Handler::Base.client collection.
+        # 
+        #       Pending examining the logical barrier of having 
+        #       the Handler route to the Cleint per a key value 
+        #       extracted from the decoded data - as decoded by 
+        #       the client's instance of the protocol not yet 
+        #       accessable within the as yet undeterminable 
+        #       instance in the Handlers collection.
+        # 
+        #       Catch22(ish)
+        # 
+        #       But that was suitable as a pettern for the 
+        #       datagram server.
+        # 
+        #       Perhaps after implementing Adapter::TcpServer
+        # 
+        #       And gaining a more knowsome notion of the 
+        #       intricacies of the application layer, esp
+        #       ACKing and NAKing. 
+        # 
+        #       Then the possibilities of the Client::ClientType
+        #       being a decendant of <self> --
+        # 
+        #       ie. The EM::Connection as instanciated upon each
+        #           socket connect.
+        #
+        #       -- will likely resolve.
+        #
+        # 
+        receive( @protocol.decode( data ) )
+        
+      end
+      
+    end
+
+  end
+
+end

data/lib/langrove/daemon/base.rb

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

data/lib/langrove/daemon_base.rb

@@ -0,0 +1,175 @@
+require 'eventmachine'
+
+require 'langrove'
+
+module LanGrove::Daemon class Base
+  
+  def listen
+    
+    #
+    # Handler - The CollectionOfClients, is passed 
+    #           through the adaptor to be assigned 
+    #           to the attaching Clients.
+    #
+    @adaptor.listen( @handler, @handler.protocol )
+    
+  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 LanGrove::DaemonConfigException.new( "Requires a logger" )
+      
+    end
+
+    begin
+
+      @my_config = @config[ :daemons ][ @daemon_name ]
+      
+      @server    = @my_config[ :server ] if @my_config.has_key? :server
+      
+      adaptor    = @my_config[ :adaptor ][ :connection ]
+      
+      handler    = @my_config[ :handler ][ :collection ]
+         
+    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
+    
+    #
+    # initialize the connection adaptor specified in config
+    # 
+    # daemons:
+    #   name_of_daemon:
+    #     adaptor:
+    #       connection: TcpServer  <----------
+    #     handler:
+    #       collection: CollectionOfClients 
+    #
+
+    @logger.info "Initialize instance: Adaptor::#{adaptor}.new( @my_config[ :adaptor ], logger )"
+    
+    @adaptor = LanGrove::ClassLoader.create( {
+      
+      :module => 'Adaptor',
+      :class  => 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 instance: Handler::#{handler}.new( config_hash, '#{daemon_name}', logger )"
+    
+    @handler = LanGrove::ClassLoader.create( {
+      
+      :module => 'Handler',
+      :class  => handler
+      
+    } ).new( @config, @daemon_name, @logger )
+    
+ 
+  end
+  
+end; end

data/lib/langrove/ext/class_loader.rb

@@ -0,0 +1,148 @@
+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
+        
+        path = File.expand_path('../../',  __FILE__)
+        
+        location = "#{path}/#{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/langrove/ext/config_item.rb

@@ -0,0 +1,34 @@
+
+module LanGrove class ConfigException < Exception; end; end
+
+module LanGrove 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; end

data/lib/langrove/ext/config_loader.rb

@@ -0,0 +1,16 @@
+# TODO: spec
+
+require 'yaml'
+
+module LanGrove class ConfigLoader
+  
+  def self.yaml( file )
+    
+    # no rescue block
+    # daemon fails on missing config file
+    
+    YAML.load_file( file )
+      
+  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/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'