a13g 0.1.0.beta3 → 0.1.0.beta4

data/lib/a13g/message.rb

@@ -0,0 +1,68 @@
+module A13g
+  # This message class is based on stomp message. Should be used by all 
+  # adapter to representating of received messages. 
+  class Message
+    attr_accessor :headers 
+    attr_reader :body, :command, :destination
+    attr_reader :original
+    attr_reader :id
+    attr_accessor :ack
+    
+    # Constructor.
+    #
+    # @param [Object] original
+    #   original object of received message
+    # @param [String] id
+    #   message id
+    # @param [String] body
+    #   message content
+    # @param [String] command
+    #   type of received message, eg. MESSAGE, ERROR, etc...
+    # @param [A13g::Adapters::AbstractAdapter] connection
+    #   connection related with message
+    #
+    # @api public
+    def initialize(original, id, headers, body, command='MESSAGE', connection=Base.connection)
+      @original = original
+      @headers, @body, @command = headers, body, command
+      @destination = Destination.new(@headers['destination'])
+      @id = id
+      @connection = connection
+      @ack = false
+    end
+    
+    def to_s # :nodoc:
+      "<A13g::Message @id='#{id} @body='#{body}' @headers='#{headers.inspect}' @command='#{command}'>"
+    end
+    
+    # Shortcut to acknowledge message.  
+    #
+    # @api public
+    def ack!
+      @connection.ack(@original)
+      @ack = true
+      @connection.logger.info(">> (#{@connection.url}#{@destination.name}): ACK #{@id}")
+    end
+    
+    # Returns true when message has been acknowledged
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def ack?
+      !!@ack
+    end
+    
+    # It says to processor, that message processing should be aborded. 
+    #
+    # @api public
+    def abort!
+      raise AbortMessage
+    end
+    
+    # It says to processor, that message should be ignored.
+    def ignore!
+      raise IgnoreMessage
+    end
+  end
+end

data/lib/a13g/producer.rb

@@ -0,0 +1,107 @@
+module A13g
+  # Mixin for publishing messages.  
+  #
+  # === Simple publishing:
+  #
+  #   include A13g::Producer
+  #   publish("/queue/Example", "This is test...")
+  #
+  # === Publishing to different hosts:
+  #
+  #   A13g.setup(:first, :adapter => 'stomp', {}, :host => 'first.host.com')
+  #   A13g.setup(:second, :adapter => 'stomp', {}, :host => 'second.host.com')
+  #
+  #   publish("/queue/Example", "My first message", {}, :first)  # will be sent to first.host.com
+  #   publish("/queue/Example", "My second message", {}, :first) # will be sent to second.host.com
+  # 
+  # === Access directly from A13g:
+  #   
+  #   A13g.publish("/queue/Example", "Message from A13g..."
+  #
+  # === Transactions:
+  #
+  #   begin("trans")
+  #   publish("/queue/Example", "First message...", { :transaction => "trans" })
+  #   publish("/queue/Example", "Second message...", { :transaction => "trans" })
+  #   publish("/queue/Example", "Third message...", { :transaction => "trans" })
+  #   commit("trans")
+  module Producer
+    # Publishes message to specified destination.
+    # 
+    # @param [String] destination
+    #   where message should be sent
+    # @param [String] message
+    #   text to send
+    # @param [Hash] headers
+    #   message headers
+    # @param [Symbol] context
+    #   connection name, which should be used
+    # @param [Array] args
+    #   additional arguments
+    #
+    # @api public
+    def publish(destination, message, headers={}, context=nil, *args)
+      context ||= a13g_context
+      conn = Base.connection(context)
+      conn.logger.info(">> " + Utils.format_message("#{conn.url}#{destination}", message, headers))
+      conn.publish(destination, message, headers, *args)
+    end
+    
+    # Begins transaction.
+    # 
+    # @param [String, Symbol] name
+    #   transaction id
+    # @param [Hash] headers
+    #   transaction additional headers
+    # @param [Symbol] context
+    #   connection name, which should be used
+    # @param [Array] args
+    #   additional arguments
+    #
+    # @api public
+    def begin(name, headers={}, context=nil, *args)
+      context ||= a13g_context
+      conn = Base.connection(context)
+      conn.logger.info("Begin transaction at #{conn.url}#{destination}")
+      conn.begin(name, headers, *args)
+    end
+    
+    # Commit specified transaction. Params the same as #begin method.
+    #
+    # @see A13g::Producer#begin
+    #
+    # @api public
+    def commit(name, headers={}, context=nil, *args)
+      context ||= a13g_context
+      conn = Base.connection(context)
+      conn.logger.info("Commit transaction to #{conn.url}#{destination}")
+      conn.commit(name, headers, *args)
+    end
+    
+    # Abort specified transaction. Params the same as #begin method.
+    #
+    # @see A13g::Producer#begin
+    #
+    # @api public
+    def abort(name, headers={}, context=nil, *args)
+      context ||= a13g_context
+      conn = Base.connection(context)
+      conn.logger.info("Abort transaction at #{conn.url}#{destination}")
+      conn.abort(name, headers, *args)
+    end
+    
+    protected
+      
+    # Current context for publishing. 
+    #
+    # @api semipublic
+    def a13g_context
+      if respond_to?(:context)
+        context
+      else
+        :default
+      end
+    end
+  end
+end
+

data/lib/a13g/railtie.rb

@@ -0,0 +1,4 @@
+require "rails"
+#require "a13g"
+
+A13g::Base.setup(:default)

data/lib/a13g/recipes.rb

@@ -0,0 +1,31 @@
+# Capistrano Recipes for managing active_messaging
+#
+# Add these callbacks to have the active_messaging process restart when the server
+# is restarted:
+#
+#   after "deploy:stop",    "active_messaging:stop"
+#   after "deploy:start",   "active_messaging:start"
+#   after "deploy:restart", "active_messaging:restart"
+
+Capistrano::Configuration.instance.load do
+  namespace :delayed_job do
+    def rails_env
+      fetch(:rails_env, false) ? "RAILS_ENV=#{fetch(:rails_env)}" : ''
+    end
+    
+    desc "Stop the active_messaging process"
+    task :stop, :roles => :app do
+      run "cd #{current_path};#{rails_env} script/messaging stop"
+    end
+
+    desc "Start the active_messaging process"
+    task :start, :roles => :app do
+      run "cd #{current_path};#{rails_env} script/messaging start"
+    end
+
+    desc "Restart the active_messaging process"
+    task :restart, :roles => :app do
+      run "cd #{current_path};#{rails_env} script/messaging restart"
+    end
+  end
+end

data/lib/a13g/subscription.rb

