fmq 0.2.0 → 0.3.0

data/lib/fmq/admin.rb

@@ -0,0 +1,96 @@
+#
+# 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/>.
+#
+begin
+  require "rack"
+rescue LoadError
+  require "rubygems"
+  require "rack"
+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"
+          # ======= 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
+            @log.info "[AdminInterface] delete 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
+    end
+    
+  private
+  
+    # converts the data of one queue to json format
+    def queue_to_json(queue_name)
+      constraints = @manager.queue_constraints[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],
+      ]
+    end
+  end
+end
+

data/lib/fmq/boot.rb

@@ -16,13 +16,10 @@
 # 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 'yaml' 
 require 'logger'
-require 'fileutils'
 
 require File.dirname(__FILE__) + '/version'
 require File.dirname(__FILE__) + '/queue_manager'
-require File.dirname(__FILE__) + '/mongrel_server'
 
 module FreeMessageQueue
   # This is the standard server header that will be used by mongel and other web servers
@@ -32,7 +29,7 @@ module FreeMessageQueue
   # free message queue, so that it is simple to access
   # the logger from somewhere in the project 
   def self.logger
-    $FMQ_GLOBAL_LOGGER
+    $FMQ_GLOBAL_LOGGER ||= create_logger
   end
   
   # This method creates the logger instance once (even if it is called twice).
@@ -48,7 +45,7 @@ module FreeMessageQueue
   # * WARN  => Client side errors
   # * INFO  => Setup information (config stuff etc.)
   # * DEBUG => All operations of the queue manager and others
-  def self.set_log_level(level)
+  def self.log_level(level)
     case level
       when /fatal/i
         FreeMessageQueue.logger.level = Logger::FATAL
@@ -64,61 +61,9 @@ module FreeMessageQueue
     FreeMessageQueue.logger.debug "[Logger] set log level to #{level}"
   end
   
-  # The class implements a simple interface to the configuration file
-  # and creates and setup the logger instance
-  class Configuration
-    # the yaml config file from <em>file_path</em> will be read and 
-    # parsed. After parsing the global free message queue logger is
-    # created and setup vor further use
-    def initialize(file_path)
-      # open and read file
-      f = open(file_path, "r")
-      data = f.read
-      f.close
-      @config = YAML.load( data )
-      
-      # create logger and setup log level
-      @log = FreeMessageQueue.create_logger
-      FreeMessageQueue.set_log_level(server["log-level"])
-      
-      # debug the configuration
-      @log.debug("[Configuration] Server: " + YAML.dump(server))
-      @log.debug("[Configuration] QueueManager: " + YAML.dump(queue_manager))
-    end
-    
-    # the configuration for the server (MongrelHandler, ...)
-    def server
-      @config["server"]
-    end
-    
-    # the configuration for the queue manager
-    def queue_manager
-      @config["queue-manager"]
-    end
-  end
-  
   # Boot deals with the tasks to create up a project and start the server etc.
-  class Boot
-    # The configuration file <em>config.yml</em> must be in the same directory.
-    # It is the starting point for booting the server.
-    # After reading the configuration the QueueManager and HttpServer (MongrelHandler)
-    # will be created and start listening.
-    # This method will stop when the server goes down otherwise it will run infinitely
-    def self.start_server
-      conf = FreeMessageQueue::Configuration.new("config.yml")
-      logger = FreeMessageQueue.logger
-      
-      # create queue manager
-      queue_manager = FreeMessageQueue::QueueManager.new(conf.queue_manager)
-      
-      # setup and run server
-      logger.debug "[MongrelHandler] startup at #{conf.server["interface"]}:#{conf.server["port"]}"
-      servsock = Mongrel::HttpServer.new(conf.server["interface"], conf.server["port"])
-      servsock.register("/", FreeMessageQueue::MongrelHandler.new(queue_manager))
-      servsock.run.join
-    end
-    
-    # This message will copy the <em>default-server</em> project files
+  class Boot    
+    # This method will copy the <em>default-server</em> project files
     # to the passed (<em>project_name</em>) location.
     # The <em>default-server</em> contains some basic and sample stuff
     # so that the free message queue can be used as fast as possible. Including:
