beetle 0.1

data/lib/beetle/publisher.rb

@@ -0,0 +1,187 @@
+module Beetle
+  # Provides the publishing logic implementation.
+  class Publisher < Base
+
+    def initialize(client, options = {}) #:nodoc:
+      super
+      @exchanges_with_bound_queues = {}
+      @dead_servers = {}
+      @bunnies = {}
+    end
+
+    def publish(message_name, data, opts={}) #:nodoc:
+      opts = @client.messages[message_name].merge(opts.symbolize_keys)
+      exchange_name = opts.delete(:exchange)
+      opts.delete(:queue)
+      recycle_dead_servers unless @dead_servers.empty?
+      if opts[:redundant]
+        publish_with_redundancy(exchange_name, message_name, data, opts)
+      else
+        publish_with_failover(exchange_name, message_name, data, opts)
+      end
+    end
+
+    def publish_with_failover(exchange_name, message_name, data, opts) #:nodoc:
+      tries = @servers.size
+      logger.debug "Beetle: sending #{message_name}"
+      published = 0
+      opts = Message.publishing_options(opts)
+      begin
+        select_next_server
+        bind_queues_for_exchange(exchange_name)
+        logger.debug "Beetle: trying to send message #{message_name}:#{opts[:message_id]} to #{@server}"
+        exchange(exchange_name).publish(data, opts)
+        logger.debug "Beetle: message sent!"
+        published = 1
+      rescue Bunny::ServerDownError, Bunny::ConnectionError
+        stop!
+        mark_server_dead
+        tries -= 1
+        retry if tries > 0
+        logger.error "Beetle: message could not be delivered: #{message_name}"
+      end
+      published
+    end
+
+    def publish_with_redundancy(exchange_name, message_name, data, opts) #:nodoc:
+      if @servers.size < 2
+        logger.error "Beetle: at least two active servers are required for redundant publishing"
+        return publish_with_failover(exchange_name, message_name, data, opts)
+      end
+      published = []
+      opts = Message.publishing_options(opts)
+      loop do
+        break if published.size == 2 || @servers.empty? || published == @servers
+        begin
+          select_next_server
+          next if published.include? @server
+          bind_queues_for_exchange(exchange_name)
+          logger.debug "Beetle: trying to send #{message_name}:#{opts[:message_id]} to #{@server}"
+          exchange(exchange_name).publish(data, opts)
+          published << @server
+          logger.debug "Beetle: message sent (#{published})!"
+        rescue Bunny::ServerDownError, Bunny::ConnectionError
+          stop!
+          mark_server_dead
+        end
+      end
+      case published.size
+      when 0
+        logger.error "Beetle: message could not be delivered: #{message_name}"
+      when 1
+        logger.warn "Beetle: failed to send message redundantly"
+      end
+      published.size
+    end
+
+    RPC_DEFAULT_TIMEOUT = 10 #:nodoc:
+
+    def rpc(message_name, data, opts={}) #:nodoc:
+      opts = @client.messages[message_name].merge(opts.symbolize_keys)
+      exchange_name = opts.delete(:exchange)
+      opts.delete(:queue)
+      recycle_dead_servers unless @dead_servers.empty?
+      tries = @servers.size
+      logger.debug "Beetle: performing rpc with message #{message_name}"
+      result = nil
+      status = "TIMEOUT"
+      begin
+        select_next_server
+        bind_queues_for_exchange(exchange_name)
+        # create non durable, autodeleted temporary queue with a server assigned name
+        queue = bunny.queue
+        opts = Message.publishing_options(opts.merge :reply_to => queue.name)
+        logger.debug "Beetle: trying to send #{message_name}:#{opts[:message_id]} to #{@server}"
+        exchange(exchange_name).publish(data, opts)
+        logger.debug "Beetle: message sent!"
+        logger.debug "Beetle: listening on reply queue #{queue.name}"
+        queue.subscribe(:message_max => 1, :timeout => opts[:timeout] || RPC_DEFAULT_TIMEOUT) do |msg|
+          logger.debug "Beetle: received reply!"
+          result = msg[:payload]
+          status = msg[:header].properties[:headers][:status]
+        end
+        logger.debug "Beetle: rpc complete!"
+      rescue Bunny::ServerDownError, Bunny::ConnectionError
+        stop!
+        mark_server_dead
+        tries -= 1
+        retry if tries > 0
+        logger.error "Beetle: message could not be delivered: #{message_name}"
+      end
+      [status, result]
+    end
+
+    def purge(queue_name) #:nodoc:
+      each_server { queue(queue_name).purge rescue nil }
+    end
+
+    def stop #:nodoc:
+      each_server { stop! }
+    end
+
+    private
+
+    def bunny
+      @bunnies[@server] ||= new_bunny
+    end
+
+    def new_bunny
+      b = Bunny.new(:host => current_host, :port => current_port, :logging => !!@options[:logging],
+                    :user => Beetle.config.user, :pass => Beetle.config.password, :vhost => Beetle.config.vhost)
+      b.start
+      b
+    end
+
+    def recycle_dead_servers
+      recycle = []
+      @dead_servers.each do |s, dead_since|
+        recycle << s if dead_since < 10.seconds.ago
+      end
+      @servers.concat recycle
+      recycle.each {|s| @dead_servers.delete(s)}
+    end
+
+    def mark_server_dead
+      logger.info "Beetle: server #{@server} down: #{$!}"
+      @dead_servers[@server] = Time.now
+      @servers.delete @server
+      @server = @servers[rand @servers.size]
+    end
+
+    def select_next_server
+      return logger.error("Beetle: message could not be delivered - no server available") && 0 if @servers.empty?
+      set_current_server(@servers[((@servers.index(@server) || 0)+1) % @servers.size])
+    end
+
+    def create_exchange!(name, opts)
+      bunny.exchange(name, opts)
+    end
+
+    def bind_queues_for_exchange(exchange_name)
+      return if @exchanges_with_bound_queues.include?(exchange_name)
+      @client.exchanges[exchange_name][:queues].each {|q| queue(q) }
+      @exchanges_with_bound_queues[exchange_name] = true
+    end
+
+    # TODO: Refactor, fethch the keys and stuff itself
+    def bind_queue!(queue_name, creation_keys, exchange_name, binding_keys)
+      logger.debug("Creating queue with opts: #{creation_keys.inspect}")
+      queue = bunny.queue(queue_name, creation_keys)
+      logger.debug("Binding queue #{queue_name} to #{exchange_name} with opts: #{binding_keys.inspect}")
+      queue.bind(exchange(exchange_name), binding_keys)
+      queue
+    end
+
+    def stop!
+      begin
+        bunny.stop
+      rescue Exception
+        Beetle::reraise_expectation_errors!
+      ensure
+        @bunnies[@server] = nil
+        @exchanges[@server] = {}
+        @queues[@server] = {}
+      end
+    end
+  end
+end

