fmq 0.1.1 → 0.2.0

data/lib/fmq/queues/base.rb

@@ -0,0 +1,75 @@
+#
+# Copyright (c) 2008 Vincent Landgraf
+#
+# This file is part of the Free Message Queue.
+# 
+# Free Message Queue is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# Free Message Queue is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with Free Message Queue.  If not, see <http://www.gnu.org/licenses/>.
+#
+module FreeMessageQueue
+  # This is the default message implementation in the queue system
+  class Message
+    attr_accessor :next, # reference to next Message if there is one
+      :payload, # the content itself
+      :created_at, # when came the message into the system
+      :content_type, # the content type of the message
+      :option # options hash (META-DATA) for the message
+    
+    # Create a message item. The payload is often just a string
+    def initialize(payload, content_type = "text/plain", created_at = Time.new)
+      @payload = payload
+      @created_at = created_at
+      @content_type = content_type
+      @option = {}
+    end
+    
+    # Aize of item in bytes
+    def bytes
+      @payload.size
+    end
+  end
+  
+  # every queue has to have this interface
+  class BaseQueue
+    # QueueManager refrence
+    attr_accessor :manager
+  
+    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
+    
+    def initialize(manager)
+      @manager = manager
+      @bytes = 0
+      @size = 0
+    end
+    
+    # returns true if there is no message in the queue
+    def empty?
+      size == 0
+    end
+    
+  protected
+  
+    # update queue size and memory usage (add one messge)
+    def add_message(bytes)
+      @size += 1
+      @bytes += bytes
+    end
+    
+    # update queue size and memory usage (remove one messge)
+    def remove_message(bytes)
+      @size -= 1
+      @bytes -= bytes
+    end
+  end
+end

data/lib/fmq/queues/file.rb

@@ -16,6 +16,8 @@
 # You should have received a copy of the GNU General Public License
 # along with Free Message Queue.  If not, see <http://www.gnu.org/licenses/>.
 #
+require File.dirname(__FILE__) + '/base'
+
 module FreeMessageQueue
   # This queue returns everytime the same file. This is useful during debugging or
   # to serve the admin page.
@@ -31,30 +33,15 @@ module FreeMessageQueue
   #      content-type: text/html
   #
   # *NOTE* the put method is not implemented in this queue. It is a poll only queue.
-  class FileQueue
-    # QueueManager refrence
-    attr_accessor :manager
-    
-    # Bytes are -1 at startup but fill after first poll. Size is allways 1 message
-    attr_reader :bytes, :size
-    
-    def initialize
-      # there is always one message (the file) in the queue
-      @bytes = -1
-      @size = 1
-    end
-
+  class FileQueue < BaseQueue
     # Return the file and content type
     def poll()
-      item = OpenStruct.new
-
       f = open(@file_path, "rb")
-      item.data = f.read
-      @bytes = item.data.size
+      file_content = f.read
       f.close
       
-      item.content_type = @content_type
-      item
+      @bytes = file_content.size
+      Message.new(file_content, @content_type)
     end
     
     # *CONFIGURATION* *OPTION*

data/lib/fmq/queues/forward.rb

@@ -16,7 +16,7 @@
 # You should have received a copy of the GNU General Public License
 # along with Free Message Queue.  If not, see <http://www.gnu.org/licenses/>.
 #
-require "ostruct"
+require File.dirname(__FILE__) + '/base'
 
 module FreeMessageQueue
   # This queue returns sends one message to several queues at a time.
@@ -30,23 +30,18 @@ module FreeMessageQueue
   #      forward_to: /fmq_test/test1 /fmq_test/test2
   #
   # *NOTE* the poll method is not implemented in this queue. It is a put only queue.
-  class ForwardQueue
-    # QueueManager refrence
-    attr_accessor :manager
+  class ForwardQueue < BaseQueue
     
-    # Bytes and size are allways 0 because this queue holds no data
-    attr_reader :bytes, :size
-    
-    def initialize
-      @bytes = @size = 0
+    def initialize(manager)
+      super(manager)
       @forwards = []
     end
     
-    # put the data from this queue to the queues
+    # put the message from this queue to the queues
     # that are specified in the <em>forward-to</em> configuration option.
-    def put(data)
+    def put(message)
       for forward in @forwards do
-        @manager.put(forward, data)
+        @manager.put(forward, message.clone)
       end
     end
     

data/lib/fmq/queues/linked.rb

@@ -16,83 +16,52 @@
 # You should have received a copy of the GNU General Public License
 # along with Free Message Queue.  If not, see <http://www.gnu.org/licenses/>.
 #
+require File.dirname(__FILE__) + '/base'
+
 module FreeMessageQueue
-  # Simple queue item class is used, because it is 
-  # considered to be faster than ostruct
-  class QueueItem
-    attr_accessor :next, :data, :created_at
- 
-    # Create queue item
-    def initialize(data, created_at = Time.new)
-      @data = data
-      @created_at = created_at
-    end
- 
-    # Aize of item in bytes
-    def bytes
-      @data.size
-    end
-  end
- 
   # *DO* *NOT* *USE* *THIS* *QUEUE* *DIRECTLY* *IN* *THE* *QUEUE* *MANAGER*
   # it is not thread safe.
   # This Queue implements a FIFO based store in system memory.
-  class LinkedQueue
-    attr_reader :size, :bytes
- 
-    def initialize()
-      @size = 0
-      @first_item = nil
-      @last_item = nil
-      @bytes = 0
+  class LinkedQueue < BaseQueue
+    def initialize(manager)
+      super(manager)
+      @last_message = @first_message = nil
     end
  
     # Remove all items from the queue
     def clear 
-      if size > 0
-        while self.poll; end
-      end
+      while self.poll; end
     end
   
     # Put an item to the queue
-    def put(data)
-      return false if data == nil
- 
-      # create item
-      qi = QueueItem.new(data)
- 
+    def put(message)
+      return false if message == nil
+      
       # insert at end of list
-      if @first_item == nil
-        @first_item = @last_item = qi
+      if @first_message == nil
+        # first and last item are same if there is no item to the queue
+        @first_message = @last_message = message
       else
-        @last_item.next = qi
+        # append the message to the end of the queue
+        @last_message = @last_message.next = message
       end
-      @last_item = qi
- 
-      # update queue size and memory usage
-      @size += 1
-      @bytes += qi.bytes
-      true
+      
+      add_message(message.bytes) # update stats
     end
  
-    # Return an item from the queue
+    # Return an message from the queue or nil if the queue is empty
     def poll()
-      if @size > 0
+      unless empty?
         # remove allways the first item
-          qi = @first_item
- 
-        # cleanup list
-        if @first_item == @last_item # just 1 element is in the list
-          @first_item = @last_item = nil
-        else
-          @first_item = @first_item.next
-        end
-        qi.next = nil # remove link to next item
- 
-        # update queue size and memory usage
-        @size -= 1
-        @bytes -= qi.bytes
-        return qi
+        message = @first_message
+        
+        # took it off
+        @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
       else
         return nil
       end

data/lib/fmq/queues/load_balanced.rb

@@ -1,104 +1,105 @@
-#
-# Copyright (c) 2008 Vincent Landgraf
-#
-# This file is part of the Free Message Queue.
-# 
-# Free Message Queue is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-# 
-# Free Message Queue is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-# 
-# You should have received a copy of the GNU General Public License
-# along with Free Message Queue.  If not, see <http://www.gnu.org/licenses/>.
-#
-require File.dirname(__FILE__) + '/syncronized'
-
-module FreeMessageQueue
-  # This queue is an approach to the issue that you want to have
-  # multiple threads at one queue at a time. Currently this is not
-  # considered to be a stable queue. Just use it for experimental things.
-  #
-  # configuration sample:
-  #  queue-manager:
-  #    auto-create-queues: true
-  #    defined-queues:
-  #      test-queue-1:
-  #        path: /fmq_test/test1
-  #        max-messages: 1000000
-  #        max-size: 10kb
-  #        class: FreeMessageQueue::LoadBalancedQueue
-  class LoadBalancedQueue    
-    # QueueManager refrence
-    attr_accessor :manager
-    
-    def initialize(queue_count = 5)
-      @queues = []
-      queue_count.times do
-      @queues << SyncronizedQueue.new
-      end
-      @poll_queue = @put_queue = 0
-      @semaphore = Mutex.new
-    end
-    
-    # delete all messages in all queues
-    def clear
-      @queues.each { |q| q.clear }
-    end
-    
-    # size of the queue is sum of size of all load balanced queues
-    def size
-      size = 0
-      @queues.each { |q| size += q.size }
-      return size 
-    end
-    
-    # size of queue in bytes
-    def bytes
-      tmp_bytes = 0
-      @queues.each { |q| tmp_bytes += q.bytes }
-      return tmp_bytes
-    end
-    
-    # Return one message from one of the queues
-    def poll
-      @queues[next_poll_index].poll
-    end
-    
-    # Put an item to one of the queues
-    def put(data)
-      @queues[next_put_index].put(data)
-    end
-    
-  private
-    
-    # next index acts like 'round robin'
-    def next_poll_index
-      @semaphore.synchronize {
-        # continue at begin if end was reached
-          pq = (@poll_queue + 1 == @queues.size) ? 0 : @poll_queue + 1
-        
-        # if current queue is emtpy use other instead if there are
-        # some items left but try just 10 times
-        i = 0
-        while @queues[pq].size == 0 && self.size > 0 && i < 10
-          pq = (@poll_queue + 1 == @queues.size) ? 0 : @poll_queue + 1
-          i += 1
-        end
-        
-        @poll_queue = pq # return index and save for next use
-      }
-    end
-    
-    # next index acts like 'round robin'
-    def next_put_index
-      @semaphore.synchronize {
-        @put_queue = (@put_queue + 1 == @queues.size) ? 0 : @put_queue + 1
-      }
-    end
-  end
-end
+#
+# Copyright (c) 2008 Vincent Landgraf
+#
+# This file is part of the Free Message Queue.
+# 
+# Free Message Queue is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# Free Message Queue is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with Free Message Queue.  If not, see <http://www.gnu.org/licenses/>.
+#
+require File.dirname(__FILE__) + '/syncronized'
+
+module FreeMessageQueue
+  # This queue is an approach to the issue that you want to have
+  # multiple threads at one queue at a time. Currently this is not
+  # considered to be a stable queue. Just use it for experimental things.
+  #
+  # configuration sample:
+  #  queue-manager:
+  #    auto-create-queues: true
+  #    defined-queues:
+  #      test-queue-1:
+  #        path: /fmq_test/test1
+  #        max-messages: 1000000
+  #        max-size: 10kb
+  #        class: FreeMessageQueue::LoadBalancedQueue
+  class LoadBalancedQueue    
+    # QueueManager refrence
+    attr_accessor :manager
+    
+    def initialize(manager, queue_count = 5)
+      @manager = manager
+      @queues = []
+      queue_count.times do
+        @queues << SyncronizedQueue.new(manager)
+      end
+      @poll_queue = @put_queue = 0
+      @semaphore = Mutex.new
+    end
+    
+    # delete all messages in all queues
+    def clear
+      @queues.each { |q| q.clear }
+    end
+    
+    # size of the queue is sum of size of all load balanced queues
+    def size
+      size = 0
+      @queues.each { |q| size += q.size }
+      return size 
+    end
+    
+    # size of queue in bytes
+    def bytes
+      tmp_bytes = 0
+      @queues.each { |q| tmp_bytes += q.bytes }
+      return tmp_bytes
+    end
+    
+    # Return one message from one of the queues
+    def poll
+      @queues[next_poll_index].poll
+    end
+    
+    # Put an item to one of the queues
+    def put(data)
+      @queues[next_put_index].put(data)
+    end
+    
+  private
+    
+    # next index acts like 'round robin'
+    def next_poll_index
+      @semaphore.synchronize {
+        # continue at begin if end was reached
+          pq = (@poll_queue + 1 == @queues.size) ? 0 : @poll_queue + 1
+        
+        # if current queue is emtpy use other instead if there are
+        # some items left but try just 10 times
+        i = 0
+        while @queues[pq].size == 0 && self.size > 0 && i < 10
+          pq = (@poll_queue + 1 == @queues.size) ? 0 : @poll_queue + 1
+          i += 1
+        end
+        
+        @poll_queue = pq # return index and save for next use
+      }
+    end
+    
+    # next index acts like 'round robin'
+    def next_put_index
+      @semaphore.synchronize {
+        @put_queue = (@put_queue + 1 == @queues.size) ? 0 : @put_queue + 1
+      }
+    end
+  end
+end

data/lib/fmq/queues/syncronized.rb

@@ -1,56 +1,55 @@
-#
-# Copyright (c) 2008 Vincent Landgraf
-#
-# This file is part of the Free Message Queue.
-# 
-# Free Message Queue is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-# 
-# Free Message Queue is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-# 
-# You should have received a copy of the GNU General Public License
-# along with Free Message Queue.  If not, see <http://www.gnu.org/licenses/>.
-#
-require 'thread'
-require File.dirname(__FILE__) + '/linked'
-
-module FreeMessageQueue
-  # The SyncronizedQueue implements a little wrapper around the 
-  # LinkedQueue to make it thread safe
-  #
-  # configuration sample:
-  #  queue-manager:
-  #    auto-create-queues: true
-  #    defined-queues:
-  #      test-queue-1:
-  #        path: /fmq_test/test1
-  #        max-messages: 1000000
-  #        max-size: 10kb
-  class SyncronizedQueue < LinkedQueue
-    attr_accessor :manager
-  
-    def initialize()
-      super
-      @semaphore = Mutex.new
-    end
-    
-    # Returns one item from the queue
-    def poll()
-      @semaphore.synchronize {
-        super
-      }
-    end
-    
-    # Puts one item to the queue
-    def put(data)
-      @semaphore.synchronize {
-        super(data)
-      }
-    end
-  end
+#
+# Copyright (c) 2008 Vincent Landgraf
+#
+# This file is part of the Free Message Queue.
+# 
+# Free Message Queue is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# Free Message Queue is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with Free Message Queue.  If not, see <http://www.gnu.org/licenses/>.
+#
+require 'thread'
+require File.dirname(__FILE__) + '/linked'
+
+module FreeMessageQueue
+  # The SyncronizedQueue implements a little wrapper around the 
+  # LinkedQueue to make it thread safe
+  #
+  # configuration sample:
+  #  queue-manager:
+  #    auto-create-queues: true
+  #    defined-queues:
+  #      test-queue-1:
+  #        path: /fmq_test/test1
+  #        max-messages: 1000000
+  #        max-size: 10kb
+  class SyncronizedQueue < LinkedQueue
+    
+    def initialize(manager)
+      super(manager)
+      @semaphore = Mutex.new
+    end
+    
+    # Returns one item from the queue
+    def poll()
+      @semaphore.synchronize {
+        super
+      }
+    end
+    
+    # Puts one item to the queue
+    def put(data)
+      @semaphore.synchronize {
+        super(data)
+      }
+    end
+  end
 end

data/lib/fmq/version.rb

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

data/test/test_basic.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+# This is the default test to the message interface
+class TestMessage < Test::Unit::TestCase
+  def test_initialize
+    msg = FreeMessageQueue::Message.new("....", "text/xml")
+    msg.option['application'] = "fast_app"
+    msg.option['expires'] = msg.created_at + (5 * 60) # 5 min after creation
+    
+    assert_equal 4, msg.bytes
+    assert_equal 2, msg.option.size
+    assert_equal "text/xml", msg.content_type
+    assert_equal "fast_app", msg.option["application"]
+  end
+  
+  def test_linking_of_messages
+    msg_0 = FreeMessageQueue::Message.new("MyMac")
+    msg_1 = FreeMessageQueue::Message.new("MyDesk")
+    msg_2 = FreeMessageQueue::Message.new("MyRuby")
+    
+    msg_0.next = msg_1
+    msg_1.next = msg_2
+    
+    assert_equal msg_2, msg_0.next.next
+  end
+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
+  end
+end