sparrow 0.2

data/History.txt

@@ -0,0 +1,5 @@
+== 1.0.0 / 2008-01-23
+
+* 1 major enhancement
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,13 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/sparrow
+lib/sparrow.rb
+lib/sparrow/queue.rb
+lib/sparrow/queues/disk.rb
+lib/sparrow/queues/memory.rb
+lib/sparrow/queues/sqlite.rb
+lib/sparrow/runner.rb
+lib/sparrow/server.rb
+lib/sparrow/utils.rb

data/README.txt

@@ -0,0 +1,87 @@
+Sparrow
+    by Alex MacCaw
+    http://code.google.com/p/sparrow/
+
+== DESCRIPTION:
+
+  # Sparrow is a really fast lightweight queue written in Ruby that speaks memcached. 
+  # That means you can use Sparrow with any memcached client library (Ruby or otherwise). 
+  # 
+  # Basic tests shows that Sparrow processes messages at a rate of 850-900 per second. 
+  # The load Sparrow can cope with increases exponentially as you add to the cluster. 
+  # Sparrow also takes advantage of eventmachine, which uses a non-blocking io, offering great performance.
+  # 
+  # Sparrow comes with built in support for daemonization and clustering. 
+  # Also included are example libraries and clients. For example:
+  # 
+  # require 'memcache'
+  # m = MemCache.new('127.0.0.1:11212')
+  # m['queue_name'] = '1' # Publish to queue
+  # m['queue_name']       #=> 1 Pull next msg from queue
+  # m['queue_name']       #=> nil
+  # m.delete('queue_name) # Delete queue
+  # 
+  # # or using the included client:
+  # 
+  # class MyQueue < MQ3::Queue
+  #   def on_message
+  #     logger.info "Received msg with args: #{args.inspect}"
+  #   end
+  # end
+  # 
+  # MyQueue.servers = [
+  #   MQ3::Protocols::Memcache.new({:host => '127.0.0.1', :port => 11212, :weight => 1})
+  # ]
+  # MyQueue.publish('test msg')
+  # MyQueue.run
+  # 
+  # Messages are deleted as soon as they're read and the order you add messages to the queue probably won't 
+  # be the same order when they're removed.
+  # 
+  # Additional memcached commands that are supported are:
+  # flush_all # Deletes all queues
+  # version
+  # quit
+  # The memcached commands 'add', and 'replace' just call 'set'.
+  # 
+  # Call sparrow with --help for usage options
+  # 
+  # The daemonization won't work on Windows. 
+  # 
+  # Check out the code:
+  # svn checkout http://sparrow.googlecode.com/svn/trunk/ sparrow
+  # 
+  # Sparrow was inspired by Twitter's Starling
+
+== REQUIREMENTS:
+
+* eventmachine
+
+== INSTALL:
+
+* sudo gem install sparrow
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 FIX
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,18 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/sparrow.rb'
+
+Hoe.new('sparrow', Sparrow::VERSION) do |p|
+  p.rubyforge_name = 'Sparrow'
+  p.author = 'Alex MacCAw'
+  p.email = 'info@eribium.org'
+  p.summary = 'Simple file based messagine queue using the memcache protocol'
+  # p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  p.url = 'http://code.google.com/p/sparrow'
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  p.extra_deps << ['eventmachine', '>=0.10.0']
+end
+
+# vim: syntax=Ruby

data/bin/sparrow

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.join(File.dirname(__FILE__), '..', 'lib', 'sparrow')
+Sparrow::Runner.run

data/lib/sparrow.rb

