langrove 0.0.4.5 → 0.0.5.3

data/lib/langrove/daemon/daemon_base.rb

@@ -0,0 +1,330 @@
+require 'eventmachine'
+
+module LanGrove
+  
+  class DaemonStopException < Exception
+    
+  end
+  
+end
+
+module LanGrove
+
+  module Daemon 
+
+    class Base < LanGrove::Base
+    
+      @@type = :daemon
+
+      def connect
+
+        #
+        # UNIMPLEMENTED (Client Daemon)
+        #
+        
+      end
+
+      
+      def listen
+        
+        @adaptor.listen(
+
+          #
+          # Handler and Protocol are instanciated at socket connect,
+          # they need the config then...
+          #
+          
+          { :class => @handler, :config => @my_config[ :handler ] },
+          
+          { :class => @protocol, :config => @my_config[ :protocol ] },
+          
+          @server
+          
+        )
+        
+      end
+      
+      
+      def stop_daemon
+        
+        @logger.info "#{self} received stop_daemon"
+
+        @adaptor.stop_adaptor
+
+        @server.stop_server
+        
+      end
+      
+      def reload_daemon
+        
+        @logger.info "#{self} received reload_daemon"
+
+        @adaptor.reload_adaptor
+
+        @server.reload_server
+        
+      end
+      
+      
+      def schedule_behaviours
+        
+        @server.schedule do |behaviour, at|
+          
+          at.each do |event, event_config|
+            
+            @root.schedule( 
+            
+              event, event_config, behaviour
+              
+            ) unless event == :interval
+            
+            
+            if not defined?( EventMachine )
+              
+              @logger.warn( "Adaptor does not support :interval: scheduling" )
+              
+              return
+              
+            end if event == :interval
+              
+            EM::add_periodic_timer( event_config ) do 
+              
+              #
+              # at_interval behaviours only act
+              # on handlers - for now
+              # 
+
+              begin
+               
+                unless behaviour.running then
+                  
+                  #
+                  # Behaviour mey be scheduled at a shorter
+                  # interval than it takes to run.
+                  # 
+                  # This protects from multiple runnings
+                  #
+                  
+                  behaviour.running = true
+                  behaviour.call( @server, :handler )
+                  behaviour.running = false
+
+                else
+              
+                  @logger.warn("#{behaviour} already running at interval:#{event_config}")
+              
+                end
+            
+              rescue Exception => err
+              
+                puts err
+                behaviour.running = false
+              
+              end 
+            
+            end if event == :interval
+          
+          end unless at.nil?
+          
+        end
+             
+      end
+      
+      
+      def run
+        
+        begin
+          
+          case @adaptor.type
+            
+            when :not_eventmachine
+            
+              start
+
+            else
+
+              EventMachine::run do
+              
+                start
+              
+              end
+            
+          end
+        
+        rescue LanGrove::DaemonStopException => e
+          
+          stop_daemon
+          
+        end
+        
+      end
+      
+      def start
+        
+        schedule_behaviours unless @server.nil?
+        
+        #
+        # TODO: The client
+        # 
+        connect unless @client.nil?
+        
+        listen unless @handler.nil?
+        
+      end
+      
+      def initialize( root, config_hash, daemon_name )
+        
+        super( root )
+        
+        @config      = config_hash
+        @daemon_name = daemon_name
+        
+
+        #
+        # TODO: The client
+        #
+
+        client  = nil
+        @client = nil
+
+        
+        begin
+
+          @logger.info "Starting daemon: #{@daemon_name}"
+
+        rescue
+
+          config_exception(
+          
+            "Requires a logger"
+            
+          )   
+          
+        end
+        
+        
+        begin
+          
+          @my_config = @config[ :daemons ][ @daemon_name ]
+
+          root.config.system = @my_config[:system] unless @my_config[:system].nil?
+
+          root.config.application = @my_config[:application] unless @my_config[:application].nil?
+               
+          raise LanGrove::DaemonConfigException.new(
+
+            'Daemon requires :system: and :application: defined.'
+
+          ) if root.config.system.nil? or root.config.application.nil?
+
+        rescue
+          
+          error = "Missing config for daemon: #{@daemon_name}"
+          
+          @logger.error( error )
+          
+          config_exception( 
+          
+            error
+            
+          )
+           
+        end
+        
+        
+        #
+        # Instanciate the Server module
+        # 
+        # - Contains the Handler collection (of attached clients)
+        #
+        
+        server = LanGrove::ModuleLoader.create( { 
+          
+          :key => :server,
+          :config => @my_config,
+          :mandatory => false,
+          :logger => @logger
+          
+        } )
+        
+        @server = server.new( 
+        
+          root, @config, @daemon_name 
+          
+        ) unless server.nil?
+        
+        
+        #
+        # Instanciate the Adaptor module
+        #
+        # - Interface to listen()
+        #
+        adaptor = LanGrove::ModuleLoader.create( { 
+          
+          :key => :adaptor,
+          :config => @my_config,
+          :mandatory => true,
+          :logger => @logger
+          
+        } )
+        
+        @adaptor = adaptor.new( 
+        
+          root, @my_config[ :adaptor ], @daemon_name
+          
+        ) unless adaptor.nil?
+
+        
+        #
+        # Load the Handler if present in config
+        # 
+        #  - Dont create instance.
+        #
+        #  - These are started up on socket connect
+        # 
+        #  - These will each have an attached client
+        # 
+        #  - These will reside in the Server.@handlers
+        #    collection.  
+        #
+        @handler = LanGrove::ModuleLoader.create( { 
+          
+          :key => :handler,
+          :config => @my_config,
+          
+          #
+          # Mandatory if @server is loaded
+          # 
+          :mandatory => ( not @server.nil? ),
+          :logger => @logger
+          
+        } )
+        
+        
+        
+        #
+        # Laod the Protocol module
+        #
+        #  - Dont create instance.
+        # 
+        #  - These are started up, one each, in
+        #    the Handler, as the socket connects.
+        #
+        @protocol = LanGrove::ModuleLoader.create( { 
+          
+          :key => :protocol,
+          :config => @my_config,
+          :mandatory =>  ( not @server.nil? ),
+          :logger => @logger
+          
+        } )
+        
+        @server.start_server
+      
+      end
+
+    end
+    
+  end
+
+end

