gz_activemessaging 0.13.1

data/generators/processor/templates/jruby_poller

@@ -0,0 +1,117 @@
+#!/bin/sh
+
+JRUBY_CMD=`which jruby`
+RAILS_ROOT="$(dirname $0)/.."
+POLLER_RB="$RAILS_ROOT/vendor/plugins/activemessaging/poller.rb"
+OUT="$RAILS_ROOT/tmp/poller.output"
+PID_FILE="$RAILS_ROOT/tmp/poller0.pid"
+
+if [ -z "$JRUBY_CMD" ] ; then
+	echo "Could not find jruby on your path."
+	exit 1
+fi
+
+if [ ! -f $POLLER_RB ] ; then
+	echo "Could not find the poller file at: $POLLER_RB"
+	exit 1
+fi
+
+function start() {
+	if [[ -s $PID_FILE && -n "$(ps -A | grep "^[ \t]*$(< $PID_FILE)")" ]] ; then
+		PID=$(< $PID_FILE)
+		echo "Poller already running with pid $PID."
+		exit 1
+	fi
+	$JRUBY_CMD $POLLER_RB "$@" >> $OUT 2>&1 &
+	PID=$!
+	echo $PID > $PID_FILE
+	echo "Poller started with pid=$PID"
+}
+
+function stop() {
+	if [[ -z "$(ps -A | grep "^[ \t]*$(< $PID_FILE)")" ]] ; then
+		echo "Poller is not currently running."
+		exit 1
+	fi
+	if [ -z "$FORCE" ] ; then
+		echo "Sending TERM signal to poller."
+		kill -TERM $(< $PID_FILE)
+	else
+		echo "Sending KILL signal to poller."
+		kill -KILL $(< $PID_FILE)
+	fi
+	rm $PID_FILE
+}
+
+function restart() {
+	stop
+	start
+}
+
+function run() {
+	exec $JRUBY_CMD $POLLER_RB "$@"
+}
+
+function zap() {
+	echo "Resetting to stopped state."
+	[ -f $PID_FILE ] && rm $PID_FILE
+}
+
+function usage() {
+	cat <<EOF
+Usage: poller <command> <options> -- <application options>
+
+* where <command> is one of:
+  start         start an instance of the application
+  stop          stop all instances of the application
+  restart       stop all instances and restart them afterwards
+  run           start the application and stay on top
+  zap           set the application to a stopped state
+
+* and where <options> may contain several of the following:
+
+    -t, --ontop                      Stay on top (does not daemonize)
+    -f, --force                      Force operation
+EOF
+
+}
+
+CMD=$1
+shift
+
+for i in "1" "2" ; do
+	case "$1" in
+		"-f"|"--force")
+			FORCE="true"
+			shift
+		;;
+		"-t"|"--ontop")
+			ONTOP="true"
+			shift
+		;;
+	esac
+done
+
+[ "$1" == "--" ] && shift
+
+case "$CMD" in
+	"start")
+		start
+	;;
+	"stop")		
+		stop
+	;;
+	"run")
+		run
+	;;
+	"restart")
+		restart
+	;;
+	"zap")
+		zap
+	;;
+	"usage"|*)
+		usage 
+		exit 1
+	;;
+esac

data/generators/processor/templates/messaging.rb

@@ -0,0 +1,12 @@
+#
+# Add your destination definitions here
+# can also be used to configure filters, and processor groups
+#
+ActiveMessaging::Gateway.define do |s|
+  #s.destination :orders, '/queue/Orders'
+  #s.filter :some_filter, :only=>:orders
+  #s.processor_group :group1, :order_processor
+  
+  s.destination :<%= singular_name %>, '/queue/<%= class_name %>'
+  
+end