@@ -0,0 +1,53 @@
+require 'logger'
+
+$:.unshift(File.dirname(__FILE__))
+require 'sparrow/utils'
+
+module Sparrow
+  
+  class SparrowError < StandardError #:nodoc:
+  end
+  
+  VERSION   = '0.2'
+  
+  @@options = {}
+  
+  class << self
+    def options
+      @@options
+    end
+  
+    def options=(val)
+      @@options = val
+    end
+  
+    def logger
+      return @@logger if defined?(@@loggger)
+      FileUtils.mkdir_p(File.dirname(log_path))
+      @@logger = Logger.new(log_path)
+      @@logger.level = Logger::INFO if options[:debug] == false
+      @@logger
+    rescue
+      @@logger = Logger.new(STDOUT)
+    end
+  
+    def base_dir
+      options[:base_dir] || File.join(%w( / var spool sparrow ))
+    end
+  
+    def log_path
+      options[:log_path] || File.join(%w( / var run sparrow.log ))
+    end
+  
+    def pid_path
+      options[:pid_path] || File.join(%w( / var run sparrow.#{options[:port]}.pid ))
+    end
+  end
+end
+
+require 'sparrow/server'
+require 'sparrow/queues/sqlite' rescue LoadError nil
+require 'sparrow/queues/memory'
+require 'sparrow/queues/disk'
+require 'sparrow/queue'
+require 'sparrow/runner'

data/lib/sparrow/queue.rb

@@ -0,0 +1,41 @@
+require 'fileutils'
+module Sparrow
+  class Queue
+    
+    cattr_accessor :queues
+    self.queues = {}
+    
+    class << self
+      def get_queue(queue_name)
+        @@queues[queue_name] ||= case Sparrow.options[:type]
+          when 'memory': Sparrow::Queues::Memory.new(queue_name)
+          when 'sqlite': Sparrow::Queues::Sqlite.new(queue_name)
+          else
+            Sparrow::Queues::Disk.new(queue_name)
+          end
+      end
+    
+      def next_message(queue_name)
+        self.get_queue(queue_name).pop
+      end
+    
+      def add_message(queue_name, value)
+        self.get_queue(queue_name).push(value)
+      end
+      
+      def delete(queue_name)
+        queue = self.get_queue(queue_name)
+        queue.clear
+        @@queues.delete(queue_name)
+        true        
+      end
+      
+      def delete_all
+        @@queues = {}
+        FileUtils.rm_rf base_dir
+        FileUtils.mkdir_p base_dir
+      end
+    end
+    
+  end
+end

data/lib/sparrow/queues/disk.rb

@@ -0,0 +1,105 @@
+require 'fileutils'
+module Sparrow
+  module Queues
+    class Disk
+      include Sparrow::Miscel
+      
+      TRX_CMD_PUSH = "\000".freeze
+      TRX_CMD_POP = "\001".freeze
+
+      TRX_PUSH = "\000%s%s".freeze
+      TRX_POP = "\001".freeze
+    
+      attr_accessor :queue_name
+      attr_accessor :trxr
+      attr_accessor :trxw
+      attr_accessor :count_all
+    
+      def initialize(queue_name)
+        self.queue_name = queue_name
+        self.count_all = 0
+        open_queue
+      end
+    
+      def push(value)
+        value = value.to_s
+        size = [value.size].pack("I")
+        data = sprintf(TRX_PUSH, size, value)
+        trxw.seek(0, IO::SEEK_END)
+        trxw.write data
+        trxw.fsync
+        rotate_queue if trxw.pos > max_log_size
+        self.count_all += 1
+        value
+      end
+    
+      def pop        
+        while !trxr.eof?
+          s_pos = trxr.pos
+          cmd = trxr.read(1)
+          if cmd != TRX_CMD_POP and cmd != TRX_CMD_PUSH
+            logger.fatal 'Corrupt queue'
+            return
+          end
+          raw_size = trxr.read(4)
+          size = raw_size.unpack("I").first
+          value = trxr.read(size)
+          next if cmd == TRX_CMD_POP
+          e_pos = trxr.pos
+          trxr.seek(s_pos, IO::SEEK_SET)
+          trxr.write(TRX_POP)
+          trxr.fsync
+          trxr.pos = e_pos
+          next unless value
+          return value
+        end
+        
+        if trxr.path == queue_path
+          File.truncate(trxr.path, 0)
+        else
+          FileUtils.rm_rf trxr.path
+        end
+        open_reader
+        nil
+      end
+      
+      def clear
+        dirs = Dir.glob(queue_path) | Dir.glob(queue_path + '.*')
+        FileUtils.rm_rf(dirs) unless dirs.empty?
+      end
+      
+      def count
+      end
+      
+      private
+      
+      def queue_path
+        File.join(base_dir, queue_name)
+      end
+      
+      def rotate_queue
+        File.rename(queue_path, File.join(base_dir, "#{queue_name}.#{Time.now.to_i}"))
+        open_writer
+      end
+      
+      def open_writer
+        self.trxw = File.open(queue_path, 'a+')
+      end
+      
+      def open_reader    
+        old_queue = Dir.glob(queue_path + '.*').first
+        self.trxr = File.open(old_queue||queue_path, 'r+')
+      end
+    
+      def open_queue
+        open_writer
+        open_reader
+      end
+      
+      def max_log_size
+        @max_log_size ||= (options[:log_size] || 16) * (1024**2) # 16mb
+      end
+
+    end
+  end
+end

data/lib/sparrow/queues/memory.rb

@@ -0,0 +1,35 @@
+module Sparrow
+  module Queues
+    class Memory
+      include Sparrow::Miscel
+      
+      attr_accessor :queue_name
+      attr_accessor :queue_data
+      attr_accessor :count_all
+      
+      def initialize(queue_name)
+        self.queue_name = queue_name
+        self.queue_data = []
+        self.count_all = 0
+      end
+      
+      def pop
+        queue_data.shift
+      end
+      
+      def push(value)
+        self.count_all += 1
+        queue_data.push(value)
+      end
+      
+      def clear
+        self.queue_data = []
+      end
+      
+      def count
+        queue_data.length
+      end
+         
+    end
+  end
+end

data/lib/sparrow/queues/sqlite.rb

@@ -0,0 +1,56 @@
+require 'sqlite3'
+module Sparrow
+  module Queues
+    class Sqlite
+      include Sparrow::Miscel
+    
+      attr_accessor :queue_name
+      attr_accessor :db
+      attr_accessor :count_all
+    
+      def initialize(queue_name)
+        self.queue_name = queue_name
+        self.count_all = 0
+        db_exists = File.exists?(db_path)
+        self.db = SQLite3::Database.new( db_path )
+        if !db_exists
+          self.db.execute_batch <<-SQL
+           CREATE TABLE queues (
+            id INTEGER PRIMARY KEY,
+            data VARCHAR(255)
+           );
+           PRAGMA default_synchronous=OFF;
+           PRAGMA count_changes=OFF;
+          SQL
+        end
+      end
+        
+      def push(value)
+        self.count_all += 1
+        db.execute("INSERT INTO queues (data) VALUES (?);", value)
+        value
+      end
+    
+      def pop
+        id, value = db.get_first_row("SELECT * FROM queues LIMIT 1;")
+        db.execute("DELETE FROM queues WHERE id = ?", id)
+        value
+      end
+    
+      def count
+        db.get_first_value("SELECT COUNT FROM queues")
+      end
+      
+      def clear
+        db.execute("DELETE FROM queues")
+      end
+      
+      private 
+      
+      def db_path
+        File.join(base_dir, queue_name)
+      end
+    
+    end
+  end
+end

data/lib/sparrow/runner.rb

@@ -0,0 +1,166 @@
+require 'optparse'
+require 'eventmachine'
+
+module Sparrow
+  class Runner
+    include Sparrow::Miscel
+    
+    class << self
+      def run
+        self.new
+      end
+    end
+    
+    def initialize
+      self.options = {
+        :host => "0.0.0.0",
+        :port => 11212,
+        :debug => false,
+        :base_dir => base_dir,
+        :pid_path => pid_path,
+        :log_path => log_path,
+        :type => 'disk'
+      }
+      
+      parse_options
+      
+      if options.include?(:kill)
+        kill_pid(options[:kill] || '*')
+      end
+      
+      if !options[:daemonize]
+        start
+      else
+        daemonize
+      end
+    end
+    
+    def start
+      puts "Starting Sparrow server on port: #{options[:port]}..."
+      
+      trap("INT") {
+        stop
+        exit
+      }
+      trap("TERM"){
+        stop
+        exit
+      }
+      
+      EventMachine::run {
+        EventMachine::start_server(options[:host], options[:port].to_i, Sparrow::Server)
+      }
+    end
+    
+    def stop
+      puts "Stopping Eventmachine Server"
+      EventMachine::stop
+    end
+    
+    def parse_options
+      OptionParser.new do |opts|
+        opts.summary_width = 25
+        opts.banner = "Sparrow (#{VERSION})\n\n",
+                      "Usage: sparrow [-b path] [-t type] [-h host] [-p port] [-P file]\n",
+                      "               [-d] [-k port] [-l file] [-e]\n",
+                      "       sparrow --help\n",
+                      "       sparrow --version\n"
+        
+        opts.separator ""
+        opts.separator ""; opts.separator "Configuration:"
+        
+        opts.on("-b", "--base PATH", String, "Path to queue data store.", "(default: #{options[:base_dir]})") do |v|
+          options[:base_dir] = File.expand_path(v)
+        end
+        
+        opts.on("-t", "--type QUEUE_TYPE", String, "Type of queue (disk/memory/sqlite).", "(default: #{options[:type]})") do |v|
+          options[:type] = v
+        end
+        
+        opts.separator ""; opts.separator "Network:"
+        
+        opts.on("-h", "--host HOST", String, "Specify host", "(default: #{options[:host]})") do |v|
+          options[:host] = v
+        end
+        
+        opts.on("-p", "--port PORT", Integer, "Specify port", "(default: #{options[:port]})") do |v|
+          options[:port] = v
+        end
+        
+        opts.separator ""; opts.separator "Daemonization:"
+        
+        opts.on("-P", "--pid FILE", String, "save PID in FILE when using -d option.", "(default: #{options[:pid_path]})") do |v|
+          options[:pid_path] = File.expand_path(v)
+        end
+        
+        opts.on("-d", "--daemon", "Daemonize mode") do |v|
+          options[:daemonize] = v
+        end
+
+        opts.on("-k", "--kill PORT", String, "Kill specified running daemons - leave blank to kill all.") do |v|
+          options[:kill] = v
+        end
+        
+        opts.separator ""; opts.separator "Logging:"
+        
+        opts.on("-l", "--log [FILE]", String, "Path to print debugging information.") do |v|
+          options[:log_path] = File.expand_path(v)
+        end
+        
+        opts.on("-e", "--debug", "Run in debug mode", "(default: #{options[:debug]})") do |v|
+          options[:debug] = v
+        end
+        
+        opts.separator ""; opts.separator "Miscellaneous:"
+        
+        opts.on_tail("-?", "--help", "Display this usage information.") do
+          puts "#{opts}\n"
+          exit
+        end
+        
+        opts.on_tail("-v", "--version", "Display version") do |v|
+          puts "Sparrow #{VERSION}"
+          exit
+        end
+      end.parse!
+      options
+    end
+    
+    private
+    
+    def store_pid(pid)
+     FileUtils.mkdir_p(File.dirname(pid_path))
+     File.open(pid_path, 'w'){|f| f.write("#{pid}\n")}
+    end
+
+    def kill_pid(k)
+      Dir[options[:pid_path]||File.join(File.dirname(pid_dir), "sparrow.#{k}.pid")].each do |f|
+        begin
+        puts f
+        pid = IO.read(f).chomp.to_i
+        FileUtils.rm f
+        Process.kill(9, pid)
+        puts "killed PID: #{pid}"
+        rescue => e
+          puts "Failed to kill! #{k}: #{e}"
+        end
+      end
+      exit
+    end
+
+    def daemonize
+     fork do
+       Process.setsid
+       exit if fork
+       store_pid(Process.pid)
+       # Dir.chdir "/" # Mucks up logs
+       File.umask 0000
+       STDIN.reopen "/dev/null"
+       STDOUT.reopen "/dev/null", "a"
+       STDERR.reopen STDOUT
+       start
+     end
+    end
+    
+  end
+end

data/lib/sparrow/server.rb

@@ -0,0 +1,201 @@
+module Sparrow
+  module Server
+    include Sparrow::Miscel
+    
+    class NoMoreMessages < SparrowError #:nodoc:
+    end
+
+    class ClientError < SparrowError #:nodoc:
+    end
+
+    class StatementInvalid < ClientError #:nodoc:
+    end
+
+    class InvalidBodyLength < ClientError #:nodoc:
+    end
+  
+    CR              = "\r\n"
+    ERROR           = "ERROR"
+    OK              = "OK"
+    EOF             = "END"
+               
+    CLIENT_ERROR    = "CLIENT_ERROR"
+    SERVER_ERROR    = "SERVER_ERROR"
+               
+    STORED          = "STORED"
+    NOT_STORED      = "NOT_STORED"
+               
+    DELETED         = "DELETED"
+    NOT_FOUND       = "NOT_FOUND"
+  
+    VALUE           = "VALUE"
+  
+    VERSION         = "VERSION"
+    
+    SET_REGEX       = /\ASET\s/i
+    ADD_REGEX       = /\AADD\s/i
+    REPLACE_REGEX   = /\AREPLACE\s/i
+    DELETE_REGEX    = /\ADELETE\s/i
+    GET_REGEX       = /\AGET\s/i
+    QUIT_REGEX      = /\AQUIT/i
+    FLUSH_ALL_REGEX = /\AFLUSH_ALL/i
+    VERSION_REGEX   = /\AVERSION/i
+
+    def post_init
+      @current_queue = nil
+      @expecting_body = false
+      @expected_bytes = 0
+      @current_flag = nil
+      @buffer = ''
+      logger.debug "New client"
+    end
+    
+    def receive_data(data)
+      logger.debug "Receiving data: #{data}"
+      @buffer << data
+      @buffer = process_whole_messages(@buffer)
+    end
+    
+    # process any whole messages in the buffer,
+    # and return the new contents of the buffer
+    def process_whole_messages(data)
+      return data if data !~ /\r\n/i # only process if data contains a CR
+      messages = data.split(CR)
+      if data =~ /\r\n$/i
+        data = ''
+      else
+        # remove the last message from the list (because it is incomplete) before processing
+        data = messages.pop
+      end
+      messages.each {|message| process_message(message) }
+      return data
+    end
+  
+    def process_message ln
+      @data = ln
+      if ln =~ SET_REGEX
+        set_command
+      elsif ln =~ ADD_REGEX
+        add_command
+      elsif ln =~ REPLACE_REGEX
+        replace_command
+      elsif ln =~ GET_REGEX
+        get_command
+      elsif ln =~ DELETE_REGEX
+        delete_command
+      elsif ln =~ QUIT_REGEX
+        quit_command
+      elsif ln =~ VERSION_REGEX
+        version_command
+      elsif ln =~ FLUSH_ALL_REGEX
+        flush_all_command
+      elsif @expecting_body
+        process_body
+      else
+        raise StatementInvalid
+      end
+      @data = nil
+      @split_args = nil
+
+    rescue ClientError => e
+      logger.error e
+      publish CLIENT_ERROR, e
+      publish ERROR
+    rescue => e
+      debugger
+      logger.error e
+      publish SERVER_ERROR, e
+    end
+  
+    def publish *args
+      send_data args.join(' ') + CR
+    end
+  
+    # Storage commands
+
+    # <command name> <key> <flags> <exptime> <bytes>\r\n
+    def set_command
+      @current_queue = args[1]
+      @current_flag = args[2] || 0
+      raise ClientError unless @current_queue
+      @expected_bytes = args[4].to_i || 0
+      @expecting_body = true
+    end
+    alias add_command set_command
+    alias replace_command set_command
+  
+    def process_body
+      if @data.length != @expected_bytes
+       raise InvalidBodyLength
+      end
+      @data << @current_flag
+      logger.debug "Adding message to queue - #{@current_queue}"
+      Sparrow::Queue.add_message(@current_queue, @data)
+      @expected_bytes = 0
+      @current_queue = nil
+      @expecting_body = false
+      publish STORED
+    end
+
+    # Retrieval commands
+  
+    # GET <key>*r\n
+    def get_command
+      args.shift # get rid of the command
+      raise ClientError if args.empty?
+      rsp = []
+      args.each do |queue|
+        begin
+          logger.debug "Getting message from queue - #{queue}"
+          msg = Sparrow::Queue.next_message(queue)
+          next unless msg
+        rescue NoMoreMessages
+          next
+        end
+        flag = msg[-1..-1]
+        msg = msg[0..-2]
+        rsp << [VALUE, queue, flag, msg.length].join(' ')
+        rsp << msg
+      end
+      rsp << EOF
+      send_data(rsp.join(CR) + CR)
+    end
+  
+    # Other commands
+  
+    # DELETE <key> <time>\r\n
+    def delete_command
+      if Sparrow::Queue.delete(!args[1])
+        logger.info "Deleting queue - #{args[1]}"
+        publish DELETED
+      else
+        publish NOT_FOUND
+      end
+    end
+  
+    # FLUSH_ALL
+    def flush_all_command
+      logger.info "Flushing all queues"
+      Sparrow::Queue.delete_all
+      publish OK
+    end
+  
+    # VERSION
+    def version_command
+      publish VERSION, Sparrow::Version
+    end
+  
+    # QUIT
+    def quit_command
+      logger.debug "Closing connection"
+      close_connection
+    end
+  
+    private
+  
+    def args
+      @split_args ||= @data.split(' ')
+    end
+  
+  end
+end

data/lib/sparrow/utils.rb

@@ -0,0 +1,71 @@
+class Class # :nodoc:
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+  end
+
+  def cattr_writer(*syms)
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+
+        def #{sym}=(obj)
+          @@#{sym} = obj
+        end
+      EOS
+    end
+  end
+
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+end
+
+module Sparrow
+  module Miscel
+    def options
+      Sparrow.options
+    end
+  
+    def options=(ob)
+      Sparrow.options = ob
+    end
+  
+    def base_dir
+      Sparrow.base_dir
+    end
+  
+    def log_path
+      Sparrow.log_path
+    end
+  
+    def pid_path
+      Sparrow.log_path
+    end
+    
+    def logger
+      Sparrow.logger
+    end
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: sparrow
+version: !ruby/object:Gem::Version 
+  version: "0.2"
+date: 2008-01-26 00:00:00 +00:00
+summary: Simple file based messagine queue using the memcache protocol
+require_paths: 
+- lib
+email: info@eribium.org
+homepage: http://code.google.com/p/sparrow
+rubyforge_project: Sparrow
+description: The author was too lazy to write a description
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Alex MacCAw
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/sparrow
+- lib/sparrow.rb
+- lib/sparrow/queue.rb
+- lib/sparrow/queues/disk.rb
+- lib/sparrow/queues/memory.rb
+- lib/sparrow/queues/sqlite.rb
+- lib/sparrow/runner.rb
+- lib/sparrow/server.rb
+- lib/sparrow/utils.rb
+test_files: []
+
+rdoc_options: 
+- --main
+- README.txt
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+executables: 
+- sparrow
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.10.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.4.0
+    version: