fmq 0.3.0 → 0.3.1

data/History.txt

@@ -1,4 +1,14 @@
-== 0.3.0 2008-08-06
+== 0.3.1 2008-08-27
+
+* 2 minor changes:
+  * refactored the queue manager and remove legacy code (moved constraints stuff to the base queue)
+  * refactored the setup_queue method in the configuration file (sorry you have to change your configs)
+* 3 tiny changes:
+  * default-server can now be used from within the development repository (no rund trip nessesary)
+  * added and replaced some tests for the new interface of the queue manager and the base queue
+  * one can now yield and return messages
+
+== 0.3.0 2008-08-26
 
 * 2 minor changes:
   * replaced the mongrel handler by rack so that it can be used by many servers and in different configurations

data/README.txt

@@ -34,7 +34,7 @@ stores it’s internal data in an FIFO in system memory.
 == FEATURES/PROBLEMS:
 
 * FIFO message store
-* easy setup and maintenance of system
+* easy setup and maintenance of system (rack)
 * using http for communication
 * changeable queue implementation
 * ruby client lib

data/default-server/config.ru

@@ -1,4 +1,8 @@
-require "fmq"
+begin
+  require File.dirname(__FILE__) + '/../lib/fmq'
+rescue LoadError
+  require "fmq"
+end
 
 # load all local queues (from project directory)
 Dir.glob("queues/*.rb").each { |f| require f }
@@ -24,39 +28,33 @@ queue_manager.setup do |qm|
   #        define there url and constraints here
   # =====================================================
   
-  qm.setup_queue do |q|
-    # the path to the queue e.g. /app1/myframe/test1
-    # means http://localhost:5884/app1/myframe/test1
-    # this parameter is not optional
-    q.path = "/fmq_test/test1"
+  # the path to the queue e.g. /app1/myframe/test1
+  # means http://localhost:5884/app1/myframe/test1
+  # this parameter is not optional
+  qm.setup_queue "/fmq_test/test1" do |q|
     # this defines the maximum count of messages that 
     # can be in the queue, if the queue is full every
     # new message will be rejected with a http error
     # this parameter is optional if you don't specify
     # a max value the queue size depends on your system
-    q.max_messages = 1000000
+    q.max_messages = 1_000_000
     # this optional to and specifys the max content size
     # for all data of a queue
     # valid extensions are kb, mb, gb
-    q.max_size = "10kb"
+    q.max_size = 10.kb
   end
   
   # if you want you can specify the class of the queue
   # this is interessting if you write your own queues
-  qm.setup_queue FreeMessageQueue::LoadBalancedQueue do |q|
-    q.path = "/fmq_test/test2"
-  end
+  qm.setup_queue "/fmq_test/test2", FreeMessageQueue::LoadBalancedQueue
   
   # if you have special queues include put them into the queues
   # folder and and use them (this MyTestQueue is places in queues/mytest.rb)
-  qm.setup_queue MyTestQueue do |q|
-    q.path = "/fmq_test/test3"
-  end
+  qm.setup_queue "/fmq_test/test3", MyTestQueue
   
   # this is a forwarding queue wich forwards one message
   # to some other queues
-  qm.setup_queue FreeMessageQueue::ForwardQueue do |q|
-    q.path = "/fmq_test/forward_to_1_and_2"
+  qm.setup_queue "/fmq_test/forward_to_1_and_2", FreeMessageQueue::ForwardQueue do |q|
     # you can add as may queues as you want
     # but seperate them with a space char
     q.forward_to = ["/fmq_test/test1", "/fmq_test/test2"]

data/default-server/queues/my_test.rb

@@ -4,8 +4,8 @@ class MyTestQueue < FreeMessageQueue::BaseQueue
   end
   
   def poll
-    msg = FreeMessageQueue::Message.new "Hello World", "text/plain"
-    msg.option["Time"] = Time.now
-    msg
+    FreeMessageQueue::Message.new "Hello World", "text/plain" do |m|
+      m.option["Time"] = Time.now
+    end
   end
 end

data/lib/fmq/admin.rb

@@ -25,72 +25,85 @@ end
 
 module FreeMessageQueue
   # This class is dedicated to the AJAX based admin interface.
-  class AdminInterface
-    # rack response for bad requests
-    WRONG_METHOD = [400, {"CONTENT-TYPE" => "text/plain", "ERROR" => "Wrong http Method"}, ""]
-    
-    # rack response for good requests
-    OK = [200, {"CONTENT-TYPE" => "text/plain"}, ["ok"]]
-    
-    # create the admin interface for the passed QueueManager
-    def initialize(queue_manager)
-      @manager = queue_manager
-      @log = FreeMessageQueue.logger
-    end
-  
-    # handle all requests
-    def call(env)
-      begin
-        request = Rack::Request.new(env)
-        @log.debug "[AdminInterface] ENV: #{env.inspect}"
-        
-        if request.get? then
-          @log.info "[AdminInterface] list queues"
+  class AdminInterface
+    # rack response for bad requests
+    WRONG_METHOD = [400, {"CONTENT-TYPE" => "text/plain", "ERROR" => "Wrong http Method"}, ""]
+    
+    # rack response for good requests
+    OK = [200, {"CONTENT-TYPE" => "text/plain"}, ["ok"]]
+    
+    # create the admin interface for the passed QueueManager
+    def initialize(queue_manager)
+      @manager = queue_manager
+      @log = FreeMessageQueue.logger
+    end
+  
+    # handle all requests
+    def call(env)
+      begin
+        request = Rack::Request.new(env)
+        @log.debug "[AdminInterface] ENV: #{env.inspect}"
+        
+        if request.get? then
+          @log.info "[AdminInterface] list queues"
           # ======= LIST QUEUES
           queues_code = []
           @manager.queues.each do |queue_name|
             queues_code << queue_to_json(queue_name)
-          end
-          
-          return [200, {"CONTENT-TYPE" => "application/json"}, ["[%s]" % queues_code.join(","), ]]
-        elsif request.post? then
-          if request["_method"] == "delete" then
-            # ======= DELETE QUEUE
+          end
+          
+          return [200, {"CONTENT-TYPE" => "application/json"}, ["[%s]" % queues_code.join(","), ]]
+        elsif request.post? then
+          if request["_method"] == "delete" then
+            # ======= DELETE QUEUE
             @log.info "[AdminInterface] delete queue"
-            @manager.delete_queue(request["path"])
-            return OK
-          elsif request["_method"] == "create"
-            # ======= CREATE QUEUE
+            @manager.delete_queue(request["path"])
+            return OK
+          elsif request["_method"] == "create"
+            # ======= CREATE QUEUE
             @log.info "[AdminInterface] create queue"
-            @manager.create_queue(request["path"], 
-              request["max_messages"].gsub("null", "-1").to_i, 
-              request["max_size"].gsub("null", "-1").to_i)
-            return OK
-          else
-            return WRONG_METHOD
-          end
-        else
-          return WRONG_METHOD
-        end
-      rescue QueueManagerException => ex
-        return [400, {"CONTENT-TYPE" => "text/plain", "ERROR" => ex.message}, [ex.message]]
-      end
+            @manager.setup_queue request["path"] do |q|
+              q.max_messages = request["max_messages"].to_i
+              q.max_size = str_bytes request["max_size"]
+            end
+            return OK
+          else
+            return WRONG_METHOD
+          end
+        else
+          return WRONG_METHOD
+        end
+      rescue QueueManagerException => ex
+        return [400, {"CONTENT-TYPE" => "text/plain", "ERROR" => ex.message}, [ex.message]]
+      end
     end
     
   private
   
     # converts the data of one queue to json format
     def queue_to_json(queue_name)
-      constraints = @manager.queue_constraints[queue_name]
+      queue = @manager.queue(queue_name)
     
       "[\"%s\", %d, %d, %d, %d]" % [
         queue_name,
-        @manager.queue[queue_name].bytes,
-        constraints[:max_size],
-        @manager.queue[queue_name].size,
-        constraints[:max_messages],
+        queue.bytes,
+        queue.max_size,
+        queue.size,
+        queue.max_messages,
       ]
     end
+    
+    # Retuns count of bytes to a expression with kb, mb or gb
+    # e.g 10kb will return 10240
+    def str_bytes(str)
+      case str
+        when /([0-9]+)kb/i: $1.to_i.kb
+        when /([0-9]+)mb/i: $1.to_i.mb 
+        when /([0-9]+)gb/i: $1.to_i.gb
+        else
+          BaseQueue::INFINITE
+      end
+    end
   end
-end
-
+end
+

data/lib/fmq/queue_manager.rb

@@ -18,6 +18,21 @@
 # 
 require "ostruct"
 
+# add kb, mb and gb methods for easy use in the config file
+class Fixnum
+  def kb
+    self * 1024
+  end
+  
+  def mb
+    self.kb * 1024
+  end
+  
+  def gb
+    self.mb * 1024
+  end
+end
+
 module FreeMessageQueue
   # All queue manager exceptions are raised using this class
   class QueueManagerException < Exception
@@ -40,23 +55,8 @@ module FreeMessageQueue
   # corresponding constraints. Every queue that is created by this
   # queue manager will get a reference (<em>manager</em>) for later use.
   class QueueManager
-    # Returns the queue that is passed otherwise nil
-    attr_reader :queue
-    
     # <b>true</b> to let the queue manager create a queue automaticly
     attr_writer :auto_create_queues
-  
-    # Returns the queue constrains as a hash. The hash has the following structure:
-    #  {
-    #    :max_size => "100mb",
-    #    :max_messages => 1000
-    #  }
-    attr_reader :queue_constraints
-    
-    # This value is used to decribe that a constraint has no limit e.g.
-    #  :max_messages => INFINITE
-    # means that there is no limitation for messages
-    INFINITE = -1
     
     # this is the default queue class if no other is specified this
     # class will be created when setting up a queue
@@ -65,8 +65,7 @@ module FreeMessageQueue
     # setup the queue manager using the configuration from the configuration
     # file (which is basically a hash)
     def initialize()
-      @queue = {}
-      @queue_constraints = {}
+      @queues = {}
       @log = FreeMessageQueue.logger
       @auto_create_queues = true
     end
@@ -76,44 +75,26 @@ module FreeMessageQueue
     def auto_create_queues?
       @auto_create_queues == true
     end
-   
-    # Create a queue (<em>name</em> => <em>path</em>). The path must contain a leading "/" and a 3 character name
-    # at minimum. Exceptions will be raised if the queue allready exists.
-    def create_queue(name, max_messages = INFINITE, max_size = INFINITE, default_class = DEFAULT_QUEUE_CLASS)
-      # path must begin with /
-      raise QueueManagerException.new("[QueueManager] Leading / in path '#{name}' missing", caller) if name[0..0] != "/"
-      
-      # path must have a minimus lenght of 3 character
-      raise QueueManagerException.new("[QueueManager] The queue path '#{name}' is to short 3 character is minimum", caller) if name.size - 1 < 3
-      
-      # don't create a queue twice
-      raise QueueManagerException.new("[QueueManager] The queue '#{name}' allready exists", caller) if queue_exists? name
-    
-      @log.info("[QueueManager] Create queue '#{name}' {type: #{default_class}, max_messages: #{max_messages}, max_size: #{max_size}}")
-
-      @queue[name] = default_class.new(self)
-      @queue_constraints[name] = {
-        :max_messages => max_messages,
-        :max_size => max_size
-      }
-      
-      @queue[name]
-    end
     
     # create a queue using a block. The block can be used to set configuration
     # options for the queue
-    def setup_queue(queue_class = DEFAULT_QUEUE_CLASS, &configure_queue)   
-      queue_settings = OpenStruct.new
-      configure_queue.call(queue_settings)
-      create_queue_from_config(queue_class, queue_settings.marshal_dump)
+    def setup_queue(path, queue_class = DEFAULT_QUEUE_CLASS)
+      check_queue_name(path)
+      queue_object = queue_class.new(self)
+      if block_given? then
+        yield queue_object
+      end
+      @queues[path] = queue_object
+      @log.info("[QueueManager] Create queue '#{path}' {type: #{queue_class}, max_messages: #{queue_object.max_messages}, max_size: #{queue_object.max_size}}")
+      return queue_object
     end
    
     # Delete the queue by name (path)
     def delete_queue(name)
-      if @queue[name]
-        @log.info("[QueueManager] Delete queue '#{name}' with #{@queue[name].size} messages")
-        @queue[name].clear
-        @queue.delete name
+      if queue_exists? name
+        @log.info("[QueueManager] Delete queue '#{name}' with #{queue(name).size} messages")
+        queue(name).clear
+        @queues.delete name
         true
       else
         raise QueueManagerException.new("[QueueManager] There is no queue '#{name}'", caller)
@@ -122,10 +103,10 @@ module FreeMessageQueue
    
     # This returns one message from the passed queue
     def poll(name)
