a13g 0.1.0.beta3 → 0.1.0.beta4

data/lib/a13g/adapters/stomp_adapter.rb

@@ -0,0 +1,163 @@
+module A13g
+  module Adapters
+    class StompAdapter < AbstractAdapter
+      def initialize(config, logger)
+        unless defined? Stomp
+          begin 
+            require_library_or_gem('stomp')
+          rescue LoadError
+            $stderr.puts '!!! Please install the stomp gem and try again: gem install stomp.'
+            raise
+          end
+        end
+        
+        config.symbolize_keys
+        
+        config = {
+          :login               => '',
+          :passcode            => '',
+          :host                => 'localhost', 
+          :port                => config[:ssl] ? 61612 : 61613,
+          :reliable            => true,
+          :dead_letter_queue   => '/queue/DLQ',
+          :client_id           => nil,
+          :max_retry           => 0,
+          :max_reconnect_delay => 30.0,
+          :timeout             => -1,
+          :ssl                 => false
+          }.merge(config)
+          
+        super(config, logger)
+        
+        @connection_options = {
+          :hosts => [
+            {
+              :login    => @config[:login], 
+              :passcode => @config[:passcode], 
+              :host     => @config[:host], 
+              :port     => @config[:port],
+              :ssl      => @config[:ssl],
+              :reliable => @config[:reliable],
+            },],
+          :initial_reconnect_delay  => 0.01,
+          :max_reconnect_delay      => @config[:max_reconnect_delay],
+          :use_exponential_back_off => true,
+          :back_off_multiplier      => 2,
+          :max_reconnect_attempts   => @config[:max_retry],
+          :randomize                => false,
+          :backup                   => false,
+          :timeout                  => @config[:timeout]
+        }
+        
+        connect
+      end
+      
+      def adapter_name
+        'Stomp'.freeze
+      end
+      
+      def url 
+        "stomp://#{@config[:host]}:#{@config[:port]}" if @config
+      end
+      
+      def active?
+        if @connection.respond_to?(:open?)
+          @connection.open?
+        else
+          false
+        end  
+      end
+      
+      def reconnect!
+        disconnect!
+        connect
+      end
+      
+      def disconnect!(headers={})
+        if active? && @connection.respond_to?(:disconnect)
+          @connection.disconnect(headers)
+        end
+      end
+      
+      def ack(message, headers={})
+        if message
+          ack_headers = message.headers.has_key?(:transaction) ? message.headers[:transaction] : {}
+          headers = ack_headers.merge(headers)
+          result = raw_connection.ack(message.headers['message-id'], headers)
+          run_callbacks(:after_ack, [message, headers])
+          result
+        end
+      end
+      
+      def begin(name, headers={})
+        result = raw_connection.begin(name, headers)
+        run_callbacks(:after_begin_transaction, [name, headers])
+        result
+      end
+      
+      def commit(name, headers={})
+        result = raw_connection.commit(name, headers)
+        run_callbacks(:after_commit_transaction, [name, headers])
+        result
+      end
+      
+      def abort(name, headers={})
+        result = raw_connection.abort(name, headers)
+        run_callbacks(:after_abort_transaction, [name, headers])
+        result
+      end
+      
+      def subscribe(destination, headers={}, sub_id=nil)
+        result = raw_connection.subscribe(destination, headers, sub_id)
+        run_callbacks(:after_subscribe, [destination, headers, sub_id])
+        result
+      end
+      
+      def unsubscribe(destination, headers={}, sub_id=nil)
+        result = raw_connection.unsubscribe(destination, headers, sub_id=nil) 
+        run_callbacks(:after_unsubscribe, [destination, headers, sub_id])
+        result
+      end
+      
+      def publish(destination, message, headers={})
+        headers = { :persistent => true }.merge(headers)
+        result = raw_connection.publish(destination, message, headers) 
+        run_callbacks(:after_publish, [destination, message, headers])
+        result
+      end
+      
+      def receive
+        raw_message = raw_connection.receive
+        message = Message.new(raw_message, raw_message.headers['message-id'], 
+          raw_message.headers, raw_message.body, raw_message.command, self)
+        run_callbacks(:after_receive, [message])
+        message
+      end
+      
+      def unreceive(message, headers={})
+        defaults = { :dead_letter_queue => @config[:dead_letter_queue] }
+        headers = headers.merge(defaults)
+        result = raw_connection.unreceive(message, headers)
+        run_callbacks(:after_receive, [message, headers])
+        result
+      end
+      
+      def client_ack?(message)
+        raw_connection.client_ack?(message)
+      end
+      
+      protected
+      
+      def connect
+        if @connection = Stomp::Connection.new(@connection_options)
+          logger.debug "Stomp connection with broker at #{url} has been established"
+        else
+          verify!
+        end
+      end
+    end
+    
+    register(:stomp, StompAdapter)
+  end
+end
+

data/lib/a13g/adapters/test_adapter.rb

@@ -0,0 +1,102 @@
+module A13g
+  module Adapters
+    class TestAdapter < AbstractAdapter
+    
+      def initialize(config, logger)
+        super(config, logger)
+        @receiving_queue = []
+        connect
+      end
+      
+      def adapter_name
+        'Test'.freeze
+      end
+      
+      def url 
+        ''
+      end
+      
+      def active?
+        @active ||= false
+      end
+      
+      def reconnect!
+        disconnect!
+        connect
+      end
+      
+      def disconnect!(headers={})
+        @active = false if active?
+      end
+      
+      def ack(message, headers={})
+        if message
+          run_callbacks(:after_ack, [message, headers])
+          true
+        end
+      end
+      
+      def begin(name, headers={})
+        run_callbacks(:after_begin_transaction, [name, headers])
+        true
+      end
+      
+      def commit(name, headers={})
+        run_callbacks(:after_commit_transaction, [name, headers])
+        true
+      end
+      
+      def abort(name, headers={})
+        run_callbacks(:after_abort_transaction, [name, headers])
+        true
+      end
+      
+      def subscribe(destination, headers={}, sub_id=nil)
+        run_callbacks(:after_subscribe, [destination, headers, sub_id])
+        true
+      end
+      
+      def unsubscribe(destination, headers={}, sub_id=nil)
+        run_callbacks(:after_unsubscribe, [destination, headers, sub_id])
+        true
+      end
+      
+      def publish(destination, message, headers={})
+        headers = {
+          'message-id' => 'TEST', 
+          'destination' => destination.to_s
+          }.merge(headers)
+        msg = OpenStruct.new(
+          :body => message,
+          :headers => headers,
+          :command => 'MESSAGE'
+          )
+        @receiving_queue << Message.new(msg, msg.headers['message-id'], 
+          msg.headers, message, msg.command, self)
+        run_callbacks(:after_publish, [destination, message, headers])
+        true
+      end
+      
+      def receive
+        if message = @receiving_queue.shift
+          run_callbacks(:after_receive, [message])
+          message                
+        end
+      end
+      
+      def unreceive(message, headers={})
+        run_callbacks(:after_receive, [message, headers])
+      end
+      
+      protected
+      
+      def connect
+        @active = true
+        logger.debug "Test connection has been established"
+      end
+    end
+    
+    register(:test, TestAdapter)
+  end
+end
+

data/lib/a13g/base.rb

