cottontail 0.1.5 → 2.0.0.pre.1

data/lib/cottontail/configurable.rb

@@ -0,0 +1,68 @@
+require 'active_support/core_ext/module/delegation'
+require 'active_support/concern'
+
+module Cottontail #:nodoc:
+  module Configurable #:nodoc:
+    extend ActiveSupport::Concern
+
+    module ClassMethods #:nodoc:
+      delegate :set, :get, to: :config
+
+      def config
+        return @__config__ if defined?(@__config__)
+
+        @__config__ =
+          if respond_to?(:superclass) && superclass.respond_to?(:config)
+            superclass.config.inheritable_copy
+          else
+            # create a new "anonymous" class that will host the compiled
+            # reader methods
+            Class.new(Configuration).new
+          end
+      end
+
+      def configure
+        yield config
+      end
+    end
+
+    def config
+      self.class.config
+    end
+
+    private
+
+    class Configuration #:nodoc:
+      def initialize
+        reset!
+      end
+
+      # Set a configuration option.
+      #
+      # @example
+      #   set :logger, Yell.new($stdout)
+      #   set :logger, -> { Yell.new($stdout) }
+      def set(key, value = nil, &block)
+        @settings[key] = !block.nil? ? block : value
+      end
+
+      # Get a configuration option. It will be evalued of the first time
+      # of calling.
+      #
+      # @example
+      #   get :logger
+      def get(key)
+        if (value = @settings[key]).is_a?(Proc)
+          @settings[key] = value.call
+        end
+
+        @settings[key]
+      end
+
+      # @private
+      def reset!
+        @settings = {}
+      end
+    end
+  end
+end

data/lib/cottontail/consumer.rb