data/lib/langrove/daemon/default.rb

@@ -0,0 +1,3 @@
+require 'langrove/daemon/base'
+
+LanGrove::Daemon::Default = LanGrove::Daemon::Base

data/lib/langrove/ext/README.md

@@ -0,0 +1,48 @@
+Tools and Utilities
+===================
+
+
+LanGrove::ClassLoader
+---------------------
+
+Used to load the contantized definition of a `class` from its `String` name in the config tree.
+
+<pre>
+
+mercury_definition = ClassLoader.create(
+
+	:module => 'InnerPlanet', 
+	:class  => 'Mercury'
+
+)
+
+mercury = mercury_definition.new
+
+</pre>
+
+Assuming that `lib/inner_planet/mercury.rb` exists.
+
+
+
+LanGrove::ConfigLoader
+----------------------
+
+Used by the environment loader to collect and merge all `./config/*.yml` files ahead of spawing the daemon.
+
+
+
+LanGrove::ModuleLoader
+----------------------
+
+Used specifically to convert branches of `config` into the `class` definitions they define.
+
+<pre>
+
+:handler:
+	:class: MyClientHandler
+
+</pre>
+
+Would use the ModuleLoader to load the `class` definition at `lib/handler/my_client_handler.rb` into `Handler::MyClientHandler` for later instanciation.
+
+

data/lib/langrove/ext/class_loader.rb

@@ -1,4 +1,5 @@
 require 'langrove/ext/string'
+
 module LanGrove
   
   class ClassLoaderException < Exception; end
@@ -7,34 +8,7 @@ module LanGrove
   
     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 )
-      #
+      logger.info( "LOAD: #{class_config.inspect}" ) unless logger.nil?
       
       raise ClassLoaderException.new( 
       
@@ -53,33 +27,6 @@ module LanGrove
       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
       #
@@ -100,16 +47,6 @@ module LanGrove
         
         exception = e
         
-        logger.error "Missing class definition in lib/#{location}.rb" unless logger.nil?
-        
-      #rescue Exception => e 
-      #  
-      #  #
-      #  # Incase of more... (discovery phase)
-      #  #
-      #
-      
-        
       end
       
       #
@@ -122,7 +59,11 @@ module LanGrove
         
         location = "#{path}/#{module_name.underscore}/#{class_name.underscore}"
         
-        eval "require '#{location}'"
+        begin
+        
+          eval "require '#{location}'"
+          
+        rescue; end
         
         return LanGrove.const_get( module_name ).const_get( class_name )
         
@@ -137,6 +78,8 @@ module LanGrove
         # And not confuse the issue by raising
         # "no such file 'langrove/module/class"
         #
+        logger.error "FAIL: #{exception.message}.rb" unless logger.nil?
+        
         raise ClassLoaderException.new "#{exception.message}.rb"
         
       end

data/lib/langrove/ext/config_item.rb

@@ -1,34 +1,42 @@
 
-module LanGrove class ConfigException < Exception; end; end
+module LanGrove 
 
-module LanGrove class ConfigItem
+  class ConfigException < Exception; end
 
-  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?
+end
+
+module LanGrove 
+
+  class ConfigItem
+
+    def self.get(config_hash, key_array, mandatory = true)
       
-        hash = hash[key]
+      # raise ConfigException.new("match")
       
-        # raises a config exception if the key isnt present BLANK NEITHER
-        raise ConfigException.new("Missing config item '#{key}'") if hash == "" 
+      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
-    
-    return hash
-    
+
   end
 
-end; end
+end

data/lib/langrove/ext/config_loader.rb

@@ -2,15 +2,49 @@
 
 require 'yaml'
 
-module LanGrove class ConfigLoader
+module LanGrove 
+
+  class ConfigLoader
   
-  def self.yaml( file )
-    
-    # no rescue block
-    # daemon fails on missing config file
+    def self.load_dir( directory )
+      
+      @config = {
+        
+        :daemons => {}
+        
+      }
+      
+      Dir.glob( "#{directory}/*.yml" ) do |config_part|
+        
+        self.load_yaml( config_part )
+        
+      end
+      
+      return @config
+      
+    end
     
-    YAML.load_file( file )
+    def self.load_yaml( file )
       
+      # no rescue block
+      # daemon fails on missing config file
+      
+      yaml = YAML.load_file( file )
+      @config.merge!( yaml ) do |key, oldval, newval|
+        
+        #
+        # so the :daemons: subconfigs dont overwrite
+        # each other
+        #
+        oldval.merge!( newval )
+        @config[ key ] = oldval
+        
+      end
+      
+      return yaml
+        
+    end
+    
   end
-  
-end; end
+
+end