waffle 0.4.0 → 0.5.0

data/README.md

@@ -36,27 +36,79 @@ You also can configure Waffle programmatically:
 
 or:
 
-    Waffle.configure do |config|
-      config.transport = 'redis'
-      config.url = 'redis://localhost:6379/0'
-      config.encoder = 'json'
+    Waffle.configure do
+      default do |config|
+        config.transport = 'redis'
+        config.url = 'redis://localhost:6379/0'
+        config.encoder = 'json'
+      end
     end
 
+### Multitransport config
+
+You can use many transports for organising your messaging system. Just add to config file `queues` section:
+
+    production:
+      transport: rabbitmq
+      encoder: marshal
+      url: amqp://anyhost.com:5678
+      queues:
+        redis_name:
+          transport: redis
+          encoder: json
+          url: redis://localhost:6379/0
+
+or programmatically:
+
+    Waffle.configure({
+      :transport => 'redis',
+      :url => 'redis://localhost:6379/0',
+      :encoder => 'json',
+      :queues => {
+        :redis_name => {
+          :transport => 'redis',
+          :url => 'redis://localhost:6380/0',
+          :encoder => 'json',
+        }
+      }
+    })
+
+    # or
+
+    Waffle.configure do
+      default do |config|
+        config.transport = 'redis'
+        config.url = 'redis://localhost:6379/0'
+        config.encoder = 'json'
+      end
+
+      queue(:redis_name) do |config|
+        config.transport = 'redis'
+        config.url = 'redis://localhost:6380/0'
+        config.encoder = 'json'
+      end
+    end
+
+
 ## Usage
 
 ### Event 
 
 When you want to performan event, just insert this code in place, where it must occur:
 
-    Waffle::Event.occurred 'index_page_load'
+    Waffle::Event.occurred 'message'
 
 You can attach meta data to event like this:
 
-    Waffle::Event.occurred 'index_page_load', {'user_id' => 13, 'user_name' => 'Joshua'}
+    Waffle::Event.occurred {'user_id' => 13, 'user_name' => 'Joshua'}, :event_name => 'index_page_load'
 
 or like this:
 
-    Waffle::Event.occurred 'index_page_load', 'bingo!'
+    Waffle::Event.occurred 'bingo!', :event_name => 'index_page_load'
+
+or:
+    
+    Waffle::Event.occurred 'message', :event_name => 'index_page_load', :queue => :experimental_queue
 
 ### Pub/Sub
 
@@ -67,6 +119,15 @@ or like this:
       pp message_hash_or_string
     end
 
+### Multitransport usage
+
+    Waffle.queue(:redis_name).publish('event.name', message_hash_or_string)
+
+    Waffle.queue(:redis_name).subscribe('event.name') do |message_type, message_hash_or_string|
+      pp message_type
+      pp message_hash_or_string
+    end
+
 ### Reconnect
 
 Don't care about any reconnects when transport server is down. Waffle just waits for server ready and reconnects automatically.

data/config/config.rb

@@ -0,0 +1,19 @@
+Waffle.configure do
+  default do |config|
+    config.transport = 'rabbitmq'
+    config.url = 'amqp://localhost:5672'
+    config.encoder = 'json'
+  end
+
+  queue(:rabbitmq_name) do |config|
+    config.transport = 'rabbitmq'
+    config.url = 'amqp://localhost:5673'
+    config.encoder = 'json'
+  end
+
+  queue(:redis_name) do |config|
+    config.transport = 'redis'
+    config.url = 'redis://localhost:6379/0'
+    config.encoder = 'json'
+  end
+end

data/config/waffle.yml

@@ -2,6 +2,15 @@ production: &base
   transport: rabbitmq
   encoder: json
   url: 'amqp://localhost:5672'
+  queues:
+    rabbitmq_name:
+      transport: rabbitmq
+      encoder: json
+      url: 'amqp://localhost:5673'
+    redis_name:
+      transport: redis
+      encoder: json
+      url: 'redis://localhost:6379/0'
 development:
   <<: *base
 test:

data/lib/waffle.rb

@@ -7,58 +7,58 @@ require 'waffle/version'
 require 'time'
 
 module Waffle
-  extend self
+  extend self 
   module Transports
     autoload :Base, 'waffle/transports/base'
     autoload :Rabbitmq, 'waffle/transports/rabbitmq' if defined?(Bunny)
     autoload :Redis, 'waffle/transports/redis' if defined?(::Redis)
+
+    module_function
+    def create config
+      "Waffle::Transports::#{config.transport.camelize}".constantize.new(config)
+    end
   end
 
   autoload :Config, 'waffle/config'
   autoload :Event, 'waffle/event'
 
+  class Config
+    autoload :Node, 'waffle/config'
+  end
+
   module Encoders
     autoload :Json, 'waffle/encoders/json' if defined?(Yajl)
     autoload :Marshal, 'waffle/encoders/marshal'
   end
 
   def reset_config!
-    @configured = false
+    config.reset_config! if config
   end
 
-  def configure options=nil
-    @configured ||= begin
+  def configure options = nil, &block
+    if block_given?
+      Config.class_eval(&block)
+    else
       options = {:path => 'config/waffle.yml'} unless options
       Config.load!(options)
-      true
     end
-    block_given? ? yield(Config) : Config
   end
 
-  def publish flow = 'events', message = ''
-    transport.publish(flow, message)
-  rescue *transport.connection_exceptions => e
-    transport.reconnect && retry if transport.ready_to_connect?
+  def config
+    Config if Config.configured?
   end
 
-  def subscribe flow = '', &block
-    transport.subscribe(flow, &block)
-  rescue *transport.connection_exceptions => e
-    until transport.reconnect do
-      sleep(config.connection_attempt_timeout)
-    end
-    retry
+  def queue name = :default
+    config.queues[name] or raise "Transport '#{name}' is not configured"
   end
 
-  def transport
-    @transport ||= "Waffle::Transports::#{Waffle.config.transport.camelize}".constantize.new
-  end
-
-  def encoder
-    @encoder ||= "Waffle::Encoders::#{Waffle.config.encoder.camelize}".constantize
+  def method_missing meth, *args
+    if Config.configured?
+      config.queues[:default].send(meth, *args)
+    else
+      super
+    end
   end
-
-  alias :config :configure
 end
 
 unless defined?(ActiveSupport::Inflector)

data/lib/waffle/config.rb

@@ -1,57 +1,111 @@
-require 'yaml'
-
 module Waffle
-  module Config
-    extend self
-    attr_accessor :settings, :defaults
+  class Config
+    class Node
+      attr_accessor :settings
 
-    @settings = {}
-    @defaults = {}
+      class << self
+        def option(name, options = {})
+          defaults[name] = options[:default]
 
