em-langrove 0.0.4.5

data/lib/langrove/client_base.rb

@@ -0,0 +1,92 @@
+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..
+      # 
+     
+      attr_accessor :handler
+      attr_accessor :protocol
+      attr_accessor :config
+      attr_accessor :logger
+      
+      
+      #
+      # 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 should have 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 )
+        
+        #
+        # Event machine writes into here at receiving data 
+        # from the client. 
+        # 
+        
+        receive( @protocol.decode( data ) )
+        
+        # 
+        # ?Multi-message protocol? 
+        # 
+        # @protocol.accumulate( multi_message_part, self )
+        #
+        #   ---- With protocol responding directly to source
+        # 
+        #   ---- With protocol then calling receive_decoded()
+        #        via the self being passed in. 
+        #   
+        
+      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,281 @@
+require 'eventmachine'
+
+require 'langrove'
+
+module LanGrove::Daemon class Base
+  
+  def listen
+    
+    #
+    # <Client> and <Protocol> are passed into 
+    # the Adaptor.listen for binding onto the 
+    # sockets at connect.
+    #
+    @adaptor.listen( 
+    
+      #
+      # pass Client, Protocol and Handler to 'listener'
+      #
+      
+      { :class => @client, :config => @my_config[ :client ] }, 
+      
+      { :class => @protocol, :config => @my_config[ :protocol ] },
+      
+      @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
+    
+    @logger.info "#{self} Scheduling periodic ...TODO..."
+    
+    EM::add_periodic_timer( @my_config[ :periodic ] ) do 
+      
+      #
+      # 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
+    
+    #
+    # The client collection class.
+    #
+    @handler = nil
+    
+    #
+    # The client type
+    #
+    @client = nil
+    
+    #
+    # The protocol type
+    #
+    @protocol = 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
+      
+      
+      
+      if @my_config[ :adaptor ].has_key? :class
+        
+        adaptor    = @my_config[ :adaptor ][ :class ]
+        
+      else
+      
+        @logger.warn( "Defaulting to Adaptor::Base" )
+        adaptor    = 'Base'
+      
+      end
+      
+      
+      
+      @logger.info "TODO: fall back to default Handler::Base"
+      
+      handler    = @my_config[ :handler ][ :collection ]
+      
+      client     = @my_config[ :client ][ :class ]
+      
+      protocol   = @my_config[ :protocol ][ :class ]
+      
+      @logger.info "TODO: Warn instead of raise and allow nil into ClassLoader -> load default"
+         
+    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:
+    #       class: MySocket  <----------( optional )
+    #       transport: tcp|udp
+    #       iface: N.N.n.n
+    #       port: nNn
+    #     handler:
+    #       collection: CollectionOfClients 
+    #
+
+    @logger.info "CREATE: 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 "CREATE: Handler::#{handler}.new( config_hash, '#{daemon_name}', logger )"
+    
+    @handler = LanGrove::ClassLoader.create( {
+      
+      :module => 'Handler',
+      :class  => handler
+      
+    } ).new( @config, @daemon_name, @logger )
+    
+    
+    #
+    # initialize the client specified in config
+    # 
+    # daemons:
+    #   name_of_daemon:
+    #     client:
+    #       class: Client <---------
+    #     adaptor:
+    #       connection: TcpServer
+    #     handler:
+    #       collection: CollectionOfClients 
+    #
+    #
+    
+    @logger.info "DEFINE: Client::#{client}"
+
+    @client = LanGrove::ClassLoader.create( {
+
+      :module => 'Client',
+      :class  => client
+
+    } )
+    
+    
+    #
+    # initialize the client specified in config
+    # 
+    # daemons:
+    #   name_of_daemon:
+    #     protocol:
+    #       class: Protocol <---------
+    #       more: config
+    #     client:
+    #       class: Client
+    #     adaptor:
+    #       connection: TcpServer
+    #     handler:
+    #       collection: CollectionOfClients 
+    #
+    #
+    
+    @logger.info "DEFINE: Protocol::#{protocol}"
+
+    @protocol = LanGrove::ClassLoader.create( {
+
+      :module => 'Protocol',
+      :class  => protocol
+
+    } )
+    
+    
+    #
+    # Notifiy the handler
+    # 
+    # About to go to listen... 
+    #
+    
+    @handler.start_daemon
+ 
+  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/find.rb

@@ -0,0 +1,90 @@
+module LanGrove
+  
+  class Find
+    
+    def self.with( arg_hash , &block )
+      
+      type = :file
+      @path = '.'
+      
+      #
+      # TODO: filter 
+      #
+      
+      @incl = nil
+      
+      @relative = false
+      
+      
+        arg_hash.each do |key, value|
+          
+          case key
+            
+            when :type
+            
+              type = value
+              
+            when :path
+              
+              @path = value
+              
+            when :include
+              
+              @incl = value
+              
+            when :relative
+              
+              @relative = value
+              
+          end
+ 
+        
+      end
+      
+      self.send( :"find_#{type}", @path,  &block )
+      
+    end
+    
+    def self.find_file( path, &block )
+      
+      puts "in #{path}"
+      
+      Dir.entries( path ).each do | sub |
+        
+        next if sub == '.'
+        next if sub == '..'
+        
+        subdir = "#{path}/#{sub}"
+        
+        begin
+          
+          if @incl.nil? then
+            
+           yield relative(subdir) if block
+            
+          else
+          
+            yield relative(subdir) unless /#{@incl}/.match( subdir ).nil?
+            
+          end
+          
+          next
+          
+        end if File.file?( subdir ) and block
+        
+        find_file( subdir, &block )
+        
+      end
+      
+    end
+    
+    def self.relative( file_path )
+      
+      return file_path.gsub( "#{@path}/",'' ) if @relative
+      return file_path
+      
+    end
+    
+  end
+  
+end