@@ -0,0 +1,215 @@
+require 'active_support/concern'
+
+require File.dirname(__FILE__) + '/configurable'
+require File.dirname(__FILE__) + '/consumer/launcher'
+require File.dirname(__FILE__) + '/consumer/session'
+require File.dirname(__FILE__) + '/consumer/collection'
+require File.dirname(__FILE__) + '/consumer/entity'
+
+module Cottontail
+  # The Cottontail::Consumer is the module for receiving
+  # asynchronous AMQP messages.
+  #
+  # @example A basic worker
+  #   class Worker
+  #     include Cottontail::Consumer
+  #
+  #     session ENV['RABBITMQ_URL'] do |worker, session|
+  #       channel = session.create_channel
+  #
+  #       queue = channel.queue('', durable: true)
+  #       worker.subscribe(queue, exclusive: true, ack: false)
+  #     end
+  #
+  #     consume do |delivery_info, properties, payload|
+  #       logger.info payload.inspect
+  #     end
+  #   end
+  #
+  # @example More custom worker
+  #   class Worker
+  #     include Cottontail::Consumer
+  #
+  #     session ENV['RABBITMQ_URL'] do |worker, session|
+  #       # You always need a separate channel
+  #       channel = session.create_channel
+  #
+  #       # Creates a `topic` exchange ('cottontail-exchange'), binds a
+  #       # queue ('cottontail-queue') to it and listens to any possible
+  #       # routing key ('#').
+  #       exchange = channel.topic('cottontail-exchange')
+  #       queue = channel.queue('cottontail-queue', durable: true)
+  #         .bind(exchange, routing_key: '#')
+  #
+  #       # Now you need to subscribe the worker instance to this queue.
+  #       worker.subscribe(queue, exclusive: true, ack: false)
+  #     end
+  #
+  #     consume 'custom-route' do |delivery_info, properties, payload|
+  #       logger.info "routing_key: 'custom-route' | #{payload.inspect}"
+  #     end
+  #
+  #     consume do |delivery_info, properties, payload|
+  #       logger.info "any routing key | #{payload.inspect}"
+  #     end
+  #   end
+  module Consumer
+    extend ActiveSupport::Concern
+
+    included do
+      include Cottontail::Configurable
+
+      # default settings
+      set :consumables, -> { Cottontail::Consumer::Collection.new }
+      set :session, -> { [nil, -> {}] }
+      set :logger, -> { Cottontail.get(:logger) }
+    end
+
+    module ClassMethods #:nodoc:
+      # Set the Bunny session.
+      #
+      # You are required to setup a standard Bunny session as you would
+      # when using Bunny directly. This enables you to be configurable to
+      # the maximum extend.
+      #
+      # @example Simple Bunny::Session
+      #   session ENV['RABBITMQ_URL'] do |session, worker|
+      #     channel = session.create_channel
+      #
+      #     queue = channel.queue('MyAwesomeQueue', durable: true)
+      #     worker.subscribe(queue, exclusive: true, ack: false)
+      #   end
+      #
+      # @example Subscribe to multiple queues
+      #   session ENV['RABBITMQ_URL'] do |session, worker|
+      #     channel = session.create_channel
+      #
+      #     queue_a = channel.queue('queue_a', durable: true)
+      #     worker.subscribe(queue_a, exclusive: true, ack: false)
+      #
+      #     queue_b = channel.queue('queue_b', durable: true)
+      #     worker.subscribe(queue_b, exclusive: true, ack: false)
+      #   end
+      def session(options = nil, &block)
+        set :session, [options, block]
+      end
+
+      # Method for consuming messages.
+      #
+      # When `:any` is provided as parameter, all messages will be routed to
+      # this block. This is the default.
+      #
+      # @example By routing key
+      #   consume route: 'message.sent' do |delivery_info, properties, payload|
+      #     # stuff to do
+      #   end
+      #
+      #   # you can also use a shortcut for this
+      #   consume "message.sent" do |delivery_info, properties, payload|
+      #     # stuff to do
+      #   end
+      #
+      # @example By multiple routing keys
+      #   consume route: ['message.sent', 'message.read'] do |delivery_info, properties, payload|
+      #     # stuff to do
+      #   end
+      #
+      #   # you can also use a shortcut for this
+      #   consume ["message.sent", "message.read"] do |delivery_info, properties, payload|
+      #     # stuff to do
+      #   end
+      #
+      # @example Scoped to a specific queue
+      #   consume route: 'message.sent', queue: 'chats' do |delivery_info, properties, payload|
+      #     # do stuff
+      #   end
+      #
+      # @example By message type (not yet implemented)
+      #   consume type: 'ChatMessage' do |delivery_info, properties, payload|
+      #     # stuff to do
+      #   end
+      #
+      # @example By multiple message types (not yet implemented)
+      #   consume type: ['ChatMessage', 'PushMessage'] do |delivery_info, properties, payload|
+      #     # stuff to do
+      #   end
+      #
+      def consume(route = {}, options = {}, &block)
+        options =
+          if route.is_a?(Hash)
+            route
+          else
+            { route: route }
+          end.merge(options)
+
+        get(:consumables).push(
+          Cottontail::Consumer::Entity.new(options, &block)
+        )
+      end
+
+      # Conveniently start the consumer
+      #
+      # @example Since setup
+      #   class Worker
+      #     include Cottontail::Consumer
+      #
+      #     # ... configuration ...
+      #   end
+      #
+      #   Worker.start
+      def start(blocking = true)
+        new.start(blocking)
+      end
+    end
+
+    def initialize
+      @__launcher__ = Cottontail::Consumer::Launcher.new(self)
+      @__session__ = Cottontail::Consumer::Session.new(self)
+
+      logger.debug '[Cottontail] initialized'
+    end
+
+    def start(blocking = true)
+      logger.info '[Cottontail] starting up'
+
+      @__session__.start
+      @__launcher__.start if blocking
+    end
+
+    def stop
+      logger.info '[Cottontail] shutting down'
+
+      # @__launcher__.stop
+      @__session__.stop
+    end
+
+    # @private
+    def subscribe(queue, options)
+      queue.subscribe(options) do |delivery_info, properties, payload|
+        consume(delivery_info, properties, payload)
+      end
+    end
+
+    private
+
+    def consume(delivery_info, properties, payload)
+      consumable = consumables.find(delivery_info, properties, payload)
+
+      if consumable.nil?
+        logger.error '[Cottontail] Could not consume message'
+      else
+        consumable.exec(self, delivery_info, properties, payload)
+      end
+    rescue => exception
+      logger.error exception
+    end
+
+    def consumables
+      config.get(:consumables)
+    end
+
+    def logger
+      config.get(:logger)
+    end
+  end
+end

data/lib/cottontail/consumer/collection.rb

