jsparrow 1.1.1 → 1.1.2

data/README.rdoc

@@ -70,7 +70,7 @@ jsparrow rocks! =)
 
 Or, if you don't want write code, only do it:
 
-  jruby sample/sample.rb
+  jruby sample/sample_queue.rb
 
 == Copyright
 

data/VERSION.yml

@@ -1,5 +1,5 @@
 --- 
-:patch: 1
 :major: 1
-:build: 
 :minor: 1
+:patch: 2
+:build: 

data/lib/client.rb

@@ -9,9 +9,8 @@ module JSparrow
     # que prove o servico JMS.
     #
     class Client
-      def initialize(connection_config, jndi_context_builder)
-        @connection_config    = connection_config
-        @jndi_context_builder = jndi_context_builder
+      def initialize(connection)
+        @connection = connection
     
         # Conexoes, filas, topicos, senders e receivers que serao habilitados
         @connection_factories = {}
@@ -21,51 +20,28 @@ module JSparrow
         @topics               = {}
         @topic_senders        = {}
         @topic_receivers      = {}
-
-        # Foi iniciado?
-        @started = false
       end
   
       def is_started?
-        @started
+        @connection.is_opened?
       end
   
       def start
-        raise InvalidClientStateError.new('started', 'start') if is_started?
-    
-        begin
-          @jndi_context = @jndi_context_builder.build
-        rescue => cause
-          raise ClientInitializationError.new(@connection_config, cause)
-        end
+        @connection.open
     
         @connection_factories, @queues, @topics = lookup_resources
-    
-        @started = true
       end
   
       def is_stoped?
-        !@started
+        @connection.is_closed?
       end
   
       def stop
-        raise InvalidClientStateError.new('stoped', 'stop') if is_stoped?
-    
-        @jndi_context.close
-    
-        @started = false  
-      end
-
-      def queue_connection_factory_enabled?
-        @connection_config.enabled_connection_factories.include?(:queue_connection_factory)
+        @connection.close
       end
 
-      def queue_connection_factory
-        @connection_factories[:queue_connection_factory]
-      end
-  
       def queue_enabled?(queue_name)
-        @connection_config.enabled_queues.include?(queue_name)
+        @connection.configuration.enabled_queues.include?(queue_name)
       end
   
       def queue(queue_name)
@@ -84,16 +60,8 @@ module JSparrow
             Messaging::Receiver.new(queue_connection_factory, queue(queue_name))
       end
 
-      def topic_connection_factory_enabled?
-        @connection_config.enabled_connection_factories.include?(:topic_connection_factory)
-      end
-
-      def topic_connection_factory
-        @connection_factories[:topic_connection_factory]
-      end
-  
       def topic_enabled?(topic_name)
-        @connection_config.enabled_topics.include?(topic_name)
+        @connection.configuration.enabled_topics.include?(topic_name)
       end
   
       def topic(topic_name)
@@ -115,47 +83,21 @@ module JSparrow
       # -- Private methods -- #
       private
 
-        def lookup_resources
-          @lookuped_connection_factories = lookup_resource(@connection_config.enabled_connection_factories)
-          @lookuped_queues               = lookup_resource(@connection_config.enabled_queues)
-          @lookuped_topic                = lookup_resource(@connection_config.enabled_topics)
-          
-          return @lookuped_connection_factories, @lookuped_queues, @lookuped_topic
+        def queue_connection_factory
+          @connection_factories[:queue_connection_factory]
         end
   
-        def lookup_resource(jndi_names = {})
-          lookuped = {}
-      
-          return lookuped unless jndi_names
-          
-          jndi_names.each do |key, jndi_name|
-            lookuped[key] = @jndi_context.lookup(jndi_name)
-          end
-      
-          lookuped
+        def topic_connection_factory
+          @connection_factories[:topic_connection_factory]
         end
-    end
-
-    class ClientInitializationError < StandardError
-      attr_reader :config, :cause
-  
-      def initialize(config, cause)
-        super("Could not open connection to server. Verify the config's config.")
-    
-        @config = config
-        @cause  = cause
-      end
-    end
-
-    class InvalidClientStateError < StandardError
-      attr_reader :state, :operation
   
-      def initialize(state, operation)
-        super("Could not did #{operation} because client is #{state}.")
-    
-        @state     = state
-        @operation = operation
-      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
   end
 end

data/lib/connection.rb

@@ -9,27 +9,97 @@ module JSparrow
     # Metodo usado para configurar a conexao com o provedor de JMS.
     #
     def self.configure
-      @@config = Configuration.new
+      @@configuration = Configuration.new
       
-      yield @@config
+      yield @@configuration
       
-      @@config
+      @@jndi_context_builder = JNDI::ContextBuilder.new(@@configuration.jms_client_jar, @@configuration.jndi_properties)
+
+      @@configuration
     end
     
     #
     # Metodo usado para obter a configuracao para conexao com o provedor de JMS.
     #
     def self.configuration
-      @@config
+      @@configuration
     end
     
     #
     # Metodo usado para criar um novo Client JMS.
     #
     def self.new_client
-      jndi_context_builder = JNDI::ContextBuilder.new(@@config.jms_client_jar, @@config.jndi_properties)
+      connection = Base.new(@@configuration, @@jndi_context_builder)
+      
+      Client.new(connection)
+    end
+    
+    #
+    # Metodo usado para criar um novo Listener de mensagens JMS.
+    #
+    def self.new_listener(listener_spec)
+      connection = Base.new(@@configuration, @@jndi_context_builder)
       
-      Client.new(@@config, jndi_context_builder)
+      listener_spec[:as].new(connection)
+    end
+
+    #
+    # Classe base para estabelecer conexao com o provedor JMS via JNDI. 
+    #
+    class Base
+      attr_reader :configuration
+      
+      def initialize(configuration, jndi_context_builder)
+        @configuration        = configuration
+        @jndi_context_builder = jndi_context_builder
+
+        # Foi estabelecida?
+        @opened = false
+      end
+      
+      def is_opened?
+        @opened
+      end
+      
+      def open
+        raise InvalidStateError.new('opened', 'open') if is_opened?
+    
+        begin
+          @jndi_context = @jndi_context_builder.build
+        rescue => cause
+          raise InitializationError.new(@configuration, cause)
+        end
+        
+        @opened = true
+      end
+      
+      def is_closed?
+        not @opened
+      end
+
+      def close
+        raise InvalidStateError.new('closed', 'close') if is_closed?
+    
+        @jndi_context.close
+    
+        @opened = false  
+      end
+
+      def lookup_resources(resources = {})
+        lookuped_resource = {}
+
+        return lookuped_resource unless resources
+    
+        resources.each do |name, jndi_name|
+          lookuped_resource[name] = lookup_resource(jndi_name)
+        end
+
+        lookuped_resource
+      end
+      
+      def lookup_resource(jndi_name)
+        @jndi_context.lookup(jndi_name)
+      end
     end
 
     #
@@ -40,26 +110,83 @@ module JSparrow
       attr_reader :jms_client_jar, :jndi_properties,
                   :enabled_connection_factories, :enabled_queues, :enabled_topics
       
+      #
+      # Use:
+      #
+      # use_jms_client_jar "path/to/name_of_the_client_jar_file.jar"
+      #
       def use_jms_client_jar(client_jar)
         @jms_client_jar = client_jar
       end
       
+      #
+      # Use:
+      #
+      #   use_jndi_properties :a_jndi_property_name_in_lower_case     => "a_value_of_property",
+      #                       :other_jndi_property_name_in_lower_case => "other_value_of_property"
+      #
       def use_jndi_properties(jndi_properties = {})
         @jndi_properties = jndi_properties
       end
       
+      #
+      # Use:
+      #
+      #   enable_connection_factories :queue_connection_factory => "jndi_name_of_queue_connection_factory",
+      #                               :topic_connection_factory => "jndi_name_of_topic_connection_factory"
+      #
       def enable_connection_factories(jndi_names = {})
         @enabled_connection_factories = jndi_names
       end
       
+      #
+      # Use:
+      #
+      #   enable_queues :a_queue_name_in_lower_case     => "jndi_name_of_a_queue",
+      #                 :other_queue_name_in_lower_case => "jndi_name_of_other_queue"
+      #
       def enable_queues(jndi_names = {})
         @enabled_queues = jndi_names
       end
       
+      #
+      # Use:
+      #
+      #   enable_topics :a_topic_name_in_lower_case     => "jndi_name_of_a_topic",
+      #                 :other_topic_name_in_lower_case => "jndi_name_of_other_topic"
+      #
       def enable_topics(jndi_names = {})
         @enabled_topics = jndi_names
       end
     end
+
+    #
+    # Erro para quando uma conexao esta num estado invalido para uma operacao (open ou close).
+    #
+    class InvalidStateError < StandardError
+      attr_reader :state, :operation
+
+      def initialize(state, operation)
+        super("Could not did #{operation} because connection is #{state}.")
+
+        @state     = state
+        @operation = operation
+      end
+    end
+
+    #
+    # Erro para quando nao for possivel estabelecer conexao com o provedor JMS.
+    #
+    class InitializationError < StandardError
+      attr_reader :configuration, :cause
+
+      def initialize(configuration, cause)
+        super("Could not open connection to JMS provider. Verify the config's config.")
+
+        @configuration = configuration
+        @cause         = cause
+      end
+    end
   end
   
   module JNDI

data/lib/jsparrow.rb

@@ -6,5 +6,6 @@ require 'jms.rb'
 # Bibliotecas do JSparrow
 require 'connection.rb'
 require 'client.rb'
+require 'listener.rb'
 require 'messaging.rb'
 require 'error.rb'

data/lib/listener.rb

@@ -0,0 +1,146 @@
+# Classes Java usadas nesse arquivo
+import 'javax.naming.InitialContext'
+import 'javax.jms.MessageListener'
+
+module JSparrow
+  module Connection
+    
+    #
+    # Ouvintes de mensagens.
+    #
+    # Sao como clientes JMS, mas apenas para recebimento de mensagens.
+    #
+    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)
+      end
+      
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def is_listening?
+        @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.
+      #
+      def on_message(received_message)
+        class << received_message
+          include Messaging::MessageType
+        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).
+      #
+      # Invariavelmente deve ser re-implementado nas 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
+      
+        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
+  end
+end

data/lib/messaging.rb

@@ -1,6 +1,5 @@
 # Classes Java usadas nesse arquivo
 import 'javax.jms.Session'
-import 'javax.jms.MessageListener'
 
 module JSparrow
   module Messaging
@@ -80,22 +79,22 @@ module JSparrow
       # --- 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)
+        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
-        message = message_creator.call(session)
+          # Obtem uma mensagem (TextMessage, ObjectMessage ou MapMessage) do criador especifico
+          message = message_creator.call(session)
         
-        # Envia a mensagem
-        producer.send(message)
+          # Envia a mensagem
+          producer.send(message)
         
-        # Commita a sessao e fecha a conexao
-        session.commit
-        connection.close
-      end
+          # Commita a sessao e fecha a conexao
+          session.commit
+          connection.close
+        end
     end
     
     #
@@ -128,117 +127,22 @@ module JSparrow
         connection.close
       end
     end
-    
-    #
-    # Ouvintes de mensagens.
+  
     #
-    # TODO: Completar a implementacao. Ainda nao esta legal. (Ja dei um tapinha,
-    #       acho que agora ta bem proximo do que deve ser.)
+    # Identifica o tipo de uma mensagem.
     #
-    class Listener < Base
-      include MessageListener
-      
-      attr_reader :connection_factory_name, :destination_name, :criteria_to_receiving
-      
-      #
-      # Estes parametros serao injetados pelo listener manager de acordo com o
-      # que houver sido definido pelos metodos connection_factory_name e destination_name.
-      #
-      def initialize(connection_factory, destination)
-        super(connection_factory, destination)
-        
-        @connection_factory_name = 'undefined'
-        @destination_name        = 'undefined'
-        @criteria_to_receiving   = {}
-      end
-
-      #
-      # Nome JNDI da connection factory que ser usada para criar conexoes JMS.
-      #
-      # Invariavelmente deve ser usado pelas subclasses para informar qual devera
-      # ser a connection factory usada por esse listener.
-      #
-      def use_connection_factory(jndi_name)
-        @connection_factory_name = jndi_name
+    module MessageType
+      def is_text_message?
+        respond_to? :get_text
       end
-      
-      #
-      # Nome JNDI do destino JMS que sera escutado.
-      #
-      # Invariavelmente deve ser usado pelas subclasses, para informar o nome
-      # da queue ou topico que sera escutado.
-      #
-      def listen_to_destination(jndi_name)
-        @destination_name = jndi_name
-      end
-      
-      #
-      # Criterios de selecao de mensagens, seguindo o padrao JMS.
-      #
-      # Invariavelmente as subclasses precisam usar esse metodo para definir
-      # os criterios de recebimento que este listener levara em conta.
-      #
-      def receive_only_in_criteria(criteria = {:timeout => DEFAULT_RECEIVER_TIMEOUT, :selector => ''})
-        # Valor default para timeout, caso nao tenha sido informado
-        @criteria_to_receiving[:timeout] = criteria[:timeout] || DEFAULT_RECEIVER_TIMEOUT
-      end
-
-      #
-      # Inicia a escuta de mensagens.
-      #
-      def start_listening
-        # 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])
-        
-        # Registra-se como ouvinte
-        consumer.message_listener = self
-        
-        # Inicia a escuta de mensagens
-        connection.start
-      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.
-      #
-      def on_message(received_message)
-        class << received_message
-          include MessageType
-        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).
-      #
-      # Invariavelmente deve ser re-implementado nas subclasses.
-      #
-      def on_receive_message(received_message)
-        raise Error::AbstractMethodError.new('on_receive_message')
-      end
-    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_object_message?
+        (respond_to? :get_object and !(respond_to? :get_long))
+      end
     
-    def is_map_message?
-      respond_to? :get_long
+      def is_map_message?
+        respond_to? :get_long
+      end
     end
   end
 end