@@ -0,0 +1,123 @@
+module A13g
+  class Subscription
+    # Special class for list of subscribed destinations. 
+    class DestinationsList < Hash; end
+    
+    attr_reader :consumer, :destination, :headers, :connection, :args
+    
+    # List of all defined destinations.
+    #
+    # @api public
+    cattr_accessor :all
+    @@all = DestinationsList.new
+    
+    # Constructor.
+    #
+    # @param [A13g::Consumer] consumer
+    #   consumer class
+    # @param [String] destination
+    #   subscribed destination
+    # @param [Hash] headers
+    #   additional connection headers
+    # @param [A13g::Adapters::AbstractAdapter] connection
+    #   connection object related with subscription
+    # @param [Array] args
+    #   additional subscription arguments
+    #
+    # @api public
+    def initialize(consumer, destination, connection=nil, headers={}, *args)
+      @consumer = consumer
+      @args = args
+      @connection = connection
+      @destination, @headers = destination, headers
+      @headers['persistent'] = true
+      @headers['id'] = @consumer.class.to_s if has_consumer?
+    end
+    
+    # Returns `true` if consumer is assigned to this subscription. 
+    #
+    # @return [Boolean]
+    #   is there related consumer?
+    #
+    # @api public
+    def has_consumer?
+      !!consumer
+    end
+    
+    # Subscribes current destination.
+    #
+    # @api public
+    def subscribe
+      if has_consumer? 
+        connection.logger.debug("Destination #{connection.url}#{destination} subscribed by #{consumer.class.to_s}")
+        connection.subscribe(destination, headers, *args)
+      end
+    end
+    
+    # Unsubscribes destination. 
+    # 
+    # @api public
+    def unsubscribe
+      connection.unsubscribe(destination, headers, *args)
+    end
+    
+    # Port to publishing in current destination. 
+    #
+    # @param [String] message
+    #   text to send
+    # @param [Hash] headers
+    #   additional connection headers
+    # @param [Array] args
+    #   additional arguments
+    #
+    # @api public
+    def publish(message, headers={}, *args) # :nodoc:
+      headers = self.headers.merge(headers)
+      connection.publish(destination, message, headers, *args)
+    end
+    
+    # Find destination using specified conditions.
+    #
+    # @param [Array] conditions
+    #   key only, or name of destination with connection object
+    #
+    # @return [A13g::Subscription]
+    #   matching subscription
+    #
+    # @api public
+    def self.find(*conditions)
+      if conditions.size == 1
+        klass = conditions[0]
+        if all.key?(klass.to_s)
+          return all[klass.to_s]
+        else
+          raise DestinationNotDefinedError, "#{klass.to_s} don't subscribes any destination"
+        end    
+      elsif conditions.size < 3
+        destination, connection = conditions[0], conditions[1]
+        return all.values.find {|x| x.destination == destination.to_s && x.connection === connection}
+      else
+        raise ArgumentError, 'To many actual parameters'
+      end
+        
+    end
+    
+    # Creates new subscription. Parameters the same as #initialize method. 
+    #
+    # @see A13g::Subscription#initialize
+    #
+    # @return [A13g::Subscription]
+    #   created subscription
+    #
+    # @api public
+    def self.create(consumer, destination, headers={}, connection=Base.connection, *args)
+      unless subscription = find(destination, connection)
+        return all[consumer.class.name] = new(consumer, destination, connection, headers, *args)
+      else
+        raise DestinationAlreadySubscribedError, 
+          "Destination #{conneciton.url}#{destination} has been already subscribed by `#{consumer.class.name}`"
+      end 
+      return subscription
+    end
+  end
+end

data/lib/a13g/support/logger.rb

@@ -0,0 +1,194 @@
+require "time" # httpdate
+# ==== Public Extlib Logger API
+#
+# To replace an existing logger with a new one:
+#  Extlib::Logger.set_log(log{String, IO},level{Symbol, String})
+#
+# Available logging levels are
+#   Extlib::Logger::{ Fatal, Error, Warn, Info, Debug }
+#
+# Logging via:
+#   Extlib.logger.fatal(message<String>,&block)
+#   Extlib.logger.error(message<String>,&block)
+#   Extlib.logger.warn(message<String>,&block)
+#   Extlib.logger.info(message<String>,&block)
+#   Extlib.logger.debug(message<String>,&block)
+#
+# Logging with autoflush:
+#   Extlib.logger.fatal!(message<String>,&block)
+#   Extlib.logger.error!(message<String>,&block)
+#   Extlib.logger.warn!(message<String>,&block)
+#   Extlib.logger.info!(message<String>,&block)
+#   Extlib.logger.debug!(message<String>,&block)
+#
+# Flush the buffer to
+#   Extlib.logger.flush
+#
+# Remove the current log object
+#   Extlib.logger.close
+#
+# ==== Private Extlib Logger API
+#
+# To initialize the logger you create a new object, proxies to set_log.
+#   Extlib::Logger.new(log{String, IO},level{Symbol, String})
+module A13g
+  class Logger
+
+    attr_accessor :level
+    attr_accessor :delimiter
+    attr_accessor :auto_flush
+    attr_reader   :buffer
+    attr_reader   :log
+    attr_reader   :init_args
+
+    # ==== Notes
+    # Ruby (standard) logger levels:
+    # :fatal:: An unhandleable error that results in a program crash
+    # :error:: A handleable error condition
+    # :warn:: A warning
+    # :info:: generic (useful) information about system operation
+    # :debug:: low-level information for developers
+    Levels =
+    {
+      :fatal => 7,
+      :error => 6,
+      :warn  => 4,
+      :info  => 3,
+      :debug => 0
+    }
+
+    private
+
+    # Readies a log for writing.
+    #
+    # ==== Parameters
+    # log<IO, String>:: Either an IO object or a name of a logfile.
+    def initialize_log(log)
+      close if @log # be sure that we don't leave open files laying around.
+
+      if log.respond_to?(:write)
+        @log = log
+      elsif File.exist?(log)
+        @log = open(log, (File::WRONLY | File::APPEND))
+        @log.sync = true
+      else
+        FileUtils.mkdir_p(File.dirname(log)) unless File.directory?(File.dirname(log))
+        @log = open(log, (File::WRONLY | File::APPEND | File::CREAT))
+        @log.sync = true
+        @log.write("#{Time.now.httpdate} #{delimiter} info #{delimiter} Logfile created\n")
+      end
+    end
+
+    public
+
+    # To initialize the logger you create a new object, proxies to set_log.
+    #
+    # ==== Parameters
+    # *args:: Arguments to create the log from. See set_logs for specifics.
+    def initialize(*args)
+      @init_args = args
+      set_log(*args)
+      self.auto_flush = true
+      A13g.logger = self
+    end
+
+    # Replaces an existing logger with a new one.
+    #
+    # ==== Parameters
+    # log<IO, String>:: Either an IO object or a name of a logfile.
+    # log_level<~to_sym>::
+    #   The log level from, e.g. :fatal or :info. Defaults to :error in the
+    #   production environment and :debug otherwise.
+    # delimiter<String>::
+    #   Delimiter to use between message sections. Defaults to " ~ ".
+    # auto_flush<Boolean>::
+    #   Whether the log should automatically flush after new messages are
+    #   added. Defaults to false.
+    def set_log(log, log_level = nil, delimiter = " ~ ", auto_flush = false)
+      if log_level && Levels[log_level.to_sym]
+        @level = Levels[log_level.to_sym]
+      else
+        @level = Levels[:debug]
+      end
+      @buffer     = []
+      @delimiter  = delimiter
+      @auto_flush = auto_flush
+
+      initialize_log(log)
+    end
+
+    # Flush the entire buffer to the log object.
+    def flush
+      return unless @buffer.size > 0
+      @log.write(@buffer.slice!(0..-1).join)
+    end
+
+    # Close and remove the current log object.
+    def close
+      flush
+      @log.close if @log.respond_to?(:close) && !@log.tty?
+      @log = nil
+    end
+
+    # Appends a message to the log. The methods yield to an optional block and
+    # the output of this block will be appended to the message.
+    #
+    # ==== Parameters
+    # string<String>:: The message to be logged. Defaults to nil.
+    #
+    # ==== Returns
+    # String:: The resulting message added to the log file.
+    def <<(string = nil)
+      message = ""
+      message << delimiter
+      message << string if string
+      message << "\n" unless message[-1] == ?\n
+      @buffer << message
+      flush if @auto_flush
+
+      message
+    end
+    alias :push :<<
+
+    # Generate the logging methods for Extlib.logger for each log level.
+    Levels.each_pair do |name, number|
+      class_eval <<-LEVELMETHODS, __FILE__, __LINE__
+
+      # Appends a message to the log if the log level is at least as high as
+      # the log level of the logger.
+      #
+      # ==== Parameters
+      # string<String>:: The message to be logged. Defaults to nil.
+      #
+      # ==== Returns
+      # self:: The logger object for chaining.
+      def #{name}(message = nil)
+        self << message if #{number} >= level
+        self
+      end
+
+      # Appends a message to the log if the log level is at least as high as
+      # the log level of the logger. The bang! version of the method also auto
+      # flushes the log buffer to disk.
+      #
+      # ==== Parameters
+      # string<String>:: The message to be logged. Defaults to nil.
+      #
+      # ==== Returns
+      # self:: The logger object for chaining.
+      def #{name}!(message = nil)
+        self << message if #{number} >= level
+        flush if #{number} >= level
+        self
+      end
+
+      # ==== Returns
+      # Boolean:: True if this level will be logged by this logger.
+      def #{name}?
+        #{number} >= level
+      end
+      LEVELMETHODS
+    end
+    
+  end
+end