LanGrove 0.0.1 → 0.0.2

data/.watchr

@@ -13,7 +13,15 @@ watch("spec/.*/*_spec.rb") do |match|
   run_spec match[0]
 end
 
-watch("lib/(.*/*).rb") do |match|
-  puts match
-  run_spec %{spec/#{match[1]}_spec.rb}
+watch("(.*/*).rb") do |match|
+  file = match[1]
+  file.gsub!('lib/','')
+  file.gsub!('spec/','')
+  file.sub!('_spec','')
+  puts "====#{file}==="
+	if /demo/.match(match[0]) then
+		run_spec %{spec/#{file}_spec.rb}
+		next
+	end
+  run_spec %{spec/#{file}_spec.rb}
 end

data/Rakefile

@@ -3,15 +3,22 @@ $LOAD_PATH.unshift 'lib'
 desc "Publish a new version to ruby-gems.org"
 task :publish do
   require 'langrove/version'
-
+  
   sh "gem build langrove.gemspec"
   sh "gem push langrove-#{LanGrove::Version}.gem"
 
-  #sh "git tag v#{LanGrove::Version}"
-  #sh "git push origin v#{Resque::Version}"
-  #sh "git push origin master"
-  #sh "git clean -fd"
+  sh "git tag v#{LanGrove::Version}"
+  sh "git push origin v#{LanGrove::Version}"
+  sh "git push origin master"
+  sh "git clean -fd"
   
 #  exec "rake documentation"
 
 end
+
+desc "Push to github"
+task :push_world do
+  
+  puts "TODO"
+  
+end

data/functional/.gitignore

@@ -0,0 +1 @@
+tmp/*.*

data/{bin/datagram_example → functional/bin/datagram}

@@ -1,4 +1,6 @@
 #!/usr/bin/env ruby
+
+DAEMON_ROOT = File.expand_path('../../../functional/',  __FILE__)
 DAEMON_NAME = File.basename $0
 require File.expand_path('../../config/environment',  __FILE__)
 DaemonKit::Application.exec( DAEMON_ROOT + '/libexec/daemon.rb' )

data/functional/config/daemons.yml

@@ -0,0 +1,12 @@
+:daemons:
+    datagram:
+        :periodic: 5
+        :adaptor:
+          :connection: Datagram
+          :iface: 127.0.0.1
+          :port: 12701
+          :client: 
+              :class: Datagram
+        :handler: 
+            :collection: SocketToFile
+            :protocol: SocketToFile

data/functional/lib/daemon/datagram.rb

@@ -0,0 +1,23 @@
+require 'langrove/daemon/base'
+
+class Datagram < LanGrove::Daemon::Base
+  
+  #
+  # Consider tossing this dependancy.
+  # 
+  # Not entirely certain this layer in the abstraction 
+  # will be useful.
+  #
+  # Except, by
+  #
+  #    << using this layer in the abstraction >>
+  # 
+  # 
+  # the eval "require 'module/class_name.rb'" in the
+  # langrove/ext/class_loader could possibly be avoided
+  # if the implementation requires all necessary modules
+  # ahead of starting the daemon.
+  # 
+  #
+  
+end

data/functional/lib/handler/socket_to_file.rb

@@ -0,0 +1,36 @@
+#
+# Define a Handler by extending LanGrove::Handler::Base
+# and extending the functions:
+#
+#   1.  <YourClass>.receive( data )
+# 
+#       Data arriving from the Adaptor will arrive into
+#       this function having already been decoded by the 
+#       configured Protocol for this Handler
+#
+#   # 2.  <YourClass>.transmit  
+#   # 
+
+require 'langrove'
+
+module Handler
+  
+  class SocketToFile < LanGrove::Handler::Base
+    
+    def receive( data )
+      
+      @logger.info( "#{self}.receive: #{data}" )  
+      
+      File.open( data[:filename], 'w' ) do |f|
+        
+        f.write( data[:content] )
+        
+      end
+      
+      @logger.info "Wrote data: '#{data[ :content ]}' to file: '#{ data[ :filename ]}'"
+      
+    end
+      
+  end
+  
+end

data/functional/lib/protocol/socket_to_file.rb

@@ -0,0 +1,55 @@
+#
+# Define a Protocol by extending LanGrove::Protocol::Base
+# and extending the functions:
+#
+#   1.  <YourClass>.decode( data )
+# 
+#       Data arriving from the Adaptor will be passed to
+#       the config assigned protocol. The Handler will
+#       be expecting decoded data in the form of a Hash
+# 
+#       SPECIFICALLY: One of the keys should correspond 
+#                     to the :route_by in the config.
+#
+#   # 2.  <YourClass>.encode( .. )  
+#   # 
+
+
+require 'langrove'
+
+module Protocol
+  
+  #
+  # Module is only necessary if you choose to
+  # structure associations of class by name.
+  # 
+  # eg. 
+  # 
+  #   Protocol::SocketToFile
+  #   Handler::SocketToFile
+  #
+
+  class SocketToFile < LanGrove::Protocol::Base
+    
+    def decode( data )
+      
+      #
+      # OVERRIDE
+      # 
+      # Becasuse your protocol 
+      #
+      
+      @logger.info( "#{self}.decode: #{data}" ) unless @logger.nil?
+      
+      {
+        
+        :filename => data.split('|')[0],
+        :content  => data.split('|',2)[1]
+        
+      }
+      
+    end
+    
+  end
+
+end

data/{libexec → functional/libexec}/daemon.rb

@@ -1,9 +1,8 @@
-require 'ext/string'
-require 'ext/config_loader'
+require 'langrove'
 
 CLASS_NAME  = DAEMON_NAME.camelize
 CONFIG_FILE = "#{DAEMON_ROOT}/config/daemons.yml"
-CONFIG_HASH = ConfigLoader.yaml( CONFIG_FILE )
+CONFIG_HASH = LanGrove::ConfigLoader.yaml( CONFIG_FILE )
 
 daemon = nil
 
@@ -50,6 +49,18 @@ DaemonKit::Application.running! do |config|
   #
   # Latebind the daemon class
   #
+  # TODO: see about tossing the libexec
+  #       or modifying class loader to enable 
+  #       alternate load path to allow this pattern:
+  #
+  # daemon = LanGrove::ClassLoader.create( {
+  #  
+  #  :module => 'Daemon', 
+  #  :class  => DAEMON_NAME.camelize
+  #  
+  # } ).new( CONFIG_HASH, DAEMON_NAME, DaemonKit.logger )
+  # 
+  
   require "daemon/#{DAEMON_NAME}"
   daemon = Object.const_get( CLASS_NAME ).new( CONFIG_HASH, DAEMON_NAME, DaemonKit.logger )
   daemon.run

data/functional/log/.gitignore

@@ -0,0 +1,3 @@
+*.log
+*.pid
+*.yml

data/functional/tmp/README

@@ -0,0 +1 @@
+Certain test write files into here

data/lib/langrove.rb

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

data/lib/langrove/_base.rb

@@ -0,0 +1,26 @@
+#$LOAD_PATH.unshift 'langrove' unless $LOAD_PATH.include?( 'langrove' )
+
+#$LOAD_PATH.inspect
+
+#
+# For the implementation client
+#
+module Adaptor; end
+module Client; end
+module Daemon; end
+module Handler; end
+module Protocol; end
+
+module LanGrove
+  
+  class DaemonConfigException < Exception; end
+  
+end
+
+require 'langrove/ext'
+
+require 'langrove/daemon/base'
+require 'langrove/adaptor/base'
+require 'langrove/handler/base'
+require 'langrove/protocol/base'
+require 'langrove/client/base'

data/lib/langrove/adaptor/base.rb

@@ -0,0 +1,3 @@
+module LanGrove::Adaptor; end
+require 'langrove/adaptor_base'
+require 'langrove/adaptor/datagram'

data/lib/langrove/adaptor/datagram.rb

@@ -0,0 +1,27 @@
+require 'langrove/adaptor/base'
+
+module LanGrove::Adaptor
+  
+  class Datagram < Base
+    
+    def listen( handler, protocol )
+    
+      @logger.info "starting listen at UDP #{@iface}:#{@port}"
+      
+      EventMachine::open_datagram_socket( @iface, @port, 
+      
+        @client ) do |client|
+          
+          @logger.info "client assign handler: #{handler}"
+          client.handler  = handler
+          
+          @logger.info "client instanciate protocol: #{protocol}"
+          client.protocol = protocol.new( nil, @logger )
+          
+          @logger.info "client assign config: #{@client_config}"
+          client.config = @client_config.clone
+          
+      end
+    end
+  end
+end

data/lib/langrove/adaptor_base.rb

@@ -0,0 +1,89 @@
+require 'eventmachine'
+
+require 'langrove'
+
+module LanGrove::Adaptor
+  
+  class Base
+  
+    def initialize( config, logger )
+    
+      @config = config
+      @logger = logger
+    
+      @iface     = '127.0.0.1'
+      @port      = 12701
+      
+      @iface   = @config[ :iface ] if @config.has_key? :iface
+      @port    = @config[ :port ]  if @config.has_key? :port
+      
+      if @config.has_key? :connector then
+        
+        #
+        # TODO: may need to override default connection handler
+        #
+        
+      end
+      
+      #
+      # initialize the client specified in config
+      # 
+      # daemons:
+      #   name_of_daemon:
+      #     adaptor:
+      #       connection: TcpServer
+      #       client:
+      #         class: Client <---------
+      #     handler:
+      #       collection: CollectionOfClients 
+      #
+      # 
+      
+      @logger.info "TODO: loading client is not tested"
+      
+      client = nil
+      
+      begin 
+        
+        #
+        # TODO: make this more informative on error
+        #
+      
+        @client_config = @config[ :client ]
+        client  = @client_config[ :class ]
+        
+      rescue
+        
+        error = "Missing config item(s) for adaptor: #{@config.inspect}" 
+
+        @logger.error "EXIT: #{error}"
+
+        raise LanGrove::DaemonConfigException.new( 
+
+          "Missing config item for daemon: #{@daemon_name}" 
+
+        )
+        
+      end
+
+      @logger.info "Load definition: Client::#{client}"
+
+      @client = LanGrove::ClassLoader.create( {
+
+        :module => 'Client',
+        :class  => client
+
+      } )
+      
+    
+    end
+  
+    def listen( handler, protocol )
+    
+      raise LanGrove::DaemonConfigException.new( "NotYetExtended: undefined listen()" )
+    
+    end
+  
+  end
+  
+end

data/lib/langrove/client/base.rb

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

data/lib/langrove/client/datagram.rb

@@ -0,0 +1,28 @@
+require 'eventmachine'
+require 'langrove'
+
+module LanGrove
+  
+  module Client
+    
+    class Datagram < Base
+      
+      def receive( data )
+
+        #
+        # Quick hack, datagram client routes
+        # data back to the Handler - to get
+        # back to friday position.
+        # 
+        # But with the gem
+        #
+        
+        @handler.receive( data )
+        
+      end
+       
+    end
+    
+  end
+  
+end

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