@@ -126,7 +71,8 @@ module FreeMessageQueue
     # * The default configuration => with some sample queues
     # * A custom queue implementation => to basically show how to create my own queues
     def self.create_project(project_name)
+      require 'fileutils'
       FileUtils.cp_r(File.dirname(__FILE__) + '/../../default-server', project_name)
     end
   end
-end
+end

data/lib/fmq/queue_manager.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 "ostruct"
+
 module FreeMessageQueue
   # All queue manager exceptions are raised using this class
   class QueueManagerException < Exception
@@ -40,6 +42,9 @@ module FreeMessageQueue
   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:
     #  {
@@ -59,18 +64,17 @@ module FreeMessageQueue
   
     # setup the queue manager using the configuration from the configuration
     # file (which is basically a hash)
-    def initialize(config)
+    def initialize()
       @queue = {}
-      @config = config
       @queue_constraints = {}
       @log = FreeMessageQueue.logger
-      setup_queue_manager()
+      @auto_create_queues = true
     end
     
     # returns if the creation of queues should be done on demand
     # (if someone sends a post to a queue)
     def auto_create_queues?
-      @config["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
@@ -95,6 +99,14 @@ module FreeMessageQueue
       
       @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)
+    end
    
     # Delete the queue by name (path)
     def delete_queue(name)
@@ -132,7 +144,7 @@ module FreeMessageQueue
       unless @queue[name]
         # only auto create queues if it is configured
         if auto_create_queues?
-            create_queue(name) 
+          create_queue(name) 
         else
           raise QueueManagerException.new("[QueueManager] There is no queue '#{name}'", caller)
         end
@@ -180,61 +192,54 @@ module FreeMessageQueue
       !queue[name].nil?
     end
     
+    # setup a this queue manager block need to be passed
+    def setup(&config)
+      config.call(self)
+    end
+    
+  private
+  
     # create a queue from a configuration hash.
-    # The <em>queue_name</em> is just for debugging and organizing the queue.
     # 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
-    # * [optional] class: the class that implements this queue e.g. FreeMessageQueue::SystemQueue
+    # * [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
+    #  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_name, queue_config)
-      @log.debug("[QueueManager] setup queue from config '#{queue_name}'")
-
+    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 '#{queue_name}'", caller) if queue_config["path"].nil?
-      path = queue_config["path"]
-      queue_config.delete "path"
+      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 = str_bytes(queue_config[:max_size])
       max_size = INFINITE if max_size.nil? || max_size <= 0
-      queue_config.delete "max-size"
+      queue_config.delete :max_size
 
       # set max messages parameter -- this parameter is optional
-      max_messages = queue_config["max-messages"].to_i
+      max_messages = queue_config[:max_messages].to_i
       max_messages = INFINITE if max_messages.nil? || max_messages <= 0
-      queue_config.delete "max-messages"
+      queue_config.delete :max_messages
 
-      # set class parameter -- this parameter is optional
-      default_class = queue_config["class"]
-      puts default_class
-      default_class = eval(default_class) unless default_class.nil?
-      queue_config.delete "class"
-
-      if default_class.nil?
-        queue = create_queue(path, max_messages, max_size)
-      else
-        queue = create_queue(path, max_messages, max_size, default_class)
-      end
+      queue = create_queue(path, max_messages, max_size, queue_class)
 
       if queue_config.size > 0
-        @log.debug("[QueueManager] Configure addional parameters for queue '#{queue_name}'; parameter: #{queue_config.inspect}")
-        for parameter in queue_config.keys
-          method_name = parameter.gsub("-", "_")
-          queue.send(method_name + "=", queue_config[parameter])
+        @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
     end