data/generators/processor/templates/poller

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+ENV['APP_ROOT'] ||= File.expand_path(File.join(File.dirname(__FILE__), '..'))
+APP_ROOT = ENV['APP_ROOT']
+ENV['APP_NAME'] ||= "poller"
+APP_NAME = ENV['APP_NAME']
+script_file = File.join(APP_ROOT, 'lib', 'poller.rb')
+tmp_dir = File.join(APP_ROOT, 'tmp')
+
+require 'rubygems'
+require 'daemons'
+
+options = {
+  :app_name   => APP_NAME,
+  :dir_mode   => :normal,
+  :dir        => tmp_dir,
+  :multiple   => true,
+  :ontop      => false,
+  :mode       => :load,
+  :backtrace  => true,
+  :monitor    => true,
+  :log_output => true
+}
+
+Daemons.run(script_file,options)

data/generators/processor/templates/poller.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+# Make sure stdout and stderr write out without delay for using with daemon like scripts
+STDOUT.sync = true; STDOUT.flush
+STDERR.sync = true; STDERR.flush
+
+# The daemons gem sets our cwd to /, which Rails doesn't work well with.
+Dir.chdir APP_ROOT
+
+#Try to Load Merb
+merb_init_file = File.expand_path(File.dirname(__FILE__)+'/../config/merb_init')
+if File.exists? merb_init_file
+  require File.expand_path(File.dirname(__FILE__)+'/../config/boot')
+  #need this because of the CWD
+  Merb.root = MERB_ROOT
+  require merb_init_file
+else
+  # Load Rails
+  RAILS_ROOT=File.expand_path(File.join(File.dirname(__FILE__), '..'))
+  require File.join(RAILS_ROOT, 'config', 'boot')
+  require File.join(RAILS_ROOT, 'config', 'environment')
+end
+
+# Start it up!
+require 'activemessaging'
+ActiveMessaging.load_activemessaging
+ActiveMessaging.start

data/generators/processor/templates/processor.rb

@@ -0,0 +1,8 @@
+class <%= class_name %>Processor < ApplicationProcessor
+
+  subscribes_to :<%= singular_name %>
+
+  def on_message(message)
+    logger.debug "<%= class_name %>Processor received: " + message
+  end
+end

data/generators/processor/templates/processor_test.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'activemessaging/test_helper'
+require File.dirname(__FILE__) + '/../../app/processors/application'
+
+class <%= class_name %>ProcessorTest < Test::Unit::TestCase
+  include ActiveMessaging::TestHelper
+  
+  def setup
+    load File.dirname(__FILE__) + "/../../app/processors/<%= file_name %>_processor.rb"
+    @processor = <%= class_name %>Processor.new
+  end
+  
+  def teardown
+    @processor = nil
+  end  
+
+  def test_<%= file_name %>_processor
+    @processor.on_message('Your test message here!')
+  end
+end

data/generators/tracer/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Generates a stub ActiveMessaging Tracing Controller.
+
+Examples:
+    ./script/generate tracer Tracer
+    will create:
+        /app/processors/tracer_processor.rb
+        /app/views/tracer/index.rhtml

data/generators/tracer/templates/controller.rb

@@ -0,0 +1,14 @@
+class <%= class_name %>Controller < ApplicationController
+  include ActiveMessaging::MessageSender
+  
+  publishes_to :trace
+
+  def index
+  end
+
+  def clear
+    publish :trace, "<trace-control>clear</trace-control>"
+    redirect_to :action=>'index'
+  end
+
+end

data/generators/tracer/templates/helper.rb

@@ -0,0 +1,2 @@
+module <%= class_name %>Helper
+end

data/generators/tracer/templates/index.rhtml

@@ -0,0 +1,4 @@
+<%=button_to 'Clear', :action=>'clear'%>
+
+<%=image_tag '../trace.png', :id => 'graph'  %>
+

data/generators/tracer/templates/layout.rhtml

@@ -0,0 +1,16 @@
+<html>
+	<head>
+		<meta http-equiv="Content-type" content="text/html; charset=utf-8" />
+		<title>Tracer</title>
+		<%=javascript_include_tag :defaults %>
+    </head>
+	<body>
+		<h2>Tracer</h2>
+
+		<% if @flash[:note] -%> 
+		<div id="flash"><%= @flash[:note] %></div> 
+		<% end -%> 
+		
+		<%= @content_for_layout %>
+	</body>
+</html>

data/generators/tracer/templates/trace_processor.rb

@@ -0,0 +1,100 @@
+require 'mpath'
+require 'active_support'
+
+class Dot
+  
+  attr_accessor :name, :nodes, :edges, :clean_names
+  
+  def initialize name
+    @name = name
+    @nodes = {}
+    @clean_names = {}
+    @edges = []
+    yield self
+  end
+
+  def node name, params = {}
+    @nodes[clean_name(name)] = params.stringify_keys.reverse_merge "label"=>name
+  end 
+
+  def clean_name name
+    @clean_names[name] = "node#{@clean_names.length+1}" if @clean_names[name].nil?
+    @clean_names[name]
+  end
+  
+  def edge from, to
+    edge = [clean_name(from), clean_name(to)]
+    @edges << edge unless @edges.member? edge
+  end 
+
+  def to_s
+    dot = "digraph #{@name} {\n"
+    @nodes.each do |node_name, options|
+      dot += "\t#{node_name.to_s}"
+      optionstrings = []
+      options.keys.sort.each do |key|
+        optionstrings << "#{key}=\"#{options[key]}\""
+      end
+      dot += " [#{optionstrings.join(', ')}]" if optionstrings.length>0
+      dot += ";\n"
+    end
+    @edges.each {|e| dot += "\t#{e[0].to_s}->#{e[1].to_s};\n"}
+    dot += "}\n"
+  end
+  
+  def == other
+    (other.name == name) && (other.nodes == nodes) && (other.edges == edges) && (other.clean_names == clean_names)
+  end
+end
+
+class TraceProcessor < ActiveMessaging::Processor
+  subscribes_to :trace
+
+  @@dot = Dot.new("Trace") {}
+
+  class << self
+
+  end
+  
+  def dot
+    @@dot
+  end
+  
+  def on_message(message)    
+    xml = Mpath.parse(message)
+    if (xml.sent?) then
+      from = xml.sent.from.to_s
+      queue = xml.sent.queue.to_s
+
+      @@dot.node from
+      @@dot.node queue, "shape" => 'box'
+      @@dot.edge from, queue #hah - could do from => to
+    elsif (xml.received?) then
+      by = xml.received.by.to_s
+      queue = xml.received.queue.to_s
+
+      @@dot.node queue, "shape" => 'box'
+      @@dot.node by
+      @@dot.edge queue, by
+    elsif (xml.trace_control) then
+      command = xml.trace_control.to_s
+     begin
+        send command
+      rescue
+        puts "TraceProcessor: I don't understand the command #{command}"
+      end
+    end
+    create_image
+  end
+
+  def create_image
+    File.open(DOT_FILE, "w") {|f| f.puts @@dot.to_s }
+    output_file = APP_ROOT + "/public/trace.png"
+    `dot -Tpng -o #{output_file} #{DOT_FILE}`
+  end
+
+  def clear
+    @@dot = Dot.new("Trace") {}
+  end
+
+end

data/generators/tracer/tracer_generator.rb

@@ -0,0 +1,25 @@
+class TracerGenerator < RubiGen::Base
+  def manifest
+    record do |m|
+      path = 'app/controllers'
+      m.directory path
+      m.template 'controller.rb', File.join(path, "#{file_name}_controller.rb")
+
+      path = 'app/processors'
+      m.directory path
+      m.template 'trace_processor.rb', File.join(path, "#{file_name}_processor.rb")
+
+      path = 'app/helpers'
+      m.directory path
+      m.template 'helper.rb', File.join(path, "#{file_name}_helper.rb")
+
+      path = 'app/views/layouts'
+      m.directory path
+      m.file 'layout.rhtml', File.join(path, "#{file_name}.rhtml")
+
+      path = "app/views/#{file_name}"
+      m.directory path
+      m.file 'index.rhtml', File.join(path, "index.rhtml")
+    end
+  end
+end

data/init.rb

@@ -0,0 +1 @@
+require 'activemessaging'

data/lib/activemessaging.rb