-      if @queue[name]
-        @log.debug("[QueueManager] Poll from queue '#{name}' with #{@queue[name].size} messages")
-        if @queue[name].respond_to? :poll
-          queue_item = @queue[name].poll
+      if queue_exists? name
+        @log.debug("[QueueManager] Poll from queue '#{name}' with #{queue(name).size} messages")
+        if queue(name).respond_to? :poll
+          queue_item = queue(name).poll
         else
           raise QueueManagerException.new("[QueueManager] You can't poll from queue '#{name}'", caller)
         end
@@ -141,7 +122,8 @@ module FreeMessageQueue
     # will be generated if there isn't a queue with the passed name (path). Otherwise
     # it will raise a QueueManagerException if the passed queue doesn't exists.
     def put(name, message)
-      unless @queue[name]
+      # check for auto createing queues if they are not available
+      unless queue_exists? name
         # only auto create queues if it is configured
         if auto_create_queues?
           create_queue(name) 
@@ -149,22 +131,10 @@ module FreeMessageQueue
           raise QueueManagerException.new("[QueueManager] There is no queue '#{name}'", caller)
         end
       end
-      
-      # check max size constraints
-      if @queue_constraints[name][:max_size] != INFINITE &&
-        @queue_constraints[name][:max_size] < queue[name].bytes + message.bytes
-        raise QueueManagerException.new("[QueueManager] The queue '#{name}' is full, max amount of space (#{@queue_constraints[name][:max_size]}) is exceeded", caller)
-      end
-      
-      # check max messages constraints
-      if @queue_constraints[name][:max_messages] != INFINITE &&
-        @queue_constraints[name][:max_messages] < queue[name].size + 1
-        raise QueueManagerException.new("[QueueManager] The queue '#{name}' is full, max amount of messages (#{@queue_constraints[name][:max_messages]}) is exceeded", caller)
-      end
    
-      @log.debug("[QueueManager] put message to queue '#{name}' with #{@queue[name].size} messages")
-      if @queue[name].respond_to? :put
-        @queue[name].put(message)
+      @log.debug("[QueueManager] put message to queue '#{name}' with #{queue(name).size} messages")
+      if queue(name).respond_to? :put
+        queue(name).put(message)
       else
         raise QueueManagerException.new("[QueueManager] You can't put to queue '#{name}'", caller)
       end
@@ -174,22 +144,12 @@ module FreeMessageQueue
 
     # Returns the names (paths) of all queues managed by this queue manager
     def queues
-      @queue.keys
-    end
-   
-    # Returns the size (number of messages)
-    def queue_size(name)
-      @queue[name].size
-    end
-    
-    # Returns the byte size of the queue
-    def queue_bytes(name)
-      @queue[name].bytes
+      @queues.keys
     end
     
     # Is the name (path) of the queue in use allready
     def queue_exists?(name)
-      !queue[name].nil?
+      !queue(name).nil?
     end
     
     # setup a this queue manager block need to be passed
@@ -197,63 +157,23 @@ module FreeMessageQueue
       config.call(self)
     end
     
-  private
-  
-    # create a queue from a configuration hash.
-    # The <em>queue_config</em> contains the following parameter:
-    # * path: the path to the queue (with leading "/" and 3 characters at minimum) e.g. "/test_queue"
-    # * [optional] max_size: the maximum size e.g. "10mb", "100kb", "2gb" or (black or -1) for infinite
-    # * [optional] max_messages: the maximim messages that can be in the queue e.g. 1500 or (black or -1) for infinite
-    # All other parameter will be send to the queue directly using a naming convention. So if you have the extra parameter
-    #  expire_date = "1h"
-    # the QueueManager will set the expire date using this assignment 
-    #  queue.expire_date = "1h"
-    # therefore your queue must implement this method
-    #  def expire_date=(time)
-    #    @expires_after = parse_seconds(time)
-    #  end
-    def create_queue_from_config(queue_class, queue_config)
-      # path need to be specified
-      raise QueueManagerException.new("[QueueManager] There is now path specified for queue", caller) if queue_config[:path].nil?
-      path = queue_config[:path]
-      queue_config.delete :path
-      
-      @log.debug("[QueueManager] setup queue from config '#{path}'")
-
-      # set max size parameter -- this parameter is optional
-      max_size = str_bytes(queue_config[:max_size])
-      max_size = INFINITE if max_size.nil? || max_size <= 0
-      queue_config.delete :max_size
-
-      # set max messages parameter -- this parameter is optional
-      max_messages = queue_config[:max_messages].to_i
-      max_messages = INFINITE if max_messages.nil? || max_messages <= 0
-      queue_config.delete :max_messages
-
-      queue = create_queue(path, max_messages, max_size, queue_class)
-
-      if queue_config.size > 0
-        @log.debug("[QueueManager] Configure addional parameters for queue '#{path}'; parameter: #{queue_config.inspect}")
-        for method_name in queue_config.keys
-          queue.send(method_name.to_s + "=", queue_config[method_name])
-        end
-      end
+    def queue(name)
+      return @queues[name]
     end