-    
-  private
+  
     # Retuns count of bytes to a expression with kb, mb or gb
     # e.g 10kb will return 10240
     def str_bytes(str)
@@ -250,17 +255,5 @@ module FreeMessageQueue
       end
       bs
     end
-    
-    # Create the queues that are defined in the configuration
-    def setup_queue_manager
-      if @config.nil?
-        raise QueueManagerException.new("[QueueManager] there is no queue manager configuration" , caller)
-      else
-        @log.info("[QueueManager] Create defined queues (#{@config["defined-queues"].size})")
-        for defined_queue in @config["defined-queues"]
-          create_queue_from_config(defined_queue[0], defined_queue[1])
-        end
-      end
-    end
   end
-end
+end

data/lib/fmq/queues/forward.rb

@@ -49,7 +49,7 @@ module FreeMessageQueue
     # you can add as may queues as you want
     # but seperate them with a space char
     def forward_to=(urls)
-      @forwards = urls.split " "
+      @forwards = urls
     end
   end
-end
+end

data/lib/fmq/server.rb

@@ -0,0 +1,144 @@
+#!/usr/bin/env ruby -wKU
+#
+# 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/>.
+#
+begin
+  require "rack"
+rescue LoadError
+  require "rubygems"
+  require "rack"
+end
+
+module FreeMessageQueue
+  # This implements server that plugs the free message queue into a rack enviroment
+  class Server
+    # When creating a server you have to pass the QueueManager
+    def initialize(queue_manager)
+      @queue_manager = queue_manager
+      @log = FreeMessageQueue.logger
+    end
+  
+    # Process incoming request and send them to the right sub processing method like <em>process_get</em>
+    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
+        if request.request_method.match(/^(GET|POST|HEAD|DELETE)$/) then
+          response = self.send("process_" + request.request_method.downcase, request, queue_path)
+        else
+          response = client_exception(request, queue_path, 
+            ArgumentError.new("[Server] Method is not supported '#{method}'"))
+        end
+      rescue QueueManagerException => ex
+        response = client_exception(request, queue_path, ex)
+      end
+      
+      response.header["SERVER"] = SERVER_HEADER
+      return response.finish
+    end
+  
+  protected
+  
+    # 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)
+            
+      unless message.nil? then
+        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
+        
+        # send all options of the message back to the client
+        if message.respond_to?(:option) && message.option.size > 0
+          for option_name in message.option.keys
+            response.header["MESSAGE_#{option_name.gsub("-", "_").upcase}"] = message.option[option_name].to_s
+          end
+        end
+        
+        if !message.payload.nil? && message.bytes > 0
+          @log.debug("[Server] Message payload: #{message.payload}")
+          response.write(message.payload)
+        end
+      else
+        response = Rack::Response.new([], 204)
+        @log.debug("[Server] Response to GET (204)")
+        response.header["QUEUE_SIZE"] = response["QUEUE_BYTES"] = 0.to_s
+      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)")
+      post_body = request.body.read
+      message = Message.new(post_body, request.content_type)
+      @log.debug("[Server] Message payload: #{post_body}")
+       
+      # send all options of the message back to the client
+      for option_name in request.env.keys
+        if option_name.match(/HTTP_MESSAGE_([a-zA-Z][a-zA-Z0-9_\-]*)/)
+          message.option[$1] = request.env[option_name]
+        end
+      end
+      
+      @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
+      return response
+    end
+    
+    # Just return server header and queue size (HTTP 200)
+    def process_head(request, queue_path)
+      @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
+      return response
+    end
+    
+    # Delete the queue and return server header (HTTP 200)
+    def process_delete(request, queue_path)
+      @log.debug("[Server] Response to DELETE (200)")
+      @queue_manager.delete_queue(queue_path)
+
+      response = Rack::Response.new([], 200)
+    end
+    
+    # Inform the client that he did something wrong (HTTP 400).
+    # 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}")
+      
+      response = Rack::Response.new([], 400)
+      response.header["ERROR"] = ex.message
+      return response
+    end
+  end
+end

data/lib/fmq/version.rb

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

data/lib/fmq.rb

@@ -22,12 +22,7 @@ Dir.glob(File.dirname(__FILE__) + "/fmq/queues/*.rb").each do |file|
   require file
 end
 
-# load all local queues (from project directory)
-Dir.glob("queues/*.rb").each do |file|
-  require file
-end
-
 # load all parts in right order
-['boot', 'client'].each do |file|
+['boot', 'admin', 'client', 'server'].each do |file|
   require File.dirname(__FILE__) + "/fmq/#{file}"
-end
+end

data/test/test_queue_manager.rb

@@ -5,20 +5,19 @@ class TestQueueManager < Test::Unit::TestCase
   DEFAULT_QUEUE_NAME = "/fmq_test/test1"
   
   def setup
-    FreeMessageQueue.create_logger
-    FreeMessageQueue.set_log_level "fatal"
+    FreeMessageQueue.log_level "fatal"
+
+    @queue_manager = FreeMessageQueue::QueueManager.new()
     
-    @working_conf = {
-      "auto-create-queues" => false,
-      "defined-queues" => {
-        "test-queue-1" => {
-          "path" => DEFAULT_QUEUE_NAME,
-          "max-messages" => 100,
-          "max-size" => "100mb"
-        }
-      }
-    }
-    @queue_manager = FreeMessageQueue::QueueManager.new(@working_conf)
+    @queue_manager.setup do |qm|
+      qm.auto_create_queues = false
+      
+      qm.setup_queue do |q|
+        q.path = DEFAULT_QUEUE_NAME
+        q.max_messages = 100
+        q.max_size = "100mb"
+      end
+    end
   end
   
   def test_config
@@ -26,17 +25,11 @@ class TestQueueManager < Test::Unit::TestCase
     constraints = { :max_messages => 100, :max_size => 104857600 }
     assert_equal constraints, @queue_manager.queue_constraints[DEFAULT_QUEUE_NAME]
     
-    # the queue manager can't be created without config
-    assert_raise(FreeMessageQueue::QueueManagerException) {
-      FreeMessageQueue::QueueManager.new(nil)
-    }
-    
     # check that the simple config will work
-    simple = {
-      "auto-create-queues" => true,
-      "defined-queues" => {}
-    }
-    FreeMessageQueue::QueueManager.new(simple)
+    FreeMessageQueue::QueueManager.new()
+    @queue_manager.setup do |qm|
+      qm.auto_create_queues = false
+    end
   end
   
   def test_poll_and_get

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: fmq
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Vincent Landgraf
@@ -9,10 +9,19 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-06-28 00:00:00 +02:00
+date: 2008-08-26 00:00:00 +02:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.4.0
+    version: 
 description: The project implements a queue system with a server and some client apis. This project wants to be a fast and lightweight implementation with most of the features of MQS or ActiveMQ.
 email: 
 - fmq-3z@gmx.net
@@ -36,16 +45,18 @@ files:
 - config/requirements.rb
 - default-server/admin-interface/images/logo.png
 - default-server/admin-interface/index.html
-- default-server/admin-interface/prototype.js
-- default-server/config.yml
+- default-server/admin-interface/javascript/prototype.js
+- default-server/admin-interface/javascript/application.js
+- default-server/admin-interface/stylesheets/application.css
+- default-server/config.ru
 - default-server/queues/my_test.rb
 - lib/fmq.rb
 - lib/fmq/boot.rb
 - lib/fmq/client.rb
-- lib/fmq/mongrel_server.rb
+- lib/fmq/admin.rb
+- lib/fmq/server.rb
 - lib/fmq/queue_manager.rb
 - lib/fmq/queues/README.txt
-- lib/fmq/queues/admin.rb
 - lib/fmq/queues/base.rb
 - lib/fmq/queues/file.rb
 - lib/fmq/queues/forward.rb