activemessaging 0.6.0

data/lib/activemessaging/message_sender.rb

@@ -0,0 +1,30 @@
+require 'logger'
+
+module ActiveMessaging
+
+  # This is a module so that we can send messages from (for example) web page controllers, or can receive a single message
+  module MessageSender
+
+    def self.included(included_by)
+      class << included_by
+        def publishes_to destination_name
+          Gateway.find_destination destination_name
+        end
+
+        def receives_from destination_name
+          Gateway.find_destination destination_name
+        end
+      end
+    end
+
+    def publish destination_name, message, headers={}, timeout=10
+      Gateway.publish(destination_name, message, self.class, headers, timeout)
+    end
+
+    def receive destination_name, headers={}, timeout=10
+      Gateway.receive(destination_name, self.class, headers, timeout)
+    end
+
+  end
+
+end

data/lib/activemessaging/named_base.rb

@@ -0,0 +1,54 @@
+#Adapter to rubigen / rails
+
+if defined?(Rails)
+  class NamedBase < Rails::Generator::NamedBase
+  end
+else
+  class NamedBase < RubiGen::Base
+    attr_reader   :name, :class_name, :singular_name, :plural_name
+    attr_reader   :class_path, :file_path, :class_nesting, :class_nesting_depth
+    alias_method :file_name, :singular_name
+    alias_method :actions, :args
+  
+    def initialize(runtime_args, runtime_options={})
+      super
+    
+      base_name = self.args.first
+      assign_names!(base_name)
+    end
+  
+    protected
+  
+    def assign_names!(name)
+      @name = name
+      base_name, @class_path, @file_path, @class_nesting, @class_nesting_depth = extract_modules(@name)
+      @class_name_without_nesting, @singular_name, @plural_name = inflect_names(base_name)
+      if @class_nesting.empty?
+        @class_name = @class_name_without_nesting
+      else
+        @table_name = @class_nesting.underscore << "_" << @table_name
+        @class_name = "#{@class_nesting}::#{@class_name_without_nesting}"
+      end
+    end
+
+    # Extract modules from filesystem-style or ruby-style path:
+    #   good/fun/stuff
+    #   Good::Fun::Stuff
+    # produce the same results.
+    def extract_modules(name)
+      modules = name.include?('/') ? name.split('/') : name.split('::')
+      name    = modules.pop
+      path    = modules.map { |m| m.underscore }
+      file_path = (path + [name.underscore]).join('/')
+      nesting = modules.map { |m| m.camelize }.join('::')
+      [name, path, file_path, nesting, modules.size]
+    end
+
+    def inflect_names(name)
+      camel  = name.camelize
+      under  = camel.underscore
+      plural = under.pluralize
+      [camel, under, plural]
+    end
+  end
+end

data/lib/activemessaging/processor.rb

@@ -0,0 +1,45 @@
+# 'abstract' base class for ActiveMessaging processor classes
+module ActiveMessaging
+
+  class Processor
+    include MessageSender
+    
+    attr_reader :message
+  
+    class<<self
+      def subscribes_to destination_name, headers={}
+        ActiveMessaging::Gateway.subscribe_to destination_name, self, headers
+      end
+    end
+
+    def logger()
+      @@logger = ActiveMessaging.logger unless defined?(@@logger)
+      @@logger
+    end
+    
+    def on_message(message)
+      raise NotImplementedError.new("Implement the on_message method in your own processor class that extends ActiveMessaging::Processor")
+    end
+
+    def on_error(exception)
+      raise exception
+    end
+    
+    # Bind the processor to the current message so that the processor could
+    # potentially access headers and other attributes of the message
+    def process!(message)
+      @message = message
+      return on_message(message.body)
+    rescue Object=>err
+      begin
+        on_error(err)
+      rescue ActiveMessaging::AbortMessageException => rpe
+        logger.error "Processor:process! - AbortMessageException caught."
+        raise rpe
+      rescue Object=>ex
+        logger.error "Processor:process! - error in on_error, will propagate no further: #{ex.message}"
+      end
+    end
+
+  end
+end

data/lib/activemessaging/support.rb

@@ -0,0 +1,17 @@
+if defined? Rails
+  ActiveMessaging.logger.debug "Rails available: Adding reload hooks."
+  require 'dispatcher' unless defined?(::Dispatcher)
+  ::Dispatcher.class_eval do
+    
+    def self.prepare_application_for_dispatch
+      disp = new(STDOUT)
+      disp.run_callbacks :before_dispatch
+    end
+    
+    def self.reset_application_after_dispatch
+      disp = new(STDOUT)
+      disp.run_callbacks :after_dispatch, :enumerator => :reverse_each
+    end
+
+  end
+end

data/lib/activemessaging/test_helper.rb

@@ -0,0 +1,194 @@
+require 'test/unit'
+#require "#{File.dirname(__FILE__)}/trace_filter"
+
+
+module ActiveMessaging #:nodoc:
+  @@logger = nil
+
+  # def self.reload_activemessaging
+  # end
+
+  def self.logger
+    @@logger ||= MockLogger.new
+    @@logger
+  end
+  
+  class AbortMessageException < Exception #:nodoc:
+  end
+
+  class StopFilterException < Exception #:nodoc:
+  end
+
+  class Gateway
+    
+    def self.reset
+      unsubscribe
+      disconnect
+      @@filters = []
+      @@subscriptions = {}
+      @@named_destinations = {}
+      @@processor_groups = {}
+      @@current_processor_group = nil
+      @@connections = {}
+    end    
+  end
+  
+  module MessageSender
+    
+    @@__a13g_initialized__ = false
+    def publish_with_reset(destination_name, message, headers={}, timeout=10)
+      unless @@__a13g_initialized__
+        ActiveMessaging.reload_activemessaging 
+        @@__a13g_initialized__ = true
+      end
+      publish_without_reset(destination_name, message, headers, timeout)
+    end
+
+    alias_method_chain :publish, :reset
+    
+  end
+  
+  class TestMessage
+    attr_reader :headers
+    attr_accessor :body
+
+    def initialize(destination, headers = {}, body = "")
+      @headers, @body = headers, body
+      @headers['destination'] = destination
+    end
+    
+    def command
+      "MESSAGE"
+    end
+  end
+
+  module TestHelper
+    
+    # #Many thanks must go to the ActiveRecord fixture code
+    # #for showing how to properly alias setup and teardown
+    # def self.included(base)
+    #   base.extend(ClassMethods)
+    # 
+    #   class << base
+    #     alias_method_chain :method_added, :a13g
+    #   end
+    #   
+    # end
+    
+    # module ClassMethods
+    # 
+      # def method_added_with_a13g(method)
+      #   return if @__a13g_disable_method_added__
+      #   @__a13g_disable_method_added__ = true
+      #   
+      #   case method.to_s
+      #   when 'setup'
+      #     unless method_defined?(:setup_without_a13g)
+      #       alias_method :setup_without_a13g, :setup
+      #       define_method(:full_setup) do
+      #         setup_with_a13g
+      #         setup_without_a13g
+      #       end
+      #     end
+      #     alias_method :setup, :full_setup
+      #   when 'teardown'
+      #     unless method_defined?(:teardown_without_a13g)
+      #       alias_method :teardown_without_a13g, :teardown
+      #       define_method(:full_teardown) do
+      #         teardown_without_a13g
+      #         teardown_with_a13g
+      #       end
+      #     end
+      #     alias_method :teardown, :full_teardown
+      #   end
+      # 
+      #   method_added_without_a13g(method)
+      #   
+      #   @__a13g_disable_method_added__ = false
+      # end
+    # 
+    # end
+    
+    # def setup_with_a13g
+    #   ActiveMessaging.reload_activemessaging
+    # end
+    # 
+    # def teardown_with_a13g
+    #   ActiveMessaging::Gateway.reset
+    # end
+
+    def mock_publish destination, body, publisher=nil, headers={}
+      ActiveMessaging::Gateway.publish destination, body, publisher, headers
+    end
+
+    def assert_message destination, body
+      destination = ActiveMessaging::Gateway.find_destination(destination).value
+      error_message = <<-EOF
+      Message for '#{destination}' with '#{body}' is not present.
+      Messages:
+      #{ActiveMessaging::Gateway.connection('default').all_messages.inspect}
+      EOF
+      assert ActiveMessaging::Gateway.connection.find_message(destination, body), error_message
+    end
+      
+    def assert_no_message_with destination, body
+      destination = ActiveMessaging::Gateway.find_destination(destination).value
+      error_message = <<-EOF
+      Message for '#{destination}' with '#{body}' is present.
+      Messages:
+      #{ActiveMessaging::Gateway.connection('default').all_messages.inspect}
+      EOF
+      assert_nil ActiveMessaging::Gateway.connection('default').find_message(destination, body), error_message
+    end
+
+    def assert_no_messages destination
+      destination = ActiveMessaging::Gateway.find_destination(destination).value
+      error_message = <<-EOF
+      Expected no messages.
+      Messages:
+      #{ActiveMessaging::Gateway.connection('default').all_messages.inspect}
+      EOF
+      assert_equal [], ActiveMessaging::Gateway.connection('default').all_messages, error_message
+    end
+
+    def assert_subscribed destination
+      destination = ActiveMessaging::Gateway.find_destination(destination).value
+      error_message = <<-EOF
+      Not subscribed to #{destination}.
+      Subscriptions:
+      #{ActiveMessaging::Gateway.connection('default').subscriptions.inspect}
+      EOF
+      assert ActiveMessaging::Gateway.connection('default').find_subscription(destination), error_message
+    end
+
+    def assert_not_subscribed destination
+      destination = ActiveMessaging::Gateway.find_destination(destination).value
+      error_message = <<-EOF
+      Subscribed to #{destination}.
+      Subscriptions:
+      #{ActiveMessaging::Gateway.connection('default').subscriptions.inspect}
+      EOF
+      assert_nil ActiveMessaging::Gateway.connection('default').find_subscription(destination), error_message
+    end
+    
+    def assert_has_messages destination
+      destination_name = ActiveMessaging::Gateway.find_destination(destination).value
+      error_message = <<-EOF
+      No messages for #{destination_name}.
+      All messages:
+      #{ActiveMessaging::Gateway.connection('default').all_messages.inspect}
+      EOF
+      destination = ActiveMessaging::Gateway.connection('default').find_destination destination_name
+      assert !destination.nil? && !destination.messages.empty?, error_message
+    end
+  end
+  
+  class MockLogger
+    def error(*args) ; end
+    def warn(*args) ; end
+    def info(*args) ; end
+    def debug(*args) ; end
+  end
+
+end
+

data/lib/activemessaging/trace_filter.rb

@@ -0,0 +1,34 @@
+class TraceFilter< ActiveMessaging::Filter
+  include ActiveMessaging::MessageSender
+  
+  def initialize(options)
+    @queue = options[:queue]
+    TraceFilter.publishes_to @queue
+  end
+  
+  def process message, routing
+    
+    unless ( routing[:destination].name == @queue ) then
+      ActiveMessaging.logger.debug "Trace: direction = #{routing[:direction]} publisher=#{routing[:publisher]} queue=#{routing[:destination].name} @queue=#{@queue}"
+      if routing[:direction].to_sym==:outgoing then
+        "trace from outgoing"
+        publish @queue, "<sent>"+
+                        "<from>#{routing[:publisher]}</from>" +        
+                        "<queue>#{routing[:destination].name}</queue>" +
+                        "<message>#{message.body}</message>" + 
+                        "</sent>"
+      end
+      if routing[:direction].to_sym==:incoming then
+        "trace from incoming"
+        publish @queue, "<received>"+
+                        "<by>#{routing[:receiver]}</by>" +        
+                        "<queue>#{routing[:destination].name}</queue>" +
+                        "<message>#{message.body}</message>" + 
+                        "</received>"
+      end
+    end
+
+  end
+  
+end
+