-    def option(name, options = {})
-      defaults[name] = settings[name] = options[:default]
+          class_eval <<-RUBY
+            def #{name}
+              settings[#{name.inspect}] || defaults[#{name.inspect}]
+            end
 
-      class_eval <<-RUBY
-        def #{name}
-          settings[#{name.inspect}]
-        end
+            def #{name}=(value)
+              settings[#{name.inspect}] = value
+            end
 
-        def #{name}=(value)
-          settings[#{name.inspect}] = value
+            def #{name}?
+              #{name}
+            end
+          RUBY
         end
 
-        def #{name}?
-          #{name}
+        def defaults
+          @defaults ||= {}
         end
-      RUBY
-    end
+      end
+      
+      option :url, :default => nil
+      option :encoder, :default => 'json'
+      option :transport, :default => nil
+      option :connection_attempt_timeout, :default => 30
+      option :options, :default => {'exchange' => 'events', 'queue' => ''}
 
-    option :url, :default => nil
-    option :encoder, :default => 'json'
-    option :transport, :default => nil
-    option :connection_attempt_timeout, :default => 30
+      def initialize config = {}
+        @settings = config ? defaults.merge(config) : {}
+        yield self if block_given?
+      end
 
-    def load! options=nil
-      options[:path] ? load_from_yaml!(options[:path]) : load_from_hash!(options)
-      self
+      protected
+      def defaults
+        self.class.defaults
+      end
     end
 
-    def load_from_yaml! filename
-      filename = Rails.root.join(filename) if defined?(Rails)
-      filename = File.expand_path(filename)
+    class << self
+      def load! options = nil
+        options[:path] ? load_from_yaml!(options[:path]) : load_from_hash!(options)
+        self
+      end
 
-      if File.exists?(filename)
-        settings_hash = YAML.load_file(filename)[environment]
-        @settings = defaults.merge(settings_hash.symbolize_keys) if settings_hash
+      def configured?
+        !!@configured
       end
-    end
 
-    def load_from_hash! options
-      @settings = defaults.merge(options)
-    end
-    
-    def environment
-      defined?(Rails) && Rails.respond_to?(:env) ? Rails.env : (ENV['RACK_ENV'] || 'development')
+      def reset_config!
+        @queues = {}
+        @configured = false
+      end
+
+      def default &block
+        queue(:default, &block).tap do 
+          @configured = true
+        end
+      end
+
+      def queue name, &block
+        queues[name] = Transports.create(Node.new(&block))
+        nil
+      end
+
+      def queues
+        @queues ||= {}
+      end
+
+      protected
+      def load_from_yaml! filename
+        filename = Rails.root.join(filename) if defined?(Rails)
+        filename = File.expand_path(filename)
+
+        if File.exists?(filename)
+          settings_hash = YAML.load_file(filename)[environment]
+          load_from_hash!(settings_hash) if settings_hash
+        end
+      end
+
+      def load_from_hash! settings_hash
+        queues_config = settings_hash.delete('queues') || {}
+        queues_config['default'] = settings_hash
+        queues_config.each do |queue, config|
+          config = Node.new(Node.defaults.merge(config.symbolize_keys))
+          queues[queue.to_sym] = Transports.create(config)
+        end
+        @configured = true
+      end
+
+      def method_missing meth, *args
+        if configured?
+          queues[:default].config.send(meth, *args)
+        else
+          super
+        end
+      end
+
+      def environment
+        defined?(Rails) && Rails.respond_to?(:env) ? Rails.env : (ENV['RACK_ENV'] || 'development')
+      end
     end
   end
-end
+end

data/lib/waffle/event.rb

@@ -1,14 +1,19 @@
 module Waffle
   class Event
     class << self
-      def occured(event_name = 'event', event_data = nil)
+      def occured(event_data, options = {})
+        options = {
+          :event_name => 'event',
+          :queue => :default
+        }.merge(options)
+
         unless event_data.is_a?(Hash)
           event_data = {'body' => event_data.to_s}
         end
 
         event_data.merge!({'occured_at' => Time.now})
 
-        Waffle.publish(event_name, event_data)
+        Waffle.queue(options[:queue]).publish(options[:event_name], event_data)
       end
       alias :occurred :occured
     end

data/lib/waffle/transports/base.rb

@@ -1,19 +1,40 @@
 module Waffle
   module Transports
     class Base
-      def initialize
+      attr_reader :config
+      def initialize config
+        @config = config
         connect!
       end
 
+      def publish flow = 'events', message = ''
+        publish_impl(flow, message)
+      rescue *connection_exceptions => e
+        reconnect && retry if ready_to_connect?
+      end
+
+      def subscribe flow = '', &block
+        subscribe_impl(flow, &block)
+      rescue *connection_exceptions => e
+        until reconnect do
+          sleep(config.connection_attempt_timeout)
+        end
+        retry
+      end
+
+      protected
       def ready_to_connect?
-        (Time.now - @last_connection_attempt) > Waffle.config.connection_attempt_timeout
+        (Time.now - @last_connection_attempt) > config.connection_attempt_timeout
       end
 
       def reconnect
         connect!
       end
 
-      protected
+      def encoder
+        @encoder ||= "Waffle::Encoders::#{config.encoder.camelize}".constantize
+      end
+
       def connect!
         @last_connection_attempt = Time.now
         do_connect

data/lib/waffle/transports/rabbitmq.rb

@@ -6,11 +6,12 @@ module Waffle
     class Rabbitmq < Base
       EXCHANGE = 'events'
 
-      def publish(flow = 'events', message = '')
-        exchange.publish(Waffle.encoder.encode(message), :key => flow)
+      protected
+      def publish_impl(flow = 'events', message = '')
+        exchange.publish(encoder.encode(message), :key => flow)
       end
 
-      def subscribe(flow = 'events')
+      def subscribe_impl(flow = 'events')
         if flow.is_a?(Array)
           flow.each{|f| queue.bind(exchange, :key => f)}
         else
@@ -18,7 +19,7 @@ module Waffle
         end
 
         queue.subscribe do |message|
-          yield(message[:delivery_details][:routing_key], Waffle.encoder.decode(message[:payload]))
+          yield(message[:delivery_details][:routing_key], encoder.decode(message[:payload]))
         end
       end
 
@@ -26,19 +27,18 @@ module Waffle
         [Bunny::ServerDownError, Bunny::ConnectionError, Errno::ECONNRESET]
       end
 
-      private
       def exchange
-        @exchange ||= @bunny.exchange(EXCHANGE)
+        @exchange ||= @bunny.exchange(config.options['exchange'] || EXCHANGE)
       end
 
       def queue
-        @queue ||= @bunny.queue('', :durable => true, :auto_delete => true)
+        @queue ||= @bunny.queue(config.options['queue'] || '', :durable => true, :auto_delete => true)
       end
 
       def do_connect
         @exchange = nil
         @queue = nil
-        @bunny = Bunny.new(Waffle.config.url)
+        @bunny = Bunny.new(config.url)
         @bunny.start
       end
     end

data/lib/waffle/transports/redis.rb

@@ -3,14 +3,15 @@ module Waffle
     class Redis < Base
       attr_reader :db
 
-      def publish(flow = 'events', message = '')
-        db.publish(flow, Waffle.encoder.encode(message))
+      protected
+      def publish_impl(flow = 'events', message = '')
+        db.publish(flow, encoder.encode(message))
       end
 
-      def subscribe(flow = 'events')
+      def subscribe_impl(flow = 'events')
         db.subscribe(*flow) do |on|
           on.message do |channel, message|
-            yield(channel, Waffle.encoder.decode(message))
+            yield(channel, encoder.decode(message))
           end
         end
       end
@@ -19,9 +20,8 @@ module Waffle
         [Errno::ECONNREFUSED, Errno::ECONNRESET]
       end
 
-      protected
       def do_connect
-        @db = ::Redis.new(:url => Waffle.config.url)
+        @db = ::Redis.new(:url => config.url)
       end
     end
   end

data/lib/waffle/version.rb

@@ -1,3 +1,3 @@
 module Waffle
-  VERSION = '0.4.0'
+  VERSION = '0.5.0'
 end

data/spec/waffle/event_spec.rb

@@ -2,22 +2,25 @@ require 'spec_helper'
 
 describe Waffle::Event do
   describe '.occured' do
-    let(:flow){'event'}
+    let(:flow){'event name'}
     let(:now){Time.now}
+    let(:options){{:event_name => flow, :queue => :default}}
+    let(:transport){double(:transport)}
     
     before do
       Time.stub(:now => now)
-      Waffle.should_receive(:publish).with(flow, message)
+      Waffle.should_receive(:queue).with(:default).and_return(transport)
+      transport.should_receive(:publish).with(flow, message)
     end
     
     context do
       let(:message){{"key1" => "value1", "key2" => "value2", "occured_at" => now}}
-      specify{Waffle::Event.occured(flow, {'key1' => 'value1', 'key2' => 'value2'})}
+      specify{Waffle::Event.occured(message, {:event_name => flow})}
     end
     
     context do
       let(:message){{"body" => "message data", "occured_at" => now}}
-      specify{Waffle::Event.occured(flow, 'message data')}
+      specify{Waffle::Event.occured('message data', {:event_name => flow})}
     end
   end
 end

data/spec/waffle/transports/rabbitmq_spec.rb

@@ -1,14 +1,13 @@
 require 'spec_helper'
 
-class Waffle::Transports::Rabbitmq
-  def initialize
-  end
-end
+#class Waffle::Transports::Rabbitmq
+#end
 
 describe Waffle::Transports::Rabbitmq do
-  subject{Waffle::Transports::Rabbitmq.new}
+  subject{Waffle::Transports::Rabbitmq.new(config)}
 
   let(:exchange){mock(:exchange)}
+  let(:config){Waffle::Config::Node.new({})}
 
   before do
     subject.stub(:exchange => exchange)

data/spec/waffle/transports/redis_spec.rb

@@ -1,13 +1,12 @@
 require 'spec_helper'
 
-class Waffle::Transports::Redis
-  def initialize
-  end
-end
+#class Waffle::Transports::Redis
+#end
 
 describe Waffle::Transports::Redis do
-  subject{Waffle::Transports::Redis.new}
+  subject{Waffle::Transports::Redis.new(config)}
 
+  let(:config){Waffle::Config::Node.new({})}
   let(:redis){mock(:redis)}
   let(:subscription){mock(:subscription)}
 

data/spec/waffle_spec.rb

@@ -19,9 +19,9 @@ describe Waffle do
         YAML.stub(:load_file => config_hash)
         File.stub(:exists? => true)
         Waffle::Config.stub(:environment => 'development')
+        Waffle.configure
       end
 
-      specify{Waffle.configure.should == Waffle::Config}
       specify{Waffle.config.should == Waffle::Config}
       specify{Waffle.config.transport.should == 'redis'}
       specify{Waffle.config.encoder.should == 'json'}
@@ -31,8 +31,10 @@ describe Waffle do
 
     context "when a block is supplied" do
       before do
-        Waffle.configure do |config|
-          config.transport = 'redis'
+        Waffle.configure do
+          default do |config|
+            config.transport = 'redis'
+          end
         end
       end
 
@@ -48,7 +50,8 @@ describe Waffle do
   
   context do
     before do
-      Waffle.stub(:transport => transport)
+      Waffle.configure
+      Waffle::Config.stub(:queues => {:default => transport})
     end
 
     let(:transport){mock(:transport)}
@@ -65,10 +68,10 @@ describe Waffle do
 
     describe '#subscribe' do
       before do
-        transport.should_receive(:subscribe).with('flow').and_yield
+        transport.should_receive(:subscribe).with('flow')
       end
 
-      specify{Waffle.subscribe('flow'){}}
+      specify{Waffle.subscribe('flow')}
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: waffle
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-06 00:00:00.000000000 Z
+date: 2012-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -43,6 +43,7 @@ files:
 - Gemfile.lock
 - README.md
 - Rakefile
+- config/config.rb
 - config/waffle.yml
 - lib/waffle.rb
 - lib/waffle/config.rb
@@ -75,7 +76,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2130519817389681143
+      hash: -4396134894466903683
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: