eventbus 0.0.20

data/admin/test/functional/applications_controller_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+class ApplicationsControllerTest < ActionController::TestCase
+  setup do
+    @application = applications(:one)
+  end
+
+  test "should get index" do
+    get :index
+    assert_response :success
+    assert_not_nil assigns(:applications)
+  end
+
+  test "should get new" do
+    get :new
+    assert_response :success
+  end
+
+  test "should create application" do
+    assert_difference('Application.count') do
+      post :create, application: @application.attributes
+    end
+
+    assert_redirected_to application_path(assigns(:application))
+  end
+
+  test "should show application" do
+    get :show, id: @application
+    assert_response :success
+  end
+
+  test "should get edit" do
+    get :edit, id: @application
+    assert_response :success
+  end
+
+  test "should update application" do
+    put :update, id: @application, application: @application.attributes
+    assert_redirected_to application_path(assigns(:application))
+  end
+
+  test "should destroy application" do
+    assert_difference('Application.count', -1) do
+      delete :destroy, id: @application
+    end
+
+    assert_redirected_to applications_path
+  end
+end

data/admin/test/functional/message_routes_controller_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+class MessageRoutesControllerTest < ActionController::TestCase
+  setup do
+    @message_route = message_routes(:one)
+  end
+
+  test "should get index" do
+    get :index
+    assert_response :success
+    assert_not_nil assigns(:message_routes)
+  end
+
+  test "should get new" do
+    get :new
+    assert_response :success
+  end
+
+  test "should create message_route" do
+    assert_difference('MessageRoute.count') do
+      post :create, message_route: @message_route.attributes
+    end
+
+    assert_redirected_to message_route_path(assigns(:message_route))
+  end
+
+  test "should show message_route" do
+    get :show, id: @message_route
+    assert_response :success
+  end
+
+  test "should get edit" do
+    get :edit, id: @message_route
+    assert_response :success
+  end
+
+  test "should update message_route" do
+    put :update, id: @message_route, message_route: @message_route.attributes
+    assert_redirected_to message_route_path(assigns(:message_route))
+  end
+
+  test "should destroy message_route" do
+    assert_difference('MessageRoute.count', -1) do
+      delete :destroy, id: @message_route
+    end
+
+    assert_redirected_to message_routes_path
+  end
+end

data/admin/test/functional/message_types_controller_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+class MessageTypesControllerTest < ActionController::TestCase
+  setup do
+    @message_type = message_types(:one)
+  end
+
+  test "should get index" do
+    get :index
+    assert_response :success
+    assert_not_nil assigns(:message_types)
+  end
+
+  test "should get new" do
+    get :new
+    assert_response :success
+  end
+
+  test "should create message_type" do
+    assert_difference('MessageType.count') do
+      post :create, message_type: @message_type.attributes
+    end
+
+    assert_redirected_to message_type_path(assigns(:message_type))
+  end
+
+  test "should show message_type" do
+    get :show, id: @message_type
+    assert_response :success
+  end
+
+  test "should get edit" do
+    get :edit, id: @message_type
+    assert_response :success
+  end
+
+  test "should update message_type" do
+    put :update, id: @message_type, message_type: @message_type.attributes
+    assert_redirected_to message_type_path(assigns(:message_type))
+  end
+
+  test "should destroy message_type" do
+    assert_difference('MessageType.count', -1) do
+      delete :destroy, id: @message_type
+    end
+
+    assert_redirected_to message_types_path
+  end
+end

data/admin/test/functional/messages_controller_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+class MessagesControllerTest < ActionController::TestCase
+  setup do
+    @message = messages(:one)
+  end
+
+  test "should get index" do
+    get :index
+    assert_response :success
+    assert_not_nil assigns(:messages)
+  end
+
+  test "should get new" do
+    get :new
+    assert_response :success
+  end
+
+  test "should create message" do
+    assert_difference('Message.count') do
+      post :create, message: @message.attributes
+    end
+
+    assert_redirected_to message_path(assigns(:message))
+  end
+
+  test "should show message" do
+    get :show, id: @message
+    assert_response :success
+  end
+
+  test "should get edit" do
+    get :edit, id: @message
+    assert_response :success
+  end
+
+  test "should update message" do
+    put :update, id: @message, message: @message.attributes
+    assert_redirected_to message_path(assigns(:message))
+  end
+
+  test "should destroy message" do
+    assert_difference('Message.count', -1) do
+      delete :destroy, id: @message
+    end
+
+    assert_redirected_to messages_path
+  end
+end

data/admin/test/performance/browsing_test.rb

@@ -0,0 +1,12 @@
+require 'test_helper'
+require 'rails/performance_test_help'
+
+class BrowsingTest < ActionDispatch::PerformanceTest
+  # Refer to the documentation for all available options
+  # self.profile_options = { :runs => 5, :metrics => [:wall_time, :memory]
+  #                          :output => 'tmp/performance', :formats => [:flat] }
+
+  def test_homepage
+    get '/'
+  end
+end

data/admin/test/test_helper.rb

@@ -0,0 +1,13 @@
+ENV["RAILS_ENV"] = "test"
+require File.expand_path('../../config/environment', __FILE__)
+require 'rails/test_help'
+
+class ActiveSupport::TestCase
+  # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
+  #
+  # Note: You'll currently still have to declare fixtures explicitly in integration tests
+  # -- they do not yet inherit this setting
+  fixtures :all
+
+  # Add more helper methods to be used by all tests here...
+end

data/admin/test/unit/application_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class ApplicationTest < ActiveSupport::TestCase
+  # test "the truth" do
+  #   assert true
+  # end
+end

data/admin/test/unit/helpers/applications_helper_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class ApplicationsHelperTest < ActionView::TestCase
+end

data/admin/test/unit/helpers/message_routes_helper_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class MessageRoutesHelperTest < ActionView::TestCase
+end

data/admin/test/unit/helpers/message_types_helper_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class MessageTypesHelperTest < ActionView::TestCase
+end

data/admin/test/unit/helpers/messages_helper_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class MessagesHelperTest < ActionView::TestCase
+end

data/admin/test/unit/message_route_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class MessageRouteTest < ActiveSupport::TestCase
+  # test "the truth" do
+  #   assert true
+  # end
+end

data/admin/test/unit/message_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class MessageTest < ActiveSupport::TestCase
+  # test "the truth" do
+  #   assert true
+  # end
+end

data/admin/test/unit/message_type_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class MessageTypeTest < ActiveSupport::TestCase
+  # test "the truth" do
+  #   assert true
+  # end
+end

data/bin/eventbus_dispatcher.rb

@@ -0,0 +1,118 @@
+#!/usr/bin/env ruby
+
+admin_base = ENV['EVENTBUS_PORTAL_BASE'] || './admin'
+puts "Loading environment.rb from: #{admin_base}/config/"
+
+require 'eventbus/service'
+require 'eventbus/message'
+require "#{admin_base}/config/environment"
+
+class DispatcherService < EventBus::Service
+ 
+  class ConfigurationError < RuntimeError
+  end
+   
+  def initialize
+    super("EVENT_BUS_CORE")
+    self.listen_queue = "dispatcher"
+    self.system_process = true
+  end
+  
+
+  def process_message(incoming_msg)
+    
+    msg = EventBus::Message.new("EVENT_BUS_CORE")
+    msg.load(incoming_msg)
+    
+    puts "Application Key: #{msg.application_id}" 
+    puts "Message ID: #{msg.message_id}"
+    puts "Message type: #{msg.message_type}"
+    puts "Message status: #{msg.status}"
+    
+    puts "Finding application for key #{msg.application_id}"
+    app = Application.find_by_key(msg.application_id)
+    
+    if app.nil?
+      puts "Unable to find an application with key #{msg.application_id}"
+      
+      msg.status = "DispatcherConfigurationError"
+      msg.is_error = true
+      msg.error_message = "Dispatcher has no application defined with key #{msg.application_id}"
+      log_message nil, msg
+      return
+    end
+    
+    puts "Found application: #{app.inspect}"
+    
+    msg_type = app.message_types.find_by_name(msg.message_type)
+    
+    if msg_type.nil?
+      log_message app, msg
+      puts "No configuration found for Application Key #{app.key}, MessageType #{msg.message_type}"
+      
+      msg.status = "DispatcherConfigurationError"
+      msg.is_error = true
+      msg.error_message = "Application #{app.name} (#{app.key}) has no message type defined as: (#{msg.message_type})"
+      log_message app, msg
+      return 
+    else
+      count = 0
+      msg_type.message_routes.where(:incoming_status => msg.status).each do | route | 
+        puts "Found route: #{route.dispatch_to}"
+        msg.send(:queue_name => route.dispatch_to)
+        count = count + 1
+        
+        log_message app, msg, msg_type, route
+      end
+      
+      if msg.is_error 
+        msg_type.message_routes.where(:match_errors => true).each do | route |
+          puts "Matched error route: #{route.dispatch_to}"
+          msg.send(:queue_name => route.dispatch_to)
+          count = count + 1
+          
+          log_message app, msg, msg_type, route
+        end
+      end
+
+      if count == 0
+        puts "No routes found for MessageType #{msg_type.name} Status #{msg.status}. Will log only."
+        log_message app, msg, msg_type
+      end
+    end
+    
+  end
+  
+  
+  def log_message(application = nil, msg = nil, msg_type = nil, route = nil)
+    
+    log = Message.new
+    
+    unless application.nil?
+      log.application_id = application.id
+    end
+    
+    unless msg.nil?
+      log.application_key = msg.application_id
+      log.message_type_name = msg.message_type
+      log.status = msg.status
+      log.content = msg.dump
+      log.is_error = msg.is_error
+      log.message_guid = msg.message_id  
+    end
+    
+    unless msg_type.nil?
+      log.message_type_id = msg_type.id
+    end
+    
+    unless route.nil?
+      log.dispatch_to = route.dispatch_to
+    end
+
+    log.save
+    
+  end
+
+end
+
+DispatcherService.new.start(:max_workers => 5)

data/bin/eventbus_emailer.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env railsrunner
+
+gem 'eventbus'
+require 'eventbus/service'
+require 'eventbus/message'
+
+class EmailRequest < EventBus::Message
+  def initialize
+    super("EVENT_BUS_CORE")
+  end
+  
+  def contents
+    get("web_message")
+  end
+end
+
+
+class EmailService < EventBus::Service
+  
+  def initialize
+    super("EVENT_BUS_CORE")
+    self.listen_queue = "email"
+  end
+  
+
+  def process_message(incoming_msg)
+    
+    msg = EmailRequest.new
+    msg.load(incoming_msg[:payload])
+    
+    puts "Sending email with contents:"
+    puts msg.contents
+    
+    msg.status = "EMAIL_SENT"
+    msg.send
+    
+  end
+
+end
+
+EmailService.new.start

data/lib/eventbus/connectors/amqp.rb

@@ -0,0 +1,70 @@
+
+require 'amqp'
+
+module AMQPConnectionDriver
+
+
+  def connection_driver_initialize
+    puts "AMQPConnectionDriver is loaded!"
+  end 
+
+  def get_connection
+    new_opts = {
+      :vhost => ENV["BROKER_VHOST"] || "eventbus",
+      :host => ENV["BROKER_HOST"] || "localhost",
+      :port => ENV["BROKER_PORT"] || 5672,
+      :user => ENV["BROKER_USER"] || "eventbus",
+      :pass => ENV["BROKER_PASS"] || "eventbus",
+      # :logging => opts.delete(:logging) || false,
+      #:logfile => opts.delete(:logfile) || STDOUT
+    }
+  
+    return AMQP.connect(new_opts)
+  
+  end
+
+  def send_raw(content, opts = {})
+    queue_name = opts.delete(:queue_name)
+    EventMachine.run do
+      client = get_connection
+      channel = AMQP::Channel.new(client)
+      
+      exchange = channel.direct('eventbus', :durable => true, 
+                                :persistent => true, :immediate => false, 
+                                :auto_delete => false)
+    
+      puts "Declaring queue: #{queue_name}"
+      q = channel.queue(queue_name, :durable => true, :persistent => true, :immediate => false, :auto_delete => false)
+      q.bind(exchange, :routing_key => queue_name)
+      
+      puts "Sending message..."
+      exchange.publish(content, :routing_key => queue_name) do
+        puts "Published to #{queue_name}: #{content}"
+        client.close { EventMachine.stop }
+      end
+    end
+  end
+  
+  def watch_queue(listen_queue)
+    EventMachine.run do
+      client = get_connection
+      channel = AMQP::Channel.new(client)
+      
+      @logger.info "Listening on #{listen_queue}"
+      
+      exchange = channel.direct('eventbus', :durable => true, 
+                                :persistent => true, :immediate => false, 
+                                :auto_delete => false)
+      
+      q = channel.queue(listen_queue, :durable => true, :persistent => true, :immediate => false, :auto_delete => false)
+      
+      
+      q.bind(exchange, :routing_key => listen_queue)
+     
+      q.subscribe do |headers, payload|
+        yield payload
+      end
+      
+    end
+  end
+end

data/lib/eventbus/connectors/bunny.rb

@@ -0,0 +1,71 @@
+# BunnyConnectionDriver is the original implementation of
+# the AMQP-based broker. I am trying to make this work with
+# straight Ruby AMQP driver, but this one is the default
+# until I get that working properly.
+
+module BunnyConnectionDriver
+
+  @@BunnyConnector_Connection = nil
+
+  def connection_driver_initialize
+    puts "BunnyConnectionDriver is loaded!"
+  end 
+
+  def get_connection
+      if @@BunnyConnector_Connection.nil?
+        new_opts = {
+          :vhost => ENV["BROKER_VHOST"] || "eventbus",
+          :host => ENV["BROKER_HOST"] || "localhost",
+          :port => ENV["BROKER_PORT"] || 5672,
+          :user => ENV["BROKER_USER"] || "eventbus",
+          :pass => ENV["BROKER_PASS"] || "eventbus",
+          # :logging => opts.delete(:logging) || false,
+          #:logfile => opts.delete(:logfile) || STDOUT
+        }
+      
+        @@BunnyConnector_Connection = Bunny.new(new_opts) 
+        @@BunnyConnector_Connection.start
+      end
+      
+      return @@BunnyConnector_Connection
+  
+  end
+
+  def send_raw(content, opts = {})
+    queue_name = opts.delete(:queue_name)
+    client = get_connection
+    
+    exchange = client.exchange('eventbus', :durable => true, :persistent => true, :immediate => false)
+    
+    puts "Declaring queue: #{queue_name}"
+    q = client.queue(queue_name, :durable => true, :persistent => true, :immediate => false)
+    q.bind('eventbus', :key => queue_name)
+    
+    puts "Publishing content to #{queue_name}: #{content}"
+    exchange.publish(content, :key => queue_name)
+    puts "Done!"
+    
+  end
+  
+  def watch_queue(listen_queue)
+  
+      b = get_connection
+      
+      @logger.info "Listening on #{listen_queue}"
+      
+      exchange = b.exchange('eventbus', :durable => true, :persistent => true, :immediate => false)
+      
+      q = b.queue(listen_queue, :durable => true, :persistent => true, :immediate => false)
+      q.bind(exchange, :key => listen_queue)
+      
+      q.pop do |msg|
+        if msg[:delivery_details].nil?
+          # Gotta figure out why this is necessary. Blech.
+          sleep 0.25
+        else
+          yield msg[:payload]
+        end
+      end
+      
+  end
+end

data/lib/eventbus/connectors/stomp.rb

@@ -0,0 +1,77 @@
+# This module is primarily intended for use with ActiveMQ, though 
+# it should work with any Stomp-speaking broker. 
+require 'stomp'
+module StompConnectionDriver
+
+  @@StompConnector_Connection = nil
+
+  def connection_driver_initialize
+    puts "StompConnectionDriver is loaded!"
+  end 
+
+  def get_connection
+      if @@StompConnector_Connection.nil?
+        opts = {
+          :host => ENV["BROKER_HOST"] || "localhost",
+          :port => ENV["BROKER_PORT"] || 61613,
+          :user => ENV["BROKER_USER"],
+          :pass => ENV["BROKER_PASS"],
+          # :logging => opts.delete(:logging) || false,
+          #:logfile => opts.delete(:logfile) || STDOUT
+        }
+      
+        stomp_url = ENV['STOMP_URL'] || 
+          "stomp://#{opts[:user]}:#{opts[:pass]}@#{opts[:host]}:#{opts[:port]}?initialReconnectDelay=5000&randomize=false&useExponentialBackOff=false"
+        @@StompConnector_Connection = Stomp::Client.new(stomp_url)
+      end
+      
+      return @@StompConnector_Connection
+  
+  end
+
+  # opts basically just gets passed to the Stomp client.send, so it can be things
+  # like :persistent => false, etc. :persistent is true by default.
+  def send_raw(content, opts = {})
+    
+    queue_name = opts.delete(:queue_name)
+    queue_name = "/queue/#{queue_name}"
+    
+    opts[:persistent] = true if opts[:persistent].nil?
+
+    # "Fix" an ActiveMQ "bug" where it assumes that any message with a content-length
+    # header is a bytes-message instead of a text message. This behavior prevents the
+    # message conent from showing up in the "Message Details" section when you try
+    # to view the message in ActiveMQ's admin interface. 
+    #
+    # Note that the *correct* behavior is the opposite of this: All Stomp messages
+    # are recommended to include content-length. However, this is the *less annoying*
+    # and *more useful* behavior. 
+    opts[:suppress_content_length] = true if opts[:suppress_content_length].nil?
+    
+    puts "Stomp sending message to: #{queue_name}"
+    
+    client = get_connection
+    client.publish(queue_name, content, opts)
+    
+  end
+  
+  def watch_queue(listen_queue)
+    client = get_connection
+    
+    queue_name = listen_queue.match('^/') ? listen_queue : "/queue/#{listen_queue}"
+    
+    # OK, so some assumption that we're using ActiveMQ here. We'll work that out eventually. The point
+    # is, though, that we want to allow for maximum parallelism -- not just by thread but also across 
+    # processes and machines. Therefore, don't lock the queue exclusively (i.e. don't kill other clients!)
+    # and only take blocks of one message rather than claiming large blocks. These assumptions should become
+    # configurable at some point, but for now it's not really a concern.
+    puts "Subscribing to #{queue_name}..."
+
+    client.subscribe(queue_name, {"activemq.prefetchSize" => 1, "activemq.exclusive" => false}) do |msg|
+      yield msg.body
+    end
+    
+    
+  end
+      
+end