data/lib/beetle/r_c.rb

@@ -0,0 +1,40 @@
+module Beetle
+  module RC #:nodoc:all
+
+    # message processing result return codes
+    class ReturnCode
+      def initialize(*args)
+        @recover = args.delete :recover
+        @failure = args.delete :failure
+        @name = args.first
+      end
+
+      def inspect
+        @name.blank? ? super : "Beetle::RC::#{@name}"
+      end
+
+      def recover?
+        @recover
+      end
+
+      def failure?
+        @failure
+      end
+    end
+
+    def self.rc(name, *args)
+      const_set name, ReturnCode.new(name, *args)
+    end
+
+    rc :OK
+    rc :Ancient, :failure
+    rc :AttemptsLimitReached, :failure
+    rc :ExceptionsLimitReached, :failure
+    rc :Delayed, :recover
+    rc :HandlerCrash, :recover
+    rc :HandlerNotYetTimedOut, :recover
+    rc :MutexLocked, :recover
+    rc :InternalError, :recover
+
+  end
+end

data/lib/beetle/subscriber.rb

@@ -0,0 +1,144 @@
+module Beetle
+  # Manages subscriptions and message processing on the receiver side of things.
+  class Subscriber < Base
+
+    # create a new subscriber instance
+    def initialize(client, options = {}) #:nodoc:
+      super
+      @handlers = {}
+      @amqp_connections = {}
+      @mqs = {}
+    end
+
+    # the client calls this method to subcsribe to all queues on all servers which have
+    # handlers registered for the given list of messages. this method does the following
+    # things:
+    #
+    # * creates all exchanges which have been registered for the given messages
+    # * creates and binds queues which have been registered for the exchanges
+    # * subscribes the handlers for all these queues
+    #
+    # yields before entering the eventmachine loop (if a block was given)
+    def listen(messages) #:nodoc:
+      EM.run do
+        exchanges = exchanges_for_messages(messages)
+        create_exchanges(exchanges)
+        queues = queues_for_exchanges(exchanges)
+        bind_queues(queues)
+        subscribe_queues(queues)
+        yield if block_given?
+      end
+    end
+
+    # stops the eventmachine loop
+    def stop! #:nodoc:
+      EM.stop_event_loop
+    end
+
+    # register handler for the given queues (see Client#register_handler)
+    def register_handler(queues, opts={}, handler=nil, &block) #:nodoc:
+      Array(queues).each do |queue|
+        @handlers[queue] = [opts.symbolize_keys, handler || block]
+      end
+    end
+
+    private
+
+    def exchanges_for_messages(messages)
+      @client.messages.slice(*messages).map{|_, opts| opts[:exchange]}.uniq
+    end
+
+    def queues_for_exchanges(exchanges)
+      @client.exchanges.slice(*exchanges).map{|_, opts| opts[:queues]}.flatten.uniq
+    end
+
+    def create_exchanges(exchanges)
+      each_server do
+        exchanges.each { |name| exchange(name) }
+      end
+    end
+
+    def bind_queues(queues)
+      each_server do
+        queues.each { |name| queue(name) }
+      end
+    end
+
+    def subscribe_queues(queues)
+      each_server do
+        queues.each { |name| subscribe(name) if @handlers.include?(name) }
+      end
+    end
+
+    # returns the mq object for the given server or returns a new one created with the
+    # prefetch(1) option. this tells it to just send one message to the receiving buffer
+    # (instead of filling it). this is necesssary to ensure that one subscriber always just
+    # handles one single message. we cannot ensure reliability if the buffer is filled with
+    # messages and crashes.
+    def mq(server=@server)
+      @mqs[server] ||= MQ.new(amqp_connection).prefetch(1)
+    end
+
+    def subscribe(queue_name)
+      error("no handler for queue #{queue_name}") unless @handlers.include?(queue_name)
+      opts, handler = @handlers[queue_name]
+      queue_opts = @client.queues[queue_name][:amqp_name]
+      amqp_queue_name = queue_opts
+      callback = create_subscription_callback(queue_name, amqp_queue_name, handler, opts)
+      logger.debug "Beetle: subscribing to queue #{amqp_queue_name} with key # on server #{@server}"
+      begin
+        queues[queue_name].subscribe(opts.slice(*SUBSCRIPTION_KEYS).merge(:key => "#", :ack => true), &callback)
+      rescue MQ::Error
+        error("Beetle: binding multiple handlers for the same queue isn't possible.")
+      end
+    end
+
+    def create_subscription_callback(queue_name, amqp_queue_name, handler, opts)
+      server = @server
+      lambda do |header, data|
+        begin
+          processor = Handler.create(handler, opts)
+          message_options = opts.merge(:server => server, :store => @client.deduplication_store)
+          m = Message.new(amqp_queue_name, header, data, message_options)
+          result = m.process(processor)
+          if result.recover?
+            sleep 1
+            mq(server).recover
+          elsif reply_to = header.properties[:reply_to]
+            status = result == Beetle::RC::OK ? "OK" : "FAILED"
+            exchange = MQ::Exchange.new(mq(server), :direct, "", :key => reply_to)
+            exchange.publish(m.handler_result.to_s, :headers => {:status => status})
+          end
+        rescue Exception
+          Beetle::reraise_expectation_errors!
+          # swallow all exceptions
+          logger.error "Beetle: internal error during message processing: #{$!}: #{$!.backtrace.join("\n")}"
+        end
+      end
+    end
+
+    def create_exchange!(name, opts)
+      mq.__send__(opts[:type], name, opts.slice(*EXCHANGE_CREATION_KEYS))
+    end
+
+    def bind_queue!(queue_name, creation_keys, exchange_name, binding_keys)
+      queue = mq.queue(queue_name, creation_keys)
+      exchange = exchange(exchange_name)
+      queue.bind(exchange, binding_keys)
+      queue
+    end
+
+    def amqp_connection(server=@server)
+      @amqp_connections[server] ||= new_amqp_connection
+    end
+
+    def new_amqp_connection
+      # FIXME: wtf, how to test that reconnection feature....
+      con = AMQP.connect(:host => current_host, :port => current_port,
+                         :user => Beetle.config.user, :pass => Beetle.config.password, :vhost => Beetle.config.vhost)
+      con.instance_variable_set("@on_disconnect", proc{ con.__send__(:reconnect) })
+      con
+    end
+
+  end
+end

data/script/start_rabbit

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+# export RABBITMQ_MNESIA_BASE=/var/lib/rabbitmq/mnesia2
+# Defaults to /var/lib/rabbitmq/mnesia. Set this to the directory where Mnesia
+# database files should be placed.
+
+# export RABBITMQ_LOG_BASE
+# Defaults to /var/log/rabbitmq. Log files generated by the server will be placed
+# in this directory.
+
+export RABBITMQ_NODENAME=$1
+# Defaults to rabbit. This can be useful if you want to run more than one node
+# per machine - RABBITMQ_NODENAME should be unique per erlang-node-and-machine
+# combination. See clustering on a single machine guide at <http://www.rab-
+# bitmq.com/clustering.html#single-machine> for details.
+
+# RABBITMQ_NODE_IP_ADDRESS
+# Defaults to 0.0.0.0. This can be changed if you only want to bind to one net-
+# work interface.
+
+export RABBITMQ_NODE_PORT=$2
+# Defaults to 5672.
+
+# RABBITMQ_CLUSTER_CONFIG_FILE
+# Defaults to /etc/rabbitmq/rabbitmq_cluster.config. If this file is present it
+# is used by the server to auto-configure a RabbitMQ cluster.  See the clustering
+# guide at <http://www.rabbitmq.com/clustering.html> for details.
+
+rabbitmq-server

data/snafu.rb

@@ -0,0 +1,55 @@
+# The simplest case
+client.register_message(:something_happened)                  # => key: something_happened
+
+# with options
+client.register_message(:
+
+####################
+# Message Grouping #
+####################
+
+client.register_message(:delete_something, :group => :jobs)   # => key: jobs.delete_something
+client.register_message(:create_something, :group => :jobs)   # => key: jobs.create_something
+
+# You can register a handler for a message group
+client.register_handler(JobsHandler, :group => :jobs)         # bind queue with: jobs.*
+
+# And still register on single messages
+client.register_handler(DeletedJobHandler, :delete_something) # bind queue with: *.delete_something
+
+######################
+# Handler Definition #
+######################
+
+# With a Handler class that implements .process(message)
+client.register_handler(MyProcessor, :something_happened)                    # => queue: my_processor
+
+# With a String / Symbol and a block
+client.register_handler("Other Processor", :delete_something, :something_happened) lambda { |message| foobar(message) } # => queue: other_processor, bound with: *.delete_something and *.something_happened
+
+# With extra parameters
+client.register_handler(VeryImportant, :delete_something, :immediate => true) # queue: very_important, :immediate => true
+
+###################################
+# Wiring, Subscribing, Publishing #
+###################################
+client.wire! # => all the binding magic happens
+
+client.subscribe
+
+client.publish(:delete_something, 'payload')
+
+__END__
+
+Whats happening when wire! is called? (pseudocode)
+1. all the messages are registered
+     messages = [{:name => :delete_something, :group => :jobs, :bound => false}, {:name => :something_happened, :bound => false}]
+2. all the queues for the handlers are created and bound...
+     my_processor_queue = queue(:my_processor).bind(exchange, :key => '*.something_happened')
+     jobs_handler_queue = queue(:jobs_handler).bind(exchange, :key => 'jobs.*')
+     handlers_with_queues = [[jobs_handler_queue, JobsHandler], [my_processor_queue, block_or_class]]
+3. every handler definition binds a queue for the handler to a list of messages and marks the message as bound.
+4. If in the end a message isn't bound to a queue at least once, an exception is raised
+
+Exceptions will be thrown if:
+* after all m