@@ -0,0 +1,28 @@
+module Cottontail #:nodoc:
+  module Consumer #:nodoc:
+    # Holds the collection of entities
+    class Collection
+      def initialize
+        @items = []
+      end
+
+      # Pushes entity to the list and sorts it
+      def push(entity)
+        @items.push(entity).sort!
+      end
+
+      # {exchange: 'exchange', queue: 'queue', route: 'route'}
+      # {exchange: 'exchange', queue: 'queue', route: :any}
+      # {exchange: 'exchange', queue: :any, route: 'route'}
+      # {exchange: 'exchange', queue: :any, route: :any}
+      # {exchange: :any, queue: 'queue'}
+      # {exchange: :any, queue: :any}
+      def find(delivery_info, _properties = nil, _payload = nil)
+        @items
+          .select { |e| e.matches?(:exchange, delivery_info.exchange) }
+          .select { |e| e.matches?(:queue, delivery_info.consumer.queue.name) }
+          .find { |e| e.matches?(:route, delivery_info.routing_key) }
+      end
+    end
+  end
+end

data/lib/cottontail/consumer/entity.rb

@@ -0,0 +1,45 @@
+module Cottontail #:nodoc:
+  module Consumer #:nodoc:
+    class Entity #:nodoc:
+      include Comparable
+
+      VALID_KEYS = [:exchange, :queue, :route]
+
+      def initialize(options = {}, &block)
+        @options = options.keep_if { |k, _| VALID_KEYS.include?(k) }
+        @block = block
+      end
+
+      def matches?(key, value)
+        [value, nil, :any].include?(@options[key])
+      end
+
+      def exec(object, *args)
+        object.instance_exec(*args, &@block)
+      end
+
+      protected
+
+      def <=>(other)
+        comparables <=> other.comparables
+      end
+
+      def comparables
+        VALID_KEYS.map { |key| Property.new(@options[key] || '') }
+      end
+
+      class Property < String #:nodoc:
+        protected
+
+        def <=>(other)
+          case
+          when length == 0 && other.length == 0 then 0
+          when length == 0 then 1
+          when other.length == 0 then -1
+          else super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cottontail/consumer/launcher.rb

@@ -0,0 +1,32 @@
+require 'thread'
+
+module Cottontail #:nodoc:
+  module Consumer #:nodoc:
+    class Launcher #:nodoc:
+      SIGNALS = [:QUIT, :TERM, :INT]
+
+      def initialize(consumer)
+        @consumer = consumer
+        @launcher = nil
+      end
+
+      def start
+        stop unless @launcher.nil?
+
+        SIGNALS.each do |signal|
+          Signal.trap(signal) { Thread.new { stop } }
+        end
+
+        @launcher = Thread.new { sleep }
+        @launcher.join
+      end
+
+      def stop
+        @consumer.stop if @consumer.respond_to?(:stop)
+
+        @launcher.kill if @launcher.respond_to?(:kill)
+        @launcher = nil
+      end
+    end
+  end
+end

data/lib/cottontail/consumer/session.rb

@@ -0,0 +1,27 @@
+require 'bunny'
+
+module Cottontail #:nodoc:
+  module Consumer #:nodoc:
+    class Session #:nodoc:
+      def initialize(consumer)
+        @consumer = consumer
+        @options, @block = @consumer.config.get(:session)
+        @session = nil
+      end
+
+      def start
+        stop unless @session.nil?
+
+        @session = Bunny.new(@options)
+        @session.start
+
+        @consumer.instance_exec(@consumer, @session, &@block)
+      end
+
+      def stop
+        @session.stop if @session.respond_to?(:stop)
+        @session = nil
+      end
+    end
+  end
+end

data/lib/cottontail/version.rb

@@ -1,3 +1,3 @@
-module Cottontail
-  VERSION = "0.1.5"
+module Cottontail #:nodoc:
+  VERSION = '2.0.0.pre.1'
 end

data/spec/cottontail/configurable_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+RSpec.describe Cottontail::Configurable do
+  class ConfigurationFactory #:nodoc:
+    include Cottontail::Configurable
+  end
+
+  let(:config) { ConfigurationFactory.config }
+  before { config.reset! }
+
+  it 'responds to :get' do
+    expect(config).to respond_to(:get)
+  end
+
+  it 'responds to :set' do
+    expect(config).to respond_to(:set)
+  end
+
+  context 'String' do
+    let(:value) { 'value' }
+    before { config.set(:key, value) }
+
+    it 'returns the correct value' do
+      expect(config.get(:key)).to eq(value)
+    end
+  end
+
+  context 'Proc' do
+    let(:value) { -> { 'value' } }
+    before { config.set(:key, value) }
+
+    it 'returns the correct value' do
+      expect(config.get(:key)).to eq(value.call)
+    end
+
+    it 'calls only once' do
+      v = config.get(:key)
+      expect(config.get(:key)).to equal(v)
+    end
+  end
+end