-  
-    # Retuns count of bytes to a expression with kb, mb or gb
-    # e.g 10kb will return 10240
-    def str_bytes(str)
-      case str
-        when /([0-9]+)kb/i
-          bs = $1.to_i * 1024 
-        when /([0-9]+)mb/i
-          bs = $1.to_i * 1024 * 1024 
-        when /([0-9]+)gb/i
-          bs = $1.to_i * 1024 * 1024 * 1024
-        else
-          bs = INFINITE
-      end
-      bs
+    
+  private  
+    
+    # Create a queue (<em>name</em> => <em>path</em>). The path must contain a leading "/" and a 3 character name
+    # at minimum. Exceptions will be raised if the queue allready exists.
+    def check_queue_name(name)
+      # path must begin with /
+      raise QueueManagerException.new("[QueueManager] Leading / in path '#{name}' missing", caller) if name[0..0] != "/"
+      
+      # path must have a minimus lenght of 3 character
+      raise QueueManagerException.new("[QueueManager] The queue path '#{name}' is to short 3 character is minimum", caller) if name.size - 1 < 3
+      
+      # don't create a queue twice
+      raise QueueManagerException.new("[QueueManager] The queue '#{name}' allready exists", caller) if queue_exists? name
     end
   end
 end

data/lib/fmq/queues/README.txt

@@ -20,8 +20,8 @@ First of all, this template is where you start.
     end
   
     def poll
-      msg = FreeMessageQueue::Message.new "Hello World", "text/plain"
-      msg.option["Time"] = Time.now
-      msg
+      FreeMessageQueue::Message.new "Hello World", "text/plain" do |m|
+    	m.option["Time"] = Time.now
+  	  end
     end
   end

data/lib/fmq/queues/base.rb

@@ -31,26 +31,53 @@ module FreeMessageQueue
       @created_at = created_at
       @content_type = content_type
       @option = {}
+      if block_given? then
+        yield self
+      end
     end
     
-    # Aize of item in bytes
+    # Size of item in bytes
     def bytes
       @payload.size
     end
   end
   
+  # All queue exceptions are raised using this class
+  class QueueException < Exception
+    attr_accessor :message, :backtrace
+  
+    # Create exception with message and backtrace (if needed)
+    def initialize(message, callstack = [])
+      @message = message
+      @backtrace = callstack
+    end
+    
+    # Returns the message of the exception
+    def to_s
+      @message
+    end
+  end
+  
   # every queue has to have this interface
   class BaseQueue
     # QueueManager refrence
     attr_accessor :manager
+    
+    # This value is used to decribe that a constraint has no limit e.g.
+    #   max_messages = INFINITE
+    # means that there is no limitation for messages (by count)
+    INFINITE = -1
   
     attr_reader :bytes, # the amount of space that is used by all messages in the queue
-      :size # the size / depp of the queue = count of messages
+      :size, # the size / depp of the queue = count of messages
+      :max_messages, # the max count of messages that can be in the queue
+      :max_size # the max size (bytes) of messages that can be in the queue
     
     def initialize(manager)
       @manager = manager
       @bytes = 0
       @size = 0
+      @max_size = @max_messages = INFINITE
     end
     
     # returns true if there is no message in the queue
@@ -58,18 +85,55 @@ module FreeMessageQueue
       size == 0
     end
     
+    # check that one can only set valid constraints
+    def max_messages=(val)
+      @max_messages = (val <= 0) ? BaseQueue::INFINITE : val
+    end
+    
+    # check that one can only set valid constraints
+    def max_size=(val)
+      @max_size = (val <= 0) ? BaseQueue::INFINITE : val
+    end
+    
   protected
   
-    # update queue size and memory usage (add one messge)
-    def add_message(bytes)
+    # update queue size and memory usage (add one message)
+    def add_message(message)
+      check_constraints_with_new(message)
+      
       @size += 1
-      @bytes += bytes
+      @bytes += message.bytes
+      return message
     end
     
-    # update queue size and memory usage (remove one messge)
-    def remove_message(bytes)
+    # update queue size and memory usage (remove one message)
+    def remove_message(message)
       @size -= 1
-      @bytes -= bytes
+      @bytes -= message.bytes
+      return message
+    end
+    
+    # check all constraints that are available.
+    # throws an exception if a constraint failed
+    def check_constraints_with_new(message)
+      check_max_size_constraint(message)
+      check_max_messages_constraint(message)
+    end
+    
+    # check if max size of messages will exceed with new message.
+    # throws an exception if a constraint failed
+    def check_max_size_constraint(message)
+      if @max_size != INFINITE && (@max_size < self.bytes + message.bytes)
+        raise QueueException.new("[Queue] The queue is full, max amount of space (#{@max_size} bytes) is exceeded", caller)
+      end
+    end
+    
+    # check if max count of messages will exceed with new message.
+    # throws an exception if a constraint failed
+    def check_max_messages_constraint(message)
+      if @max_messages != INFINITE && (@max_messages < self.size + 1)
+        raise QueueException.new("[Queue] The queue is full, max amount of messages (#{@max_messages}) is exceeded", caller)
+      end
     end
   end
 end

data/lib/fmq/queues/linked.rb

@@ -37,6 +37,8 @@ module FreeMessageQueue
     def put(message)
       return false if message == nil
       
+      add_message(message) # update stats and check constraints
+      
       # insert at end of list
       if @first_message == nil
         # first and last item are same if there is no item to the queue
@@ -46,7 +48,7 @@ module FreeMessageQueue
         @last_message = @last_message.next = message
       end
       
-      add_message(message.bytes) # update stats
+      return true
     end
  
     # Return an message from the queue or nil if the queue is empty
@@ -59,9 +61,7 @@ module FreeMessageQueue
         @first_message = message.next
         @last_message = nil if @first_message.nil?
         message.next = nil # unlink the message
-        remove_message(message.bytes) # update stats
-        
-        return message
+        remove_message(message) # update stats
       else
         return nil
       end

data/lib/fmq/queues/load_balanced.rb

@@ -75,6 +75,16 @@ module FreeMessageQueue
       @queues[next_put_index].put(data)
     end
     
+    # queue has infinite count
+    def max_messages
+      BaseQueue::INFINITE
+    end 
+    
+    # queue has infinite messages
+    def max_size
+      BaseQueue::INFINITE
+    end
+    
   private
     
     # next index acts like 'round robin'

data/lib/fmq/server.rb

@@ -34,11 +34,11 @@ module FreeMessageQueue
     end
   
     # Process incoming request and send them to the right sub processing method like <em>process_get</em>
-    def call(env)
+    def call(env)
       request = Rack::Request.new(env)
       queue_path = request.env["REQUEST_PATH"]
       @log.debug("[Server] Request params: #{YAML.dump(request.params)})")
-      
+      
       response = nil
       begin
         # process supported features
@@ -50,9 +50,9 @@ module FreeMessageQueue
         end
       rescue QueueManagerException => ex
         response = client_exception(request, queue_path, ex)
-      end
+      end
       
-      response.header["SERVER"] = SERVER_HEADER
+      response.header["SERVER"] = SERVER_HEADER
       return response.finish
     end
   
@@ -61,15 +61,15 @@ module FreeMessageQueue
     # Returns an item from queue and sends it to the client.
     # If there is no item to fetch send an 204 (NoContent) and same as HEAD
     def process_get(request, queue_path)
-      message = @queue_manager.poll(queue_path)
+      message = @queue_manager.poll(queue_path)
             
       unless message.nil? then
-        response = Rack::Response.new([], 200)
+        response = Rack::Response.new([], 200)
         
         @log.debug("[Server] Response to GET (200)")
         response.header["CONTENT-TYPE"] = message.content_type
-        response.header["QUEUE_SIZE"] = @queue_manager.queue_size(queue_path).to_s
-        response.header["QUEUE_BYTES"] = @queue_manager.queue_bytes(queue_path).to_s
+        response.header["QUEUE_SIZE"] = @queue_manager.queue(queue_path).size.to_s
+        response.header["QUEUE_BYTES"] = @queue_manager.queue(queue_path).bytes.to_s
         
         # send all options of the message back to the client
         if message.respond_to?(:option) && message.option.size > 0
