lolitra 0.0.3 → 0.0.4

data/.gitignore

@@ -1,5 +1,6 @@
 *.gem
 *.rbc
+*.swp
 .bundle
 .config
 .yardoc

data/lib/lolitra/future.rb

@@ -0,0 +1,7 @@
+module Lolitra
+  class Future
+    def initialze(message_class)
+     
+    end
+  end
+end

data/lib/lolitra/handler_base.rb

@@ -62,20 +62,21 @@ module Lolitra
     private
       def message_handler(message_class, id = :id)   
         message_class.new.send(id) #check if id exists for this class
-        handlers.merge!(message_class.name => [message_class, get_method_by_class(message_class), id])
+        handlers.merge!(message_class.message_key => [message_class, get_method_by_class(message_class), id])
       end
      
-      def started_by(message_class)
-        starters << message_class.name
+      def started_by(message_class, id = :id)
+        starters << message_class.message_key
+        message_handler(message_class, id)
       end
 
       def search(message)
-        id_method_name = handlers[message.class.name][2]
+        id_method_name = handlers[message.class.message_key][2]
         send("find_by_#{id_method_name}", message.send(id_method_name))
       end
 
       def is_starter?(message)
-        starters.include? message.class.name
+        starters.include? message.class.message_key
       end
 
       def get_handler(message)
@@ -104,7 +105,7 @@ module Lolitra
     end
 
     def handle(message)
-      handler_method = self.class.handlers[message.class.name][1]
+      handler_method = self.class.handlers[message.class.message_key][1]
       raise "Can't handle message #{message.class}" unless handler_method
       self.send(handler_method, message)
     end
@@ -124,12 +125,24 @@ module Lolitra
       instance.bus
     end
 
-    def self.register(handler_class)
-      instance.register(handler_class)
+    def self.register_subscriber(handler_class)
+      instance.register_subscriber(handler_class)
     end
    
-    def register(handler_class)
-      register_message_handler(handler_class)    
+    def register_subscriber(handler_class)
+      handler_class.handle_messages.each do |message_class|
+        bus.subscribe(message_class, handler_class)
+      end
+    end
+
+    def self.register_pull_subscriber(handler_class)
+      instance.register_pull_subscriber(handler_class)
+    end
+   
+    def register_pull_subscriber(handler_class)
+      handler_class.handle_messages.each do |message_class|
+        bus.pull_subscribe(message_class, handler_class)
+      end
     end
 
     def self.publish(message_instance)
@@ -139,17 +152,11 @@ module Lolitra
     def publish(message_instance)
       bus.publish(message_instance)
     end
-  private
-    def register_message_handler(handler_class)
-      handler_class.handle_messages.each do |message_class|
-        bus.subscribe(message_class, handler_class)
-      end
-    end
   end
 
-  module AmqpMessage
+  module Message
 
-    module AmqpMessageClass
+    module MessageClass
       def self.extended(base)
         class << base; attr_accessor :class_message_key; end
       end
@@ -158,7 +165,7 @@ module Lolitra
         if (key)
           self.class_message_key = key      
         else
-          self.class_message_key
+          self.class_message_key || "#{MessageHandler::Helper.underscore(self.class.name)}"
         end
       end
 
@@ -170,7 +177,7 @@ module Lolitra
     end
 
     def self.included(base)
-      base.send :extend, AmqpMessageClass
+      base.send :extend, MessageClass
     end
 
     def initialize(hash={})   
@@ -184,32 +191,6 @@ module Lolitra
     end
   end
 
-  module AmqpMessageHandler
-    module AmqpMessageHandlerClass
-      
-      def self.extended(base)
-        class << base
-          attr_accessor :message_class_by_key
-          alias_method :message_handler_without_class_by_key, :message_handler unless method_defined?(:message_handler_without_class_by_key)
-          alias_method :message_handler, :message_handler_with_class_by_key
-        end
-        base.message_class_by_key = {}
-      end
-
-      def message_handler_with_class_by_key(message_class, id = :id)
-        message_class_by_key.merge!({message_class.message_key => message_class})
-        message_handler_without_class_by_key(message_class, id)
-      end
-
-    end
-
-    def self.included(base)
-      base.send :include, MessageHandler
-      base.send :extend, AmqpMessageHandlerClass
-    end
-
-  end
-
   class AmqpBus
     attr_accessor :queue_prefix
     attr_accessor :connection
@@ -228,18 +209,26 @@ module Lolitra
     end
 
     def subscribe(message_class, handler_class)
-      EM.next_tick do
-        channel = AMQP::Channel.new(self.connection)
-        channel.prefetch(1).queue(queue_prefix + MessageHandler::Helpers.underscore(handler_class.name), :dureable => true).bind(self.exchange, :routing_key => message_class.message_key).subscribe do |info, payload|
-          message_class_tmp = handler_class.message_class_by_key[info.routing_key]
-          handler_class.handle(message_class_tmp.unmarshall(payload))
-        end
-      end
+      create_queue(message_class, handler_class, {:exclusive => true, :durable => false}, "")
+    end
+
+    def pull_subscribe(message_class, handler_class)
+      create_queue(message_class, handler_class, {:durable => true}, queue_prefix + MessageHandler::Helpers.underscore(handler_class.name))
     end
 
     def publish(message)
       self.exchange.publish(message.marshall, :routing_key => message.class.message_key, :timestamp => Time.now.to_i)
     end
 
+  private
+    def create_queue(message_class, handler_class, options, queue_name)
+      EM.next_tick do
+        channel = AMQP::Channel.new(self.connection)
+        channel.prefetch(1).queue(queue_name, options).bind(self.exchange, :routing_key => message_class.message_key).subscribe do |info, payload|
+          message_class_tmp = handler_class.handlers[info.routing_key][0]
+          handler_class.handle(message_class_tmp.unmarshall(payload))
+        end
+      end
+    end
   end
 end  

data/lib/lolitra/version.rb

@@ -1,3 +1,3 @@
 module Lolitra
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/lolitra.rb

@@ -1,2 +1,3 @@
 require "lolitra/version"
 require "lolitra/handler_base"
+require "lolitra/future"

data/spec/lolitra_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper.rb'
 
 class TestMessage
-  include Lolitra::AmqpMessage
+  include Lolitra::Message
 
   message_key "test1"
 
@@ -11,7 +11,7 @@ class TestMessage
 end
 
 class TestMessage1
-  include Lolitra::AmqpMessage
+  include Lolitra::Message
 
   message_key "test2"
 
@@ -24,7 +24,6 @@ class TestMessageHandler
   include Lolitra::MessageHandler
 
   started_by TestMessage
-  message_handler TestMessage
   stateful true
 
   def self.find_by_id(id)
@@ -41,7 +40,6 @@ class TestMessageHandler1
 
   started_by TestMessage1
   message_handler TestMessage
-  message_handler TestMessage1
 
   stateful true
 
@@ -59,19 +57,23 @@ class TestMessageHandler1
 
 end
 
-class TestAmqpMessageHandler
-  include Lolitra::AmqpMessageHandler
+class TestMessageHandlerAmqp
+  include Lolitra::MessageHandler
 
   message_handler TestMessage
   message_handler TestMessage1
 
   stateful false
 
-  def test_message(message)
-    EM.stop { exit } 
-  end
 end
 
+class TestMessageHandlerAmqp1
+  include Lolitra::MessageHandler
+
+  message_handler TestMessage
+
+  stateful false
+end
 
 describe Lolitra::MessageHandler,'#create_handler' do
   it "returns old instance of the handler for the same message id" do
@@ -115,7 +117,7 @@ describe Lolitra::MessageHandler, '#publish' do
     message = TestMessage.new
     bus = TestBus.new
     Lolitra::MessageHandlerManager.bus = bus
-    Lolitra::MessageHandlerManager.register(TestMessageHandler)
+    Lolitra::MessageHandlerManager.register_subscriber(TestMessageHandler)
 
 
     TestMessageHandler.should_receive(:handle).with(message)
@@ -127,7 +129,7 @@ describe Lolitra::MessageHandlerManager, '#publish' do
   it "can send message to the bus" do
     bus = TestBus.new
     Lolitra::MessageHandlerManager.bus = bus
-    Lolitra::MessageHandlerManager.register(TestMessageHandler)
+    Lolitra::MessageHandlerManager.register_subscriber(TestMessageHandler)
 
     message = TestMessage.new
 
@@ -144,8 +146,8 @@ describe Lolitra::MessageHandlerManager, '#handle_message' do
     
     Lolitra::MessageHandlerManager.bus = bus
 
-    Lolitra::MessageHandlerManager.register(TestMessageHandler)
-    Lolitra::MessageHandlerManager.register(TestMessageHandler1)
+    Lolitra::MessageHandlerManager.register_subscriber(TestMessageHandler)
+    Lolitra::MessageHandlerManager.register_subscriber(TestMessageHandler1)
 
     message = TestMessage.new
     message1 = TestMessage1.new
@@ -161,7 +163,7 @@ describe Lolitra::MessageHandlerManager, '#handle_message' do
   end
 end
 
-describe Lolitra::AmqpMessage, '#message_key' do
+describe Lolitra::Message, '#message_key' do
   it "message_key has constant key for a class" do
     TestMessage.message_key.should eq "test1"
     TestMessage1.message_key.should eq "test2"
@@ -169,24 +171,27 @@ describe Lolitra::AmqpMessage, '#message_key' do
   end
 end
 
-describe Lolitra::AmqpMessageHandler, '#message_class_by_key' do
+describe Lolitra::MessageHandler, '#message_class_by_key' do
   it "should return the message_class that belongs to key" do
-    TestAmqpMessageHandler.message_class_by_key[TestMessage.message_key].name.should eq "TestMessage" 
-    TestAmqpMessageHandler.message_class_by_key[TestMessage1.message_key].name.should eq "TestMessage1" 
+    TestMessageHandler1.handlers[TestMessage.message_key][0].name.should eq "TestMessage" 
+    TestMessageHandler1.handlers[TestMessage1.message_key][0].name.should eq "TestMessage1" 
   end
 end
 
 describe Lolitra::AmqpBus do
   it "should recive message when publish a message" do
     Lolitra::MessageHandlerManager.bus = Lolitra::AmqpBus.new(:host => "127.0.0.1", :exchange => "test_exchange")
-    Lolitra::MessageHandlerManager.register(TestAmqpMessageHandler)
+    Lolitra::MessageHandlerManager.register_pull_subscriber(TestMessageHandlerAmqp)
+    Lolitra::MessageHandlerManager.register_pull_subscriber(TestMessageHandlerAmqp1)
 
-    TestAmqpMessageHandler.should_receive(:handle) do |message|
+    TestMessageHandlerAmqp.should_receive(:handle) do |message|
       message.should be_an_instance_of TestMessage
       EM.stop { exit }
     end
 
-    Lolitra::MessageHandlerManager.publish(TestMessage.new)
+    EM.add_timer(0.25) do
+      Lolitra::MessageHandlerManager.publish(TestMessage.new)
+    end
 
     EM.next_tick{ EM.add_timer(60) { EM.stop { exit } }}
     AMQP::Utilities::EventLoopHelper.eventmachine_thread.join
@@ -195,7 +200,48 @@ end
 
 describe Lolitra::AmqpBus do
   it "should return a unable to connect when specify a wrong amqp host" do
-    expect { Lolitra::AmqpBus.new(:host => "192.168.123.123") }.to raise_error(UnableToConnect) #TODO
-    pending 
+    expect { Lolitra::AmqpBus.new(:host => "192.168.123.123") }.to raise_error(Exception) #TODO
+  end
+end
+
+describe Lolitra::AmqpBus do
+  it "should send all messages to all subscribers in non pull mode" do
+    Lolitra::MessageHandlerManager.bus = Lolitra::AmqpBus.new(:host => "127.0.0.1", :exchange => "test_exchange")
+    Lolitra::MessageHandlerManager.register_subscriber(TestMessageHandlerAmqp)
+    Lolitra::MessageHandlerManager.register_subscriber(TestMessageHandlerAmqp1)
+
+    @handled_message_1 = false
+    @handled_message_2 = false
+
+    TestMessageHandlerAmqp.should_receive(:handle) do |message|
+      message.should be_an_instance_of TestMessage
+      @handled_message_1 = true
+      EM.stop { exit } if @handled_message_1 && @handled_message_2
+    end
+
+    TestMessageHandlerAmqp1.should_receive(:handle) do |message|
+      message.should be_an_instance_of TestMessage
+      @handled_message_2 = true
+      EM.stop { exit } if @handled_message_1 && @handled_message_2
+    end
+
+    EM.add_timer(0.25){
+      Lolitra::MessageHandlerManager.publish(TestMessage.new)
+    }
+
+    EM.next_tick{ EM.add_timer(60) { EM.stop { exit } }}
+    AMQP::Utilities::EventLoopHelper.eventmachine_thread.join
+  end
+end  
+
+describe Lolitra::Future,"#wait_message" do
+  it "should return the message" do
+    Lolitra::MessageHandlerManager.bus = Lolitra::AmqpBus.new(:host => "127.0.0.1", :exchange => "test_exchange")
+    EM.next_tick{    
+      Lolitra::MessageHandlerManager.publish(TestMessage.new)
+    }
+    future = Lolitra::Future.new     
+    message = future.wait_for(TestMessage)
+    message.should be_an_instance_of TestMessage    
   end
 end

data/spec/spec_helper.rb

@@ -21,6 +21,10 @@ class TestBus
     end
   end
 
+  def pull_subscribe(message_class, handler_class)
+    subscribe(message_class, handler_class)
+  end
+  
   def subscribe(message_class, handler_class)
     @unmarshallers[message_class.message_key] = message_class
     @handlers[message_class.name] ||= []

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Hugo Freire
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-05-26 00:00:00 +02:00
+date: 2012-05-28 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -73,8 +73,9 @@ files:
 - README.md
 - Rakefile
 - lib/lolitra.rb
+- lib/lolitra/.future.rb.swp
 - lib/lolitra/.handler_base.rb.swp
-- lib/lolitra/.version.rb.swp
+- lib/lolitra/future.rb
 - lib/lolitra/handler_base.rb
 - lib/lolitra/version.rb
 - lolitra.gemspec