@@ -0,0 +1,448 @@
+require 'ostruct'
+
+module A13g
+  # It describes connection during setup. 
+  class ConnectionSpecification
+    attr_reader :config, :adapter
+    def initialize(config, adapter)
+      @config, @adapter = config, adapter
+    end
+  end
+  
+  # It keeps context informations about connection and related consumers. 
+  class ConnectionContext
+    attr_reader :name, :related_classes, :connection
+    
+    # Constructor.
+    #
+    # @param [Symbol] name
+    #   context name
+    # @param [A13g::Adapters::AbstractAdapter] connection
+    #   related connection
+    # @param [Array] related classess
+    #   list of consumers woring in this context
+    #
+    # @api public
+    def initialize(name, connection, related_classes=[])
+      @name, @connection, @related_classes = name, connection, related_classes
+      @related_classes << Base if name == :default
+    end
+    
+    def to_s # :nodoc:
+      name
+    end
+  end
+  
+  class Base
+    # Returns broker configuration for current connection and environment. 
+    #
+    # For example, the following broker.yml...
+    #
+    #   development:
+    #     adapter: stomp
+    #     host: localhost
+    #     port: 61613
+    #
+    # ...would result in A13g::Base#config on development environment
+    # to look like this:
+    #
+    #   {
+    #     'development' => {
+    #       'adapter' => 'stomp'
+    #       'host'    => 'localhost'
+    #       'port'    => 61613
+    #     }
+    #   } 
+    #
+    # @api public
+    cattr_reader :configurations
+    @@configurations = HashWithIndifferentAccess.new
+    
+    # @api public
+    cattr_accessor :logger, :instance_writer => false
+    @@logger = nil
+
+    # @api public
+    cattr_accessor :environment, :instance_writer => false 
+    @@environment = nil
+    
+    # @api public
+    cattr_reader :ready
+    @@ready = false
+    
+    # Keeps list of connection contexts.
+    #
+    # @api public
+    cattr_reader :contexts
+    @@contexts = HashWithIndifferentAccess.new
+    
+    # List of contexts related with consumers.
+    #
+    # @api public
+    cattr_reader :contextuals
+    @@contextuals = {}
+    
+    # @api public
+    cattr_reader :path
+    @@path = nil
+    
+    # Returns the connection currently associated with the class.
+    # 
+    # @return [A13g::Adapters::AbstractAdapter]
+    #   currenct connection
+    #
+    # @api public
+    def connection
+      self.class.connection
+    end
+    
+    class << self
+      # Returns all pathes to important directories and files. 
+      #
+      # You can define following pathes when your project structure is different
+      # than standard Ruby on Rails / Merb / Padrino application. 
+      #
+      #   A13g::Base.path.app              # => path to application
+      #   A13g::Base.path.config           # => path to broker configuration file
+      #   A13g::Base.path.consumers        # => path to consumers directory
+      #
+      # There is also shortcut: A13g#path. 
+      #
+      # @see A13g#path  
+      #  
+      # @return [Struct(:root, :log, :config, :consumers)] 
+      #   important directories pathes
+      #
+      # @api public
+      def path
+        unless @@path
+          @@path = OpenStruct.new  
+          @@path.root ||= APP_ROOT if defined?(APP_ROOT)
+          @@path.root ||= RACK_ROOT if defined?(RACK_ROOT)
+          @@path.root ||= RAILS_ROOT if defined?(RAILS_ROOT)
+          @@path.root ||= Rails.root if defined?(Rails)
+          @@path.root ||= "./"
+          @@path.config ||= File.join(@@path.root.to_s, 'config')
+          @@path.consumers ||= File.join(@@path.root.to_s, 'app', 'consumers')
+        end
+        @@path
+      end
+      
+      # Current environment.
+      #
+      # @return [String]
+      #   env name
+      #
+      # @api public
+      def environment
+        unless @environment
+          @@environment ||= APP_ENV.to_s if defined?(APP_ENV)
+          @@environment ||= RACK_ENV.to_s if defined?(RACK_ENV)
+          @@environment ||= Rails.env.to_s if defined?(Rails)
+          @@environment ||= 'development'
+        end
+        @@environment
+      end
+      
+      # Output logger for processor instance. Actually it's global logger for 
+      # whole A13g.
+      #
+      # @return [Logger]
+      #
+      # @api public
+      def logger
+        unless @@logger
+          @@logger ||= APP_LOGGER if defined?(APP_LOGGER)
+          @@logger ||= Merb::Logger if defined?(Merb::Logger)
+          @@logger ||= RAILS_DEFAULT_LOGGER if defined?(RAILS_DEFAULT_LOGGER)
+          @@logger ||= Rails.logger if defined?(Rails) && !defined?(RAILS_DEFAULT_LOGGER)
+          @@logger ||= Logger.new(STDOUT)
+        end
+        @@logger
+      end
+      
+      # Returns `true` if was successfully prepared to work.
+      #
+      # @return [Boolean]
+      #   is A13g ready to work
+      #
+      # @api public
+      def ready?
+        @@ready
+      end
+      
+      # Prepares configuration if not ready and creates connection in specified 
+      # context. 
+      #
+      # Here you have few examples how to setup A13g... 
+      #   
+      #   # ...using configuration hash
+      #   A13g::Base.setup(:default, :adapter => 'stomp', :host => 'localhost') 
+      # 
+      #   # ...using configuration for specified environment 
+      #   A13g::Base.setup(:default, :development)            
+      # 
+      #   # ...using default context and current environment configuration            
+      #   A13g::Base.setup() # or A13g::Base.setup(:default)
+      #
+      #   # ...using shortcut
+      #   A13g.setup(:default)
+      #
+      # @param [Context] context
+      #   context name
+      # @param [Hash, Symbol, ConnectionSpecification] spec
+      #   connection configuration
+      #
+      # @return [A13g::Adapters::AbstractAdapter] 
+      #   established connection
+      #
+      # @api public
+      def setup(context=:default, spec=nil)
+        unless ready?
+          path.freeze
+          environment.freeze
+          logger
+          if !spec.is_a?(Hash) && !spec.is_a?(ConnectionSpecification)
+            load_config_from_file
+          else
+            @@configurations[context] = HashWithIndifferentAccess.new
+            @@configurations[context][environment] = spec if spec.is_a?(Hash)
+            @@configurations[context][environment] = spec.config if spec.is_a?(ConnectionSpecification)
+          end
+          @@ready = true
+        end
+        establish_connection(context, spec)
+      end
+      
+      # Clears all destinations and closes active connections. 
+      #
+      # @api public
+      def teardown
+        destroy_subscriptions
+        clear_all_connections!
+        @@logger = nil
+        @@path = nil
+        @@environment = nil
+        @@contextuals = {}
+        @@configurations = HashWithIndifferentAccess.new
+        @@contexts = HashWithIndifferentAccess.new
+        @@ready = false
+      end
+
+      # Connection currently associated with the class or connection from
+      # specified context. 
+      #
+      # @param [Symbol] name
+      #   context name 
+      #
+      # @return [A13g::Adapters::AbstractAdapter]
+      #   found connection
+      #
+      # @api public
+      def connection(name=nil)
+        unless name.nil?
+          context = @@contexts[name]
+          if context
+            raise_connection_error(name) unless context.connection
+            return context.connection 
+          end 
+        else
+          if context
+            raise_connection_error(name) unless context.connection
+            return context.connection
+          else
+            return connection(:default)
+          end
+        end
+        raise_connection_error(:default)
+      end
+      
+      # Defines connection context. For consumers can be called only once per class. 
+      #
+      # @param [Symbol] name
+      #   connection name
+      # 
+      # @return [A13g::ConnectionContext] 
+      #   related context 
+      #
+      # @api public 
+      def context(name=nil)
+        if name.nil?
+          if @@contextuals[self]
+            return @@contextuals[self]
+          else
+            return @@contexts[:default]
+          end
+        end
+        unless @@contextuals[self]
+          if connection(name)
+            @@contexts[name].related_classes << self
+            @@contextuals[self] = @@contexts[name]
+          end
+        else
+          raise ContextAlreadyDefinedError
+        end
+      end
+      
+      # Returns true if connected with broker is established and valid.
+      #
+      # @return [Boolean] 
+      #   connection state
+      #
+      # @api public
+      def connected?
+        connection && connection.active?
+      end
+
+      # Creates all defined subscriptions.
+      #
+      # @api public
+      def create_subscriptions
+        load_consumers
+        Subscription.all.each {|name, subscription| subscription.subscribe }
+      end
+      
+      # Destroys all active subscriptions.
+      #
+      # @api public
+      def destroy_subscriptions
+        Subscription.all.each {|name, subscription| subscription.unsubscribe }
+      end
+      
+      private
+      
+      # Connects to broker using authorization specified in <tt>spec</tt> param. 
+      #
+      # === Connection specification options
+      #
+      # * <tt>:adapter</tt>  - You can use one of following: stomp, jms, wmq, test,
+      #   beanstalk, asqs, realiable_msg
+      # * <tt>:username</tt> - User name for authentication
+      # * <tt>:password</tt> - Password for authentication
+      # * <tt>:host</tt> - Where broker is served
+      # * <tt>:port</tt> - Which port you want to connect 
+      #
+      # There are also adapter specific options, like eg. <tt>:max_retry</tt>, 
+      # or # <tt>:dead_letter_queue</tt> for stomp adapter. 
+      # 
+      # @see A13g#setup
+      #
+      # @api private
+      def establish_connection(context, spec=nil)
+        case spec
+        when nil
+          establish_connection(context, environment)
+        when ConnectionSpecification
+          remove_connection(name)
+          adapter = Adapters.load(spec.adapter)
+          conn = adapter.new(spec.config, logger)
+          @@contexts[context] = ConnectionContext.new(context, conn)
+          conn
+        when Symbol, String
+          if configurations[context] && configuration = configurations[context][spec.to_s]
+            establish_connection(context, configuration)
+          else
+            raise AdapterNotSpecified, "Broker in `#{spec}` environment is not configured"
+          end
+        when Hash
+          spec = spec.symbolize_keys
+          establish_connection unless spec.key?(:adapter)
+          establish_connection(context, ConnectionSpecification.new(spec, spec[:adapter]))
+        else
+          raise ArgumentError, "Unknown connection specification"
+        end
+      end
+      
+      # @param [Symbol] name
+      #   context name
+      #
+      # @api private
+      def raise_connection_error(name)
+        if name != :default
+          raise ConnectionNotEstablished, "Connection marked as `#{name}` is not established"
+        else
+          raise MissingDefaultContext, "There is not defined default connection context. Did you forgot about `:default`?" 
+        end
+        nil
+      end
+      
+      # Removes specified connection.
+      #
+      # @param [Symbol] name
+      #   context name
+      #
+      # @api private
+      def remove_connection(context)
+        context = @@contexts.delete(context)
+        context.connection.disconnect! if context && context.connection
+      end
+      
+      # Close all active connections. 
+      #
+      # @api private
+      def clear_active_connections!
+        @@contexts.values.each do |context| 
+          if c = context.connection
+            c.disconnect! if c.active?
+          end
+        end
+      end
+      
+      # Close all connections.
+      #
+      # @api private
+      def clear_all_connections!
+        @@contexts.values.each do |context| 
+          if c = context.connection
+            c.disconnect!
+          end
+        end
+      end
+      
+      # Verify all connections. 
+      #
+      # @api private
+      def verify_active_connections!
+        @@contexts.values.each do |context| 
+          if c = context.connection
+            c.verify!
+          end
+        end
+      end
+      
+      # Load configurations from file.
+      #
+      # @param [Symbol] context
+      #   context name 
+      #
+      # @return [HashWithIndifferentAccess]
+      #   configuration hash
+      # 
+      # @api private
+      def load_config_from_file(context=:default)
+        fname = context == :default ? "broker.yml" : "broker-#{context.to_s}.yml"
+        cpath = File.join(@@path.config, fname)
+        if File.exists?(cpath)
+          conf = YAML.load_file(cpath)
+          @@configurations[context] = HashWithIndifferentAccess.new(conf)
+        end
+      end
+      
+      # Loads all available consumers. 
+      #
+      # @api private
+      def load_consumers
+        if File.exists?(path.consumers)
+          begin
+            load File.join(path.consumers, 'application_consumer.rb')
+          rescue LoadError
+            # Do nothing... It is allowed to skip ApplicationConsumer.
+          end
+          Dir[File.join(path.consumers, '*_consumer.rb')].each do |f|
+            load f unless f =~ /\/application_consumer.rb\Z/
+          end
+        end
+      end
+    end
+  end
+end