@@ -0,0 +1,133 @@
+require 'logger'
+require 'active_support/all'
+require 'ostruct'
+
+if defined?(Rails::Railtie)
+  require 'activemessaging/railtie.rb'
+end
+
+module ActiveMessaging
+
+  ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+  # Used to indicate that the processing for a thread shoud complete
+  class StopProcessingException < Interrupt #:nodoc:
+  end
+
+  # Used to indicate that the processing on a message should cease,
+  # and the message should be returned back to the broker as best it can be
+  class AbortMessageException < Exception #:nodoc:
+  end
+
+  # Used to indicate that the processing on a message should cease,
+  # but no further action is required
+  class StopFilterException < Exception #:nodoc:
+  end
+
+  def self.logger
+    @@logger = nil unless defined? @@logger
+    @@logger ||= Rails.logger if defined? Rails
+    @@logger ||= Logger.new(STDOUT)
+    @@logger
+  end
+
+  def self.logger=(logger)
+    @@logger = logger
+  end
+
+  def self.app_root
+    @@app_root ||= (ENV['APP_ROOT'] || (defined?(::Rails) && ::Rails.root) || ENV['RAILS_ROOT'] || File.expand_path(Dir.pwd))
+  end
+
+  def self.app_env
+    @@app_env  ||= (ENV['APP_ENV']  || (defined?(::Rails) && ::Rails.env)  || ENV['RAILS_ENV']  || 'development')
+  end
+
+  def self.load_extensions
+    require 'logger'
+    require 'activemessaging/gateway'
+    require 'activemessaging/adapter'
+    require 'activemessaging/message_sender'
+    require 'activemessaging/processor'
+    require 'activemessaging/filter'
+    require 'activemessaging/trace_filter'
+
+    # load all under the adapters dir
+    Dir[File.join(ROOT, 'lib', 'activemessaging', 'adapters', '*.rb')].each do |a|
+      begin
+        adapter_name = File.basename(a, ".rb")
+        require 'activemessaging/adapters/' + adapter_name
+      rescue RuntimeError, LoadError => e
+        logger.warn "ActiveMessaging: adapter #{adapter_name} not loaded: #{ e.message }"
+      end
+    end
+  end
+
+  def self.load_config
+    # Skip loading config if there are no custom processors as the generator 
+    # is likely running since application_processor.rb and another processor
+    # should exist when running rails. 
+    if Dir["#{app_root}/app/processors/*.rb"].size() <= 1
+	return
+    end
+    path = File.expand_path("#{app_root}/config/messaging.rb")
+    begin
+      load path 
+    rescue
+      raise $!, " ActiveMessaging: problems trying to load '#{path}': \n\t#{$!.message}"
+    end
+  end
+
+  def self.load_processors(first=true)
+    logger.info "ActiveMessaging: Loading #{app_root}/app/processors/application_processor.rb" if first
+    load "#{app_root}/app/processors/application_processor.rb" if File.exist?("#{app_root}/app/processors/application_processor.rb")
+    Dir["#{app_root}/app/processors/*.rb"].each do |f|
+      unless f.match(/\/application_processor.rb/)
+        logger.info "ActiveMessaging: Loading #{f}" if first
+        load f
+      end
+    end
+  end
+
+  def self.reload_activemessaging
+    # this is resetting the messaging.rb
+    ActiveMessaging::Gateway.filters = []
+    ActiveMessaging::Gateway.named_destinations = {}
+    ActiveMessaging::Gateway.processor_groups = {}
+
+    # now load the config
+    load_config
+    load_processors(false)
+  end
+
+  def self.load_activemessaging
+    load_extensions
+    load_config
+    load_processors
+  end
+
+  def self.start
+    if ActiveMessaging::Gateway.subscriptions.empty?
+      err_msg = <<-EOM
+
+      ActiveMessaging Error: No subscriptions.
+
+      If you have no processor classes in app/processors, add them using the command:
+        script/generate processor DoSomething"
+
+      If you have processor classes, make sure they include in the class a call to 'subscribes_to':
+        class DoSomethingProcessor < ActiveMessaging::Processor
+          subscribes_to :do_something
+          # ...
+        end
+
+      EOM
+      puts err_msg
+      logger.error err_msg
+      exit
+    end
+
+    Gateway.start
+  end
+
+end