@@ -86,13 +86,13 @@ module FreeMessageQueue
         response = Rack::Response.new([], 204)
         @log.debug("[Server] Response to GET (204)")
         response.header["QUEUE_SIZE"] = response["QUEUE_BYTES"] = 0.to_s
-      end
+      end
       return response
     end
     
     # Put new item to the queue and and return sam e as head action (HTTP 200)
     def process_post(request, queue_path)
-      @log.debug("[Server] Response to POST (200)")
+      @log.debug("[Server] Response to POST (200)")
       post_body = request.body.read
       message = Message.new(post_body, request.content_type)
       @log.debug("[Server] Message payload: #{post_body}")
@@ -107,8 +107,8 @@ module FreeMessageQueue
       @queue_manager.put(queue_path, message)
       
       response = Rack::Response.new([], 200)
-      response.header["QUEUE_SIZE"] = @queue_manager.queue_size(queue_path).to_s
-      response.header["QUEUE_BYTES"] = @queue_manager.queue_bytes(queue_path).to_s
+      response.header["QUEUE_SIZE"] = @queue_manager.queue(queue_path).size.to_s
+      response.header["QUEUE_BYTES"] = @queue_manager.queue(queue_path).bytes.to_s
       return response
     end
     
@@ -117,8 +117,8 @@ module FreeMessageQueue
       @log.debug("[Server] Response to HEAD (200)")
       
       response = Rack::Response.new([], 200)
-      response.header["QUEUE_SIZE"] = @queue_manager.queue_size(queue_path).to_s
-      response.header["QUEUE_BYTES"] = @queue_manager.queue_bytes(queue_path).to_s
+      response.header["QUEUE_SIZE"] = @queue_manager.queue(queue_path).size.to_s
+      response.header["QUEUE_BYTES"] = @queue_manager.queue(queue_path).bytes.to_s
       return response
     end
     
@@ -134,11 +134,11 @@ module FreeMessageQueue
     # HTTP-Header field Error contains information about the problem.
     # The client errorwill also be reported to warn level of logger.
     def client_exception(request, queue_path, ex)
-      @log.warn("[Server] Client error: #{ex}")
+      @log.warn("[Server] Client error: #{ex}")
       
       response = Rack::Response.new([], 400)
-      response.header["ERROR"] = ex.message
+      response.header["ERROR"] = ex.message
       return response
     end
   end
-end
+end

data/lib/fmq/version.rb

@@ -20,7 +20,7 @@ module FreeMessageQueue
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 3
-    TINY  = 0
+    TINY  = 1
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/test/test_basic.rb

@@ -26,11 +26,61 @@ class TestMessage < Test::Unit::TestCase
 end
 
 class BaseQueue < Test::Unit::TestCase
-  def test_initialize
-    manager = "pseudo manager"
-    queue = FreeMessageQueue::BaseQueue.new(manager)
-    assert_equal 0, queue.size
-    assert_equal 0, queue.bytes
-    assert_equal manager, queue.manager
+  def setup
+    @manager = FreeMessageQueue::QueueManager.new()
+    
+    @manager.setup do |m|
+      @queue1 = m.setup_queue "/dummy1"
+      @queue2 = m.setup_queue "/dummy2" do |q|
+        q.max_messages = 100
+        q.max_size = 100.kb
+      end
+      @queue3 = m.setup_queue "/dummy3" do |q|
+        q.max_size = 0
+        q.max_messages = -10
+      end
+    end
+  end
+  
+  def test_creating
+    # check first queue
+    assert_equal 0, @queue1.size
+    assert_equal 0, @queue1.bytes
+    assert_equal FreeMessageQueue::BaseQueue::INFINITE, @queue1.max_messages
+    assert_equal FreeMessageQueue::BaseQueue::INFINITE, @queue1.max_size
+    
+    # check 2. queue
+    assert_equal 0, @queue2.size
+    assert_equal 0, @queue2.bytes
+    assert_equal 100, @queue2.max_messages
+    assert_equal 100 * 1024, @queue2.max_size
+    
+    # check 3. queue
+    assert_equal 0, @queue3.size
+    assert_equal 0, @queue3.bytes
+    assert_equal FreeMessageQueue::BaseQueue::INFINITE, @queue3.max_messages
+    assert_equal FreeMessageQueue::BaseQueue::INFINITE, @queue3.max_size
+    
+    assert_equal @manager, @queue1.manager
+  end
+  
+  def test_constraint_max_messages
+    100.times do |v|
+      @queue2.put(new_msg("test"))
+    end
+    
+    assert_raise(FreeMessageQueue::QueueException) do
+      @queue2.put(new_msg("test"))
+    end
+  end
+  
+  def test_constraint_max_size
+    11.times do |v|
+      @queue2.put(new_msg("X" * 9.kb))
+    end
+    
+    assert_raise(FreeMessageQueue::QueueException) do
+      @queue2.put(new_msg("X" * 10.kb))
+    end
   end
 end

data/test/test_queue_manager.rb

@@ -12,54 +12,58 @@ class TestQueueManager < Test::Unit::TestCase
     @queue_manager.setup do |qm|
       qm.auto_create_queues = false
       
-      qm.setup_queue do |q|
-        q.path = DEFAULT_QUEUE_NAME
+      qm.setup_queue DEFAULT_QUEUE_NAME do |q|
         q.max_messages = 100
-        q.max_size = "100mb"
+        q.max_size = 100.mb
       end
+      
+      qm.setup_queue "/second_test_queue"
+      qm.setup_queue "/third_test_queue"
     end
   end
   
   def test_config
-    # check constraints
-    constraints = { :max_messages => 100, :max_size => 104857600 }
-    assert_equal constraints, @queue_manager.queue_constraints[DEFAULT_QUEUE_NAME]
-    
     # check that the simple config will work
     FreeMessageQueue::QueueManager.new()
     @queue_manager.setup do |qm|
       qm.auto_create_queues = false
     end
+    
+    # check if all queues are available
+    assert_equal 3, @queue_manager.queues.size
+    [DEFAULT_QUEUE_NAME, "/second_test_queue", "/third_test_queue"].each do |e|
+      assert @queue_manager.queues.include? e
+    end
   end
   
   def test_poll_and_get
     10.times do
       @queue_manager.put(DEFAULT_QUEUE_NAME, new_msg("XXX" * 20))
     end
-    assert_equal 10, @queue_manager.queue_size(DEFAULT_QUEUE_NAME)
+    assert_equal 10, @queue_manager.queue(DEFAULT_QUEUE_NAME).size
     i = 0
     while message = @queue_manager.poll(DEFAULT_QUEUE_NAME)
       i += 1
     end
     assert_equal 10, i
-    assert_equal 0, @queue_manager.queue_size(DEFAULT_QUEUE_NAME)
+    assert_equal 0, @queue_manager.queue(DEFAULT_QUEUE_NAME).size
     
     # should raise a exception because of the maximum messages limitation
     i = 0
-    assert_raise(FreeMessageQueue::QueueManagerException) {
+    assert_raise(FreeMessageQueue::QueueException) {
       101.times do
         @queue_manager.put(DEFAULT_QUEUE_NAME, new_msg("XXX" * 20))
           i += 1
       end
     }
-    @queue_manager.queue[DEFAULT_QUEUE_NAME].clear
-    assert_equal 0, @queue_manager.queue_size(DEFAULT_QUEUE_NAME)
+    @queue_manager.queue(DEFAULT_QUEUE_NAME).clear
+    assert_equal 0, @queue_manager.queue(DEFAULT_QUEUE_NAME).size
     assert i = 100
     
     # should raise a exception because of the maximum byte size limitation
     i = 0
     two_mb_message = new_msg("X" * 1024 * 1024 * 2)
-    assert_raise(FreeMessageQueue::QueueManagerException) {
+    assert_raise(FreeMessageQueue::QueueException) {
       101.times do
         @queue_manager.put(DEFAULT_QUEUE_NAME, two_mb_message) 
         i += 1
@@ -70,7 +74,7 @@ class TestQueueManager < Test::Unit::TestCase
   
   def test_creating_and_deleting
     url = "/XX123"
-    @queue_manager.create_queue(url)
+    @queue_manager.setup_queue url
     @queue_manager.put(url, new_msg("X_X_X_X_X_X"))
     assert_equal "X_X_X_X_X_X", @queue_manager.poll(url).payload
     @queue_manager.delete_queue(url)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: fmq
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors: 
 - Vincent Landgraf
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-26 00:00:00 +02:00
+date: 2008-08-27 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency