em-langrove 0.0.4.5

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rvmrc

@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional.
+environment_id="ruby-1.9.2-p0@langrove"
+
+#
+# Uncomment following line if you want options to be set only for given project.
+#
+# PROJECT_JRUBY_OPTS=( --1.9 )
+
+#
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+#
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments" \
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+
+  if [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]]
+  then
+    . "${rvm_path:-$HOME/.rvm}/hooks/after_use"
+  fi
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  if ! rvm --create use  "$environment_id"
+  then
+    echo "Failed to create RVM environment '${environment_id}'."
+    return 1
+  fi
+fi
+
+#
+# If you use an RVM gemset file to install a list of gems (*.gems), you can have
+# it be automatically loaded. Uncomment the following and adjust the filename if
+# necessary.
+#
+# filename=".gems"
+# if [[ -s "$filename" ]]
+# then
+#   rvm gemset import "$filename" | grep -v already | grep -v listed | grep -v complete | sed '/^$/d'
+# fi
+
+# If you use bundler, this might be useful to you:
+# if command -v bundle && [[ -s Gemfile ]]
+# then
+#   bundle install
+# fi
+
+if [[ $- == *i* ]] # check for interactive shells
+then
+    echo "Using: $(tput setaf 2)$GEM_HOME$(tput sgr0)" # show the user the ruby and gemset they are using in green
+else 
+	echo "Using: $GEM_HOME" # don't use colors in interactive shells
+fi
+
+

data/.watchr

@@ -0,0 +1,27 @@
+def run_spec(file)
+  unless File.exist?(file)
+    puts "#{file} does not exist"
+    return
+  end
+
+  puts "Running #{file}"
+  system "rspec #{file}"
+  puts
+end
+
+watch("spec/.*/*_spec.rb") do |match|
+  run_spec match[0]
+end
+
+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/Gemfile

@@ -0,0 +1,16 @@
+source :gemcutter
+source "http://rubygems.org"
+
+gem 'watchr'
+gem 'rspec'
+
+# daemon-kit
+gem 'daemon-kit'
+gem 'eventmachine'
+gem 'em-http-request'
+gem 'awesome_print'
+
+gem 'eventmachine_httpserver'
+
+gem 'resque'
+gem 'rake'

data/Gemfile.lock

@@ -0,0 +1,61 @@
+GEM
+  remote: http://rubygems.org/
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.2.7)
+    awesome_print (1.0.2)
+    daemon-kit (0.1.8.2)
+      eventmachine (>= 0.12.10)
+      safely (>= 0.3.1)
+    diff-lcs (1.1.3)
+    em-http-request (0.3.0)
+      addressable (>= 2.0.0)
+      escape_utils
+      eventmachine (>= 0.12.9)
+    escape_utils (0.2.4)
+    eventmachine (0.12.10)
+    eventmachine_httpserver (0.2.1)
+    multi_json (1.3.2)
+    rack (1.4.1)
+    rack-protection (1.2.0)
+      rack
+    rake (0.8.7)
+    redis (2.2.2)
+    redis-namespace (1.0.3)
+      redis (< 3.0.0)
+    resque (1.20.0)
+      multi_json (~> 1.0)
+      redis-namespace (~> 1.0.2)
+      sinatra (>= 0.9.2)
+      vegas (~> 0.1.2)
+    rspec (2.9.0)
+      rspec-core (~> 2.9.0)
+      rspec-expectations (~> 2.9.0)
+      rspec-mocks (~> 2.9.0)
+    rspec-core (2.9.0)
+    rspec-expectations (2.9.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.9.0)
+    safely (0.3.1)
+    sinatra (1.3.2)
+      rack (~> 1.3, >= 1.3.6)
+      rack-protection (~> 1.2)
+      tilt (~> 1.3, >= 1.3.3)
+    tilt (1.3.3)
+    vegas (0.1.11)
+      rack (>= 1.0.0)
+    watchr (0.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  awesome_print
+  daemon-kit
+  em-http-request
+  eventmachine
+  eventmachine_httpserver
+  rake
+  resque
+  rspec
+  watchr

data/Rakefile

@@ -0,0 +1,24 @@
+$LOAD_PATH.unshift 'lib'
+
+desc "Publish a new version to ruby-gems.org"
+task :publish do
+  require 'langrove/version'
+  
+  sh "gem build em-langrove.gemspec"
+  sh "gem push em-langrove-#{LanGrove::Version}.gem"
+
+  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/bin/langrove

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+puts "warbel"

data/functional/config/boot.rb

@@ -0,0 +1,64 @@
+# Don't change this file!
+# Configure your daemon in config/environment.rb
+
+DAEMON_ROOT = "#{File.expand_path(File.dirname(__FILE__))}/.." unless defined?( DAEMON_ROOT )
+
+require "rubygems"
+require "bundler/setup"
+
+module DaemonKit
+  class << self
+    def boot!
+      unless booted?
+        pick_boot.run
+      end
+    end
+
+    def booted?
+      defined? DaemonKit::Initializer
+    end
+
+    def pick_boot
+      (vendor_kit? ? VendorBoot : GemBoot).new
+    end
+
+    def vendor_kit?
+      File.exists?( "#{DAEMON_ROOT}/vendor/daemon-kit" )
+    end
+  end
+
+  class Boot
+    def run
+      load_initializer
+      DaemonKit::Initializer.run
+    end
+  end
+
+  class VendorBoot < Boot
+    def load_initializer
+      require "#{DAEMON_ROOT}/vendor/daemon-kit/lib/daemon_kit/initializer"
+    end
+  end
+
+  class GemBoot < Boot
+    def load_initializer
+      begin
+        require 'rubygems' unless defined?( ::Gem )
+        gem 'daemon-kit'
+        require 'daemon_kit/initializer'
+      rescue ::Gem::LoadError => e
+        msg = <<EOF
+
+You are missing the daemon-kit gem. Please install the following gem:
+
+sudo gem install daemon-kit
+
+EOF
+        $stderr.puts msg
+        exit 1
+      end
+    end
+  end
+end
+
+DaemonKit.boot!

data/functional/config/daemons.yml

@@ -0,0 +1,13 @@
+:daemons:
+    datagram:
+        :periodic: 5
+        :protocol:
+            :class: SocketToFile
+        :adaptor:
+            :iface: 127.0.0.1
+            :port: 12701
+            :transport: udp
+        :client: 
+            :class: SocketToFile
+        :handler: 
+            :collection: Base

data/functional/config/environment.rb

@@ -0,0 +1,28 @@
+ENV["TZ"] = "ZA"
+#ENV['DAEMON_ENV'] ||= 'production'
+
+# Boot up
+require File.join(File.dirname(__FILE__), 'boot')
+
+# Auto-require default libraries.
+Bundler.require :default, DaemonKit.env
+
+DaemonKit::Initializer.run do |config|
+  
+  config.daemon_name = DAEMON_NAME
+
+  # Force the daemon to be killed after X seconds from asking it to
+  # config.force_kill_wait = 30
+
+  # Log backraces when a thread/daemon dies (Recommended)
+  config.backtraces = true
+  
+  #
+  # TODO: move log level into per daemon config
+  #
+     #config.log_level = :debug
+  config.log_level = :debug
+     #config.log_level = :warn
+     #config.log_level = :error
+  
+end

data/functional/lib/client/socket_to_file.rb

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

data/functional/lib/daemon/datagram.rb

@@ -0,0 +1,21 @@
+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/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.debug( "#{self}.decode: #{data}" ) unless @logger.nil?
+      
+      {
+        
+        :filename => data.split('|')[0],
+        :content  => data.split('|',2)[1]
+        
+      }
+      
+    end
+    
+  end
+
+end

data/functional/libexec/daemon.rb

@@ -0,0 +1,68 @@
+require 'langrove'
+
+CLASS_NAME  = DAEMON_NAME.camelize
+CONFIG_FILE = "#{DAEMON_ROOT}/config/daemons.yml"
+CONFIG_HASH = LanGrove::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
+  #
+  # 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
+  
+end

data/functional/tmp/README

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

data/lib/langrove/_base.rb

@@ -0,0 +1,28 @@
+#$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 Job; 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'
+require 'langrove/job/base'

data/lib/langrove/adaptor/base.rb

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

data/lib/langrove/adaptor_base.rb

@@ -0,0 +1,116 @@
+require 'eventmachine'
+
+require 'langrove'
+
+module LanGrove::Adaptor
+  
+  class Base
+  
+    def initialize( config, logger )
+    
+      @config = config
+      @logger = logger
+      
+      @transport = :tcp
+      @iface     = '127.0.0.1'
+      @port      = 12701
+      
+      @iface     = @config[ :iface ] if @config.has_key? :iface
+      @port      = @config[ :port ]  if @config.has_key? :port
+      @transport = @config[ :transport ].to_sym  if @config.has_key? :transport
+      
+      #
+      # Assign the call signature for the EventMachine server
+      #
+      @em_server_call = case @transport
+        
+        when :tcp
+          
+          :start_server
+          
+        when :udp
+          
+          :open_datagram_socket
+          
+        else
+          
+          :start_server
+        
+      end
+    
+    end
+  
+    def listen( client, protocol, handler )
+      
+      #
+      # <client> = {
+      # 
+      #    :class   => <loaded class constant>
+      #    :config  => <client's branch of config>
+      # 
+      # } 
+      # 
+      # <protocol> = {  ...the same, but protocolic }
+      #
+      #
+    
+      @logger.info "starting listen at UDP #{@iface}:#{@port}"
+      
+      EventMachine::send( @em_server_call, @iface, @port, 
+      
+        client[:class] ) do | client_connected |
+          
+          #
+          # @em_server_call as:
+          # 
+          # udp - EM::open_datagram_socket, yields an instance of 
+          #       client[:class] into here on bind to the port 
+          #
+          #       ie. at starting to listen
+          #       
+          #       unverified: ? If more than 1 datagram source is 
+          #                   transmitting to here - will there still
+          #                   still be only ONE EM:Connection instance?
+          # 
+          # tcp - EM::start_server yields an new instance of client[:class]
+          #       with every connecting socket pair.
+          #
+          #       ie. On socket pair binding - so each remote client will 
+          #           have it's own associated instance of a client[:class] 
+          #           running in the machine.
+          #
+          
+          
+          #
+          # Initialize the client with the (application layer) Protocol
+          #
+          
+          client_connected.logger = @logger
+          
+          client_connected.config = client[ :config ]
+          
+          client_connected.protocol = protocol[ :class ]\
+          
+            .new( protocol[ :config ], @logger )
+            
+          @logger.info( "TODO: make a reference to the Client on the Handler" )
+     
+          #
+          # Bi-Directionally bind the Client and Handler
+          #
+          handler.connect( client_connected )
+          client_connected.handler = handler
+          
+          #
+          # Client is ready and running inside the reactor
+          #
+          # EM::start_server will yield again on the next connect.
+          # 
+          
+      end
+    
+    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,25 @@
+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