data/messaging.rb.example

@@ -0,0 +1,5 @@
+
+ActiveMessaging::Dispatcher.define do |s|
+  s.queue :orders, '/queue/Orders'
+  s.queue :completed, '/queue/CompletedItems'
+end

data/tasks/start_consumers.rake

@@ -0,0 +1,8 @@
+namespace "activemessaging" do
+
+  desc 'Run all consumers'
+  task :start_consumers do
+    load File.dirname(__FILE__) + '/../poller.rb'
+  end
+  
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification 
+name: activemessaging
+version: !ruby/object:Gem::Version 
+  version: 0.6.0
+platform: ruby
+authors: 
+- jon.tirsen
+- kookster
+- olle.jonsson
+- sylvain.perez
+- anti.god.botherer
+- uwe.kubosch
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-08-15 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rubigen
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.5.2
+    version: 
+description: ActiveMessaging is an attempt to bring the simplicity and elegance of rails development to the world of messaging. Messaging, (or event-driven architecture) is widely used for enterprise integration, with frameworks such as Java's JMS, and products such as ActiveMQ, Tibco, IBM MQSeries, etc.
+email: activemessaging-discuss@googlegroups.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- generators/a13g_test_harness/a13g_test_harness_generator.rb
+- generators/a13g_test_harness/templates/active_messaging_test.rhtml
+- generators/a13g_test_harness/templates/active_messaging_test_controller.rb
+- generators/a13g_test_harness/templates/index.rhtml
+- generators/processor/templates/application.rb
+- generators/processor/templates/poller.rb
+- generators/processor/templates/broker.yml
+- generators/processor/templates/processor.rb
+- generators/processor/templates/jruby_poller
+- generators/processor/templates/poller
+- generators/processor/templates/messaging.rb
+- generators/processor/templates/processor_test.rb
+- generators/processor/processor_generator.rb
+- generators/processor/USAGE
+- generators/tracer/tracer_generator.rb
+- generators/tracer/templates/helper.rb
+- generators/tracer/templates/controller.rb
+- generators/tracer/templates/layout.rhtml
+- generators/tracer/templates/index.rhtml
+- generators/tracer/templates/trace_processor.rb
+- generators/tracer/USAGE
+- generators/filter/filter_generator.rb
+- generators/filter/templates/filter_test.rb
+- generators/filter/templates/filter.rb
+- generators/filter/USAGE
+- lib/activemessaging/message_sender.rb
+- lib/activemessaging/support.rb
+- lib/activemessaging/adapters/reliable_msg.rb
+- lib/activemessaging/adapters/test.rb
+- lib/activemessaging/adapters/jms.rb
+- lib/activemessaging/adapters/asqs.rb
+- lib/activemessaging/adapters/stomp.rb
+- lib/activemessaging/adapters/wmq.rb
+- lib/activemessaging/adapters/base.rb
+- lib/activemessaging/gateway.rb
+- lib/activemessaging/adapter.rb
+- lib/activemessaging/named_base.rb
+- lib/activemessaging/processor.rb
+- lib/activemessaging/trace_filter.rb
+- lib/activemessaging/test_helper.rb
+- lib/activemessaging/filter.rb
+- lib/activemessaging.rb
+- tasks/start_consumers.rake
+- Rakefile
+- messaging.rb.example
+has_rdoc: true
+homepage: http://code.google.com/p/activemessaging/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.2
+signing_key: 
+specification_version: 2
+summary: ActiveMessaging is an attempt to bring the simplicity and elegance of rails development to the world of messaging. Messaging, (or event-driven architecture) is widely used for enterprise integration, with frameworks such as Java's JMS, and products such as ActiveMQ, Tibco, IBM MQSeries, etc.
+test_files: []
+