jsparrow 1.1.3 → 1.1.4

data/lib/interaction.rb

@@ -0,0 +1,4 @@
+require 'interaction/messaging'
+require 'interaction/client'
+require 'interaction/listener'
+require 'interaction/interactors'

data/lib/{client.rb → interaction/client.rb}

@@ -1,18 +1,15 @@
-# Classes Java usadas nesse arquivo
 import 'javax.naming.InitialContext'
 
 module JSparrow
-  module Connection
-
+  module Interactors
+  
     #
-    # Cliente JMS que possibilita a conexao com o servidor de aplicacoes Java EE
-    # que prove o servico JMS.
+    # Client to send and receive messages to/from the JMS provider.
     #
     class Client
       def initialize(connection)
         @connection = connection
-    
-        # Conexoes, filas, topicos, senders e receivers que serao habilitados
+
         @connection_factories = {}
         @queues               = {}
         @queue_senders        = {}
@@ -21,21 +18,21 @@ module JSparrow
         @topic_senders        = {}
         @topic_receivers      = {}
       end
-  
+
       def is_started?
         @connection.is_opened?
       end
-  
+
       def start
         @connection.open
-    
+
         @connection_factories, @queues, @topics = lookup_resources
       end
-  
+
       def is_stoped?
         @connection.is_closed?
       end
-  
+
       def stop
         @connection.close
       end
@@ -43,10 +40,10 @@ module JSparrow
       def queue_enabled?(queue_name)
         @connection.configuration.enabled_queues.include?(queue_name)
       end
-  
+
       def queue(queue_name)
         raise NameError, "Queue '#{queue_name}' does not exist." unless queue_enabled?(queue_name)
-    
+
         @queues[queue_name]
       end
 
@@ -63,10 +60,10 @@ module JSparrow
       def topic_enabled?(topic_name)
         @connection.configuration.enabled_topics.include?(topic_name)
       end
-  
+
       def topic(topic_name)
         raise NameError, "Topic '#{topic_name}' does not exist." unless topic_enabled?(topic_name)
-    
+
         @topics[topic_name]
       end
 
@@ -79,23 +76,22 @@ module JSparrow
         @topic_receivers[topic_name] ||=
             Messaging::Receiver.new(topic_connection_factory, topic(topic_name))
       end
-  
-      # -- Private methods -- #
+
       private
 
         def queue_connection_factory
           @connection_factories[:queue_connection_factory]
         end
-  
+
         def topic_connection_factory
           @connection_factories[:topic_connection_factory]
         end
-  
+
         def lookup_resources
           lookuped_connection_factories = @connection.lookup_resources(@connection.configuration.enabled_connection_factories)
           lookuped_queues               = @connection.lookup_resources(@connection.configuration.enabled_queues)
           lookuped_topic                = @connection.lookup_resources(@connection.configuration.enabled_topics)
-          
+      
           return lookuped_connection_factories, lookuped_queues, lookuped_topic
         end
     end

data/lib/interaction/interactors.rb

@@ -0,0 +1,70 @@
+module JSparrow
+  module Interactors
+    
+    #
+    # Class methods to build interactors (Client and Listener).
+    #
+    class << self
+
+      def new_client
+        Client.new(new_connection)
+      end
+
+      #
+      # Example:
+      #
+      #   new_listener :as => ListenerClass
+      #
+      # ou
+      #
+      #   new_listener(
+      #     :listen_to => { :queue => :registered_name_of_queue },
+      #     :receive_only_in_criteria => { :selector => "recipient = 'jsparrow-spec'" }
+      #     ) do |received_message|
+
+      #     # do something
+      #   end
+      #
+      def new_listener(listener_spec, &on_receive_message)
+        is_anonymous_listener = listener_spec[:as].nil?
+
+        if is_anonymous_listener
+          new_anonymous_listener(listener_spec, &on_receive_message)
+        else
+          new_named_listener(listener_spec)
+        end
+      end
+
+      private
+
+        def new_named_listener(listener_spec)
+          listener_spec[:as].new(new_connection)
+        end
+
+        def new_anonymous_listener(listener_spec, &on_receive_message)
+          listener = Listener.new(new_connection)
+
+          (class << listener; self; end;).class_eval do
+            listen_to listener_spec[:listen_to] if listener_spec[:listen_to]
+            receive_only_in_criteria listener_spec[:receive_only_in_criteria] if listener_spec[:receive_only_in_criteria]
+    
+            define_method(:on_receive_message, &on_receive_message)
+          end
+
+          listener
+        end
+        
+        def new_connection
+          JSparrow::Connection.new
+        end
+    end
+  end
+end
+
+def new_jsparrow_client
+  JSparrow::Interactors.new_client
+end
+
+def new_jsparrow_listener(listener_spec, &on_receive_message)
+  JSparrow::Interactors.new_listener(listener_spec, &on_receive_message)
+end

data/lib/{listener.rb → interaction/listener.rb}

@@ -3,41 +3,52 @@ import 'javax.naming.InitialContext'
 import 'javax.jms.MessageListener'
 
 module JSparrow
-  module Connection
-    
-    #
-    # Ouvintes de mensagens.
+  module Interactors
+
     #
-    # Sao como clientes JMS, mas apenas para recebimento de mensagens.
+    # Message listener.
     #
     class Listener
       include MessageListener
-      
-      #
-      # Nome (configurado no setup da conexao) do destino JMS que sera escutado.
-      #
-      # Invariavelmente deve ser usado pelas subclasses, para informar o nome da queue
-      # ou topico que sera escutado.
-      #
-      # listen_to :queue => :registered_name_of_queue
-      # listen_to :topic => :registered_name_of_topic
-      #
-      def self.listen_to(destination)
-        configure(:listen_to_destination, destination)
-      end
-      
-      #
-      # Criterios de selecao de mensagens, seguindo o padrao JMS.
-      #
-      # Invariavelmente as subclasses precisam usar esse metodo, se quiserem definir
-      # os criterios de recebimento que este listener levara em conta.
-      #
-      # receive_only_in_criteria :selector => "recipient = 'jsparrow-spec' and to_listener = 'TestQueueListener'"
+  
       #
-      def self.receive_only_in_criteria(criteria = {:selector => ''})
-        configure(:criteria_to_receiving, criteria)
+      # Class methods to configure subclasses.
+      #
+      class << self
+        #
+        # Name (configured in connection setup) of JMS destination to listen to.
+        #
+        # Must be used by subclasses to configure destination.
+        #
+        # listen_to :queue => :registered_name_of_queue
+        # listen_to :topic => :registered_name_of_topic
+        #
+        def listen_to(destination)
+          configure(:listen_to_destination, destination)
+        end
+  
+        #
+        # Selector criteria to receive the messages, following the JMS pattern.
+        #
+        # Should be used by subclasses when want to set criterias to message selection.
+        #
+        # receive_only_in_criteria :selector => "recipient = 'jsparrow-spec' and to_listener = 'TestQueueListener'"
+        #
+        def receive_only_in_criteria(criteria = {:selector => ''})
+          configure(:criteria_to_receiving, criteria)
+        end
+    
+        private
+  
+          def configure(attribute, value)
+            instance_eval do
+              send(:define_method, attribute) do
+                value
+              end
+            end
+          end
       end
-      
+  
       def initialize(connection)
         @connection = connection
       end
@@ -46,99 +57,76 @@ module JSparrow
         @connection.is_opened?
       end
 
-      #
-      # Inicia a escuta de mensagens.
-      #
       def start_listening
         @connection.open
-        
+    
         connection_factory, destination = lookup_resources
-        
+    
         selector = criteria_to_receiving[:selector] if respond_to? :criteria_to_receiving
-        
-        # Cria uma conexao para escuta de mensagens
+    
         @listening_connection = connection_factory.create_connection
-        
-        # Cria uma sessao e um consumidor de qualquer tipo de mensagem
+    
         session  = @listening_connection.create_session(false, Session::AUTO_ACKNOWLEDGE)
         consumer = session.create_consumer(destination, selector)
-        
-        # Registra-se como ouvinte
+    
         consumer.message_listener = self
-        
-        # Inicia a escuta de mensagens
+    
         @listening_connection.start
       end
-      
-      #
-      # Finaliza a escuta de mensagens.
-      #
+  
       def stop_listening
         @listening_connection.close
-        
+    
         @connection.close
       end
-      
-      #
-      # Faz o enriquecimento do objeto mensagem e delega para o metodo on_receive_message
-      # que, implementado pelas subclasses, efetivamente trata a mensagem.
+  
       #
-      # Nao deve ser re-implementado por subclasses.
+      # It's part of JMS Listener interface. Shouldn't be overrided by subclasses.
       #
       def on_message(received_message)
         class << received_message
-          include Messaging::MessageType
+          include JMS::Message::TypingMethods
         end
-        
+    
         on_receive_message(received_message)
       end
-      
+  
       #
-      # E executado todas as vezes que chega uma mensagem que atenda aos criterios
-      # definido para este listener (na variavel de instancia @criteria_for_receiving).
+      # Callback mathod to receive enriched messages.
       #
-      # Invariavelmente deve ser re-implementado nas subclasses.
+      # Must be overrided by subclasses.
       #
       def on_receive_message(received_message)
         raise Error::AbstractMethodError.new(self.class.superclass, 'on_receive_message')
       end
-  
-      # --- Private methods --- #
-      private
 
-        def self.configure(attribute, value)
-          self.instance_eval do
-            send(:define_method, attribute) do
-              value
-            end
-          end
-        end
-      
+      private
+  
         def lookup_resources
           destination_type, destination_name = get_destination_info
-          
+      
           jndi_name_of_connection_factory = get_jndi_name_of_connection_factory(destination_type, destination_name)
           jndi_name_of_destination        = get_jndi_name_of_destination(destination_type, destination_name)
-          
+      
           lookuped_connection_factory = @connection.lookup_resource(jndi_name_of_connection_factory)
           lookuped_destination        = @connection.lookup_resource(jndi_name_of_destination)
-          
+      
           return lookuped_connection_factory, lookuped_destination
         end
-        
+    
         def get_destination_info
           return listen_to_destination.keys[0], listen_to_destination.values[0]
         end
-        
+    
         def get_jndi_name_of_connection_factory(destination_type, destination_name)
           connection_factory_name = "#{destination_type}_connection_factory".to_sym
-          
+      
           @connection.configuration.enabled_connection_factories[connection_factory_name]
         end
-        
+    
         def get_jndi_name_of_destination(destination_type, destination_name)
           enabled_method_for_destinations = "enabled_#{destination_type}s"
-          
+      
           @connection.configuration.send(enabled_method_for_destinations)[destination_name]
         end
     end

data/lib/{messaging.rb → interaction/messaging.rb}

@@ -1,30 +1,25 @@
-# Classes Java usadas nesse arquivo
 import 'javax.jms.Session'
 
 module JSparrow
   module Messaging
 
     #
-    # Tempo padrao de timeout no recebimento de mensagens = 1 milesegundo.
+    # Default timeout to receive messages = 1 millisecond.
     #
     DEFAULT_RECEIVER_TIMEOUT = 1000
   
     #
-    # Classe base para mensageiros, que enviam ou recebem mensagens, tanto
-    # para filas ou topicos.
+    # Base class to define messangers (for queues and topics).
     #
     class Base
       def initialize(connection_factory, destination)
-        # Fabrica de conexoes JMS
         @connection_factory = connection_factory
-
-        # Destino JMS para envio ou recebimento de mensagens
-        @destination = destination
+        @destination        = destination
       end
     end
     
     #
-    # Emissor de mensagens.
+    # Message sender.
     #
     class Sender < Base
       def send_text_message(text)
@@ -64,41 +59,41 @@ module JSparrow
       end
       
       def send_messages(&message_sender)
-        # Cria uma conexao, uma sessao e um emissor de qualquer tipo de mensagem
         connection = @connection_factory.create_connection
         session    = connection.create_session(true, Session::AUTO_ACKNOWLEDGE)
         producer   = session.create_producer(@destination)
         
-        # Passa o controle que trata a emissao de mensagens
+        class << session
+          include JMS::Session::OverrideMethods
+        end
+        
         message_sender.call(session, producer)
 
-        # Fecha a conexao
         connection.close
       end
       
-      # --- Private methods --- #
       private
       
         def send_message(&message_creator)
-          # Cria uma conexao, uma sessao e um emissor de qualquer tipo de mensagem
           connection = @connection_factory.create_connection
           session    = connection.create_session(true, Session::AUTO_ACKNOWLEDGE)
           producer   = session.create_producer(@destination)
         
-          # Obtem uma mensagem (TextMessage, ObjectMessage ou MapMessage) do criador especifico
+          class << session
+            include JMS::Session::OverrideMethods
+          end
+        
           message = message_creator.call(session)
         
-          # Envia a mensagem
           producer.send(message)
         
-          # Commita a sessao e fecha a conexao
           session.commit
           connection.close
         end
     end
     
     #
-    # Receptor de mensagens.
+    # Message receiver.
     #
     class Receiver < Base
       def receive_message(criteria_for_receiving = {:timeout => DEFAULT_RECEIVER_TIMEOUT, :selector => ''}, &message_handler)
@@ -109,56 +104,33 @@ module JSparrow
         receive(:many_messages, criteria_for_receiving, &message_handler)
       end
       
-      # --- Private methods --- #
       private
       
         def receive(how_much_messages, criteria_for_receiving, &message_handler)
-          # Cria uma conexao, uma sessao e um consumidor de qualquer tipo de mensagem
           connection = @connection_factory.create_connection
           session    = connection.create_session(false, Session::AUTO_ACKNOWLEDGE)
-          consumer   = session.create_consumer(@destination, criteria_for_receiving[:selector])
+      
+          class << session
+            include JMS::Session::OverrideMethods
+          end
+
+          consumer = session.create_consumer(@destination, criteria_for_receiving[:selector])
         
-          # Prepara a conexao para receber mensagens
           connection.start
         
-          # Inicia o recebimento de mensagens
           timeout = criteria_for_receiving[:timeout] || DEFAULT_RECEIVER_TIMEOUT
           
-          # Uma (if) mensagem ou muitas (while) mensagens?
+          # One message (if) or many masseges (while)
           conditional_keyword = (how_much_messages.eql? :one_message) ? 'if' : 'while'
         
           eval %Q{
             #{conditional_keyword} (received_message = consumer.receive(timeout))
-              # Inclui o modulo de identificacao de mensagem, util para o message_handler
-              class << received_message
-                include MessageType
-              end
-
-              # Delega o tratamento da mensagem para o bloco recebido
               message_handler.call(received_message)
             end
           }
         
-          # Fecha a conexao
           connection.close
         end
     end
-  
-    #
-    # Identifica o tipo de uma mensagem.
-    #
-    module MessageType
-      def is_text_message?
-        respond_to? :get_text
-      end
-    
-      def is_object_message?
-        (respond_to? :get_object and !(respond_to? :get_long))
-      end
-    
-      def is_map_message?
-        respond_to? :get_long
-      end
-    end
   end
 end