cottontail 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in cottontail.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/cottontail.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "cottontail/version"
+
+Gem::Specification.new do |s|
+  s.name        = "cottontail"
+  s.version     = Cottontail::VERSION
+  s.authors     = ["Rudolf Schmidt"]
+
+  s.homepage    = "http://github.com/rudionrails/cottontail"
+  s.summary     = %q{Sinatra inspired wrapper around the AMQP Bunny gem}
+  s.description = %q{Convenience wrapper around the AMQP Bunny gem to better handle routing_key specific messages}
+
+  s.rubyforge_project = "cottontail"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/lib/cottontail.rb

@@ -0,0 +1,245 @@
+require 'logger'
+
+module Cottontail
+  class RouteNotFound < StandardError; end
+
+  module Helpers
+    attr_reader :message, :last_error
+
+    def payload; message[:payload]; end
+    def delivery_details; message[:delivery_details]; end
+    def routing_key; message[:routing_key]; end
+  end
+
+  class Base
+    include Helpers
+
+    class << self
+      attr_reader :routes
+
+      # convenience method to start the instance
+      def run; new.run; end
+
+      # Reset the class
+      def reset!
+        @settings = {}
+
+        @errors = {}
+        @routes = {}
+      end
+
+      # Set runtime configuration
+      #
+      # @example
+      #   set :host, "localhost"
+      #   set(:host) { "localhost" } # will be called on first usage
+      def set( key, *args, &block )
+        @settings[ key ] = block ? block : args
+      end
+
+      # Override the standard subscribe loop
+      #
+      # @example
+      #   subscribe :ack => false do |message|
+      #     puts "Received #{message.inspect}"
+      #     route! message
+      #   end
+      def subscribe( options = {}, &block )
+        set :subscribe, options, compile!("subscribe", &block)
+      end
+
+      # Defines routing on class level
+      #
+      # @example
+      #   route "message.sent" do
+      #     ... stuff to do ...
+      #   end
+      def route( key, &block )
+        @routes[key] = compile!("route_#{key}", &block)
+      end
+
+      # Define error handlers
+      #
+      # @example
+      #   error RouteNotFound do
+      #     puts "Route not found for #{routing_key.inspect}"
+      #   end
+      def error( *codes, &block )
+        codes << :default if codes.empty? # the default error handling
+
+        codes.each { |c| (@errors[c] ||= []) << compile!("error_#{c}", &block) }
+      end
+
+      # Route on class level
+      #
+      # @example
+      #   route! :payload => "some message", :routing_key => "v2.message.sent"
+      def route!( message )
+        new.route!( message )
+      end
+
+
+      # Retrieve the settings
+      #
+      # In case a block was given to a settings, it will be called upon first execution and set
+      # as the setting's value.
+      def settings( key )
+        if @settings[key].is_a? Proc
+          @settings[key] = @settings[key].call
+        end
+
+        @settings[key]
+      end
+
+      # Retrieve the error block for the passed Exception class
+      #
+      # If no class matches, the default will be returned in case it has been set (else nil).
+      def errors( klass )
+        @errors[klass] || @errors[:default]
+      end
+
+
+      private
+
+      def inherited( subclass )
+        subclass.reset!
+        super
+      end
+
+      # compiles a given proc to an unbound method to be called later on a different binding
+      def compile!( name, &block )
+        define_method name, &block
+        method = instance_method name
+        remove_method name
+
+        block.arity == 0 ? proc { |a,p| method.bind(a).call } : proc { |a,*p| method.bind(a).call(*p) }
+      end
+
+    end
+
+    def initialize
+      reset!
+    end
+
+    # Starts the consumer service and enters the subscribe loop.
+    def run
+      logger.debug "[Cottontial] Declaring exchange"
+      exchange  = client.exchange( *settings(:exchange) )
+
+      logger.debug "[Cottontial] Declaring queue"
+      queue     = client.queue( *settings(:queue) )
+
+      routes.keys.each do |key| 
+        logger.debug "[Cottontail] Binding #{key.inspect} to exchange"
+        queue.bind( exchange, :key => key )
+      end
+
+      logger.debug "[Cottontail] Entering subscribe loop"
+      subscribe! queue
+    rescue => e
+      @client.stop if @client
+      reset!
+
+      logger.error "#{e.class}: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
+
+      # raise when no retries are defined
+      raise( e, caller ) unless settings(:retries)
+
+      sleep settings(:delay_on_retry) if settings(:delay_on_retry)
+      retry
+    end
+
+    # performs the routing of the given AMQP message.
+    def route!( message )
+      @message = message
+      process!
+    rescue => err
+      @last_error = err
+
+      if errors(err.class).nil?
+        raise( err, caller )
+      else
+        errors(err.class).each { |block| block.call(self) }
+      end
+    end
+
+
+    private
+
+      def process!
+        key = @message[:delivery_details][:routing_key]
+
+        raise Cottontail::RouteNotFound.new(key) unless block = routes[key]
+        block.call(self)
+      end
+
+      def routes; self.class.routes; end
+
+      # Retrieve errors
+      def errors(code); self.class.errors(code); end
+
+      # Retrieve settings
+      def settings(key); self.class.settings(key); end
+
+      # Conveniently access the logger
+      def logger; settings(:logger); end
+
+      # Reset the instance
+      def reset!
+        @client = nil
+      end
+
+      def subscribe!( queue )
+        options, block = settings(:subscribe)
+
+        queue.subscribe( options ) { |m| block.call(self, m) }
+      end
+
+      def client
+        return @client if @client
+
+        @client = Bunny.new( bunny_options )
+        @client.start
+
+        @client
+      end
+
+      # The bunny gem itself is not able to handle multiple hosts - although multiple RabbitMQ instances may run in parralel.
+      #
+      # You may pass :hosts as option whensettings the client in order to cycle through them when a connection was lost.
+      def bunny_options
+        return {} unless options = settings(:client) and options = options.first
+
+        if hosts = options[:hosts]
+          host, port = hosts.shift
+          hosts << [host, port]
+
+          options.merge!( :host => host, :port => port )
+        end
+
+        options
+      end
+
+    public
+
+      # === Perform the initial setup
+      reset!
+
+      # default subscribe loop
+      set :subscribe, [{}, proc { |m| route! m }]
+
+      # default logger
+      set :logger, Logger.new(STDOUT)
+
+      # retry settings
+      set :retries, true
+      set :delay_on_retry, 2
+
+      # default bunny options
+      set :client,    {}
+      set :exchange,  "default", :type => :topic
+      set :queue,     "default"
+
+  end
+end
+

data/lib/cottontail/version.rb

@@ -0,0 +1,3 @@
+module Cottontail
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification 
+name: cottontail
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+  - Rudolf Schmidt
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-02-02 00:00:00 Z
+dependencies: []
+
+description: Convenience wrapper around the AMQP Bunny gem to better handle routing_key specific messages
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+  - .gitignore
+  - Gemfile
+  - Rakefile
+  - cottontail.gemspec
+  - lib/cottontail.rb
+  - lib/cottontail/version.rb
+homepage: http://github.com/rudionrails/cottontail
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+requirements: []
+
+rubyforge_project: cottontail
+rubygems_version: 1.8.9
+signing_key: 
+specification_version: 3
+summary: Sinatra inspired wrapper around the AMQP Bunny gem
+test_files: []
+
+has_rdoc: