stompserver 0.9.1

data/History.txt

@@ -0,0 +1,10 @@
+== 0.9.0 / 16 Oct 2006
+
+* Initialial Beta Release
+  * Seems to work
+  * Passes numerous test cases
+  * Journals using madeleine
+  * Needs documentaion
+  * Needs to command line processing
+  * Needs service/daemon options
+

data/Manifest.txt

@@ -0,0 +1,16 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+setup.rb
+bin/stompserver
+lib/frame_journal.rb
+lib/queue_manager.rb
+lib/stomp_frame.rb
+lib/stomp_server.rb
+lib/topic_manager.rb
+test/test_frame_journal.rb
+test/test_queue_manager.rb
+test/test_stomp_frame.rb
+test/test_stomp_server.rb
+test/test_topic_manager.rb

data/README.txt

@@ -0,0 +1,58 @@
+stompserver
+    by Patrick Hurley
+    http://stompserver.rubyforge.org/
+
+== DESCRIPTION:
+
+Don't want to install a JVM, but still want to use messaging? Me too,
+so I threw together this little server. All the hard work was done
+by Francis Cianfrocca (big thank you) in his event machine gem (which
+is required by this server).
+
+== FEATURES/PROBLEMS:
+
+Handles basic message queue processing
+Does not support any server to server messaging
+  (although you could write a client to do this)
+Server Id is not being well initialized   
+Quite a bit of polish is still required to make into a daemon/service 
+and add command line handling.
+And oh yeah, I need to write some docs (see the tests for now)
+
+== SYNOPSYS:
+
+Handles basic message queue processing  
+
+== REQUIREMENTS:
+
++ EventMachine
++ madeleine 
+
+== INSTALL:
+
++ Grab the gem
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2006 Patrick Hurley
+
+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,23 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+$LOAD_PATH << "./lib"
+require 'stomp_server'
+
+Hoe.new('stompserver', StompServer::VERSION) do |p|
+  p.rubyforge_name = 'stompserver'
+  p.summary = 'A very light messaging server'
+  p.description = p.paragraphs_of('README.txt', 2..4).join("\n\n")
+  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  p.email = "phurley@gmail.com"
+  p.author = ["Patrick Hurley"]  
+  p.extra_deps = [
+                  ["eventmachine", ">= 5.0.0"],
+                  ["madeleine", ">= 0.7.3"], 
+                  ["hoe", ">= 1.1.1"]
+                 ]
+end
+
+# vim: syntax=Ruby

data/lib/frame_journal.rb

@@ -0,0 +1,134 @@
+# Simple Journal File(s) Manager
+# You select the directory, and it will collect the messages
+# The journal file format is:
+#
+# Status Byte: 0 - pending, 1 - processed
+# Frame Size: 4 byte long (network endian - yes I limit my messages to 4G)
+# Message 
+#
+# Repeat
+#
+# When the size of a journal file exceeds its limit
+
+require 'madeleine'
+require 'madeleine/automatic'
+
+class MadFrameJournal
+  include Madeleine::Automatic::Interceptor
+  attr_reader :frames
+  automatic_read_only :frames
+  attr_accessor :frame_index
+  automatic_read_only :frame_index
+  attr_accessor :system_id
+  automatic_read_only :system_id
+
+  def initialize
+    @frames = {}
+    @frame_index = 0
+    @system_id = nil
+  end
+
+  def add(msgid, frame)
+    @frames[msgid] = frame
+  end
+
+  def delete(msgid)
+    @frames.delete(msgid)
+  end
+
+  def clear
+    @frames.clear
+  end
+  
+  automatic_read_only :lookup
+  def lookup(msgid)
+    @frames[msgid]
+  end
+end
+
+class FrameJournal
+  def initialize(directory='frame-journal', snap_freq = 60 * 5)
+    @directory = directory
+    @mad = AutomaticSnapshotMadeleine.new(directory) do
+      MadFrameJournal.new
+    end
+    
+    # always snap on startup, in case we had an previous failure
+    @modified = true
+    Thread.new(@mad, snap_freq) do |mad, freq|
+      while true
+        sleep(freq)
+        mad.take_snapshot if @modified
+        @modified = false
+      end
+    end
+  end
+  
+  def []=(msgid, frame)
+    @modified = true
+    @mad.system.add(msgid, frame)
+  end
+  
+  def [](msgid)
+    @mad.system.lookup(msgid)
+  end
+  
+  def delete(msgid)
+    @modified = true
+    @mad.system.delete(msgid)
+  end
+  
+  def keys
+    @mad.system.frames.keys
+  end
+  
+  def clear
+    @modified = true
+    @mad.system.clear
+    @mad.take_snapshot
+  end
+  
+  def index
+    @mad.system.frame_index
+  end
+  
+  def next_index
+    @modified = true
+    @mad.system.frame_index += 1
+  end
+  
+  def system_id
+    unless name = @mad.system.system_id
+      # todo - grab default name from some place smarter...
+      @modified = true
+      @mad.system.system_id = 'cmastomp'
+      name = @mad.system.system_id
+    end 
+    name
+  end
+end
+
+if __FILE__ == $0
+  fj = FrameJournal.new('fj', 3)
+  until ARGV.empty?
+    case cmd = ARGV.shift
+    when "keys"
+      puts fj.keys.inspect
+    when "dump"
+      fj.keys.each do |key|
+        puts "#{key}: #{fj[key]}"
+      end
+    when "show"
+      key = ARGV.shift
+      puts "#{key}: #{fj[key]}"
+    when "add"
+      key = ARGV.shift
+      val = ARGV.shift
+      fj[key] = val
+    when "sleep"
+      sleep ARGV.shift.to_i
+    when "delete"
+      fj.delete(ARGV.shift)
+    end
+  end
+end

data/lib/queue_manager.rb

@@ -0,0 +1,68 @@
+# queue - persistent sent to a single subscriber
+# queue_monitor - looks, but does not remove from queue
+
+class QueueManager
+  Struct::new('QueueUser', :user, :ack)
+  
+  def initialize(journal)
+    # read journal information
+    @journal = journal
+    @queues = Hash.new { Array.new }
+    @pending = Hash.new { Array.new }
+    @messages = Hash.new { Array.new }
+    
+    # recover from previous run
+    msgids = @journal.keys.sort
+    msgids.each do |msgid|
+      sendmsg(@journal[msgid])
+    end
+  end  
+
+  def subscribe(dest, user, use_ack=false)
+    user = Struct::QueueUser.new(user, use_ack)
+    @queues[dest] += [user]
+    @messages[dest].each do |frame|
+      send_to_user(frame, user)
+    end
+  end
+  
+  def unsubscribe(topic, user)
+    @queues[topic].delete_if { |u| u.user == user } 
+  end
+  
+  def ack(user, frame)
+    pending_size = @pending[user]
+    msgid = frame.headers['message-id']
+    @pending[user].delete_if { |pf| pf.headers['message-id'] == msgid }
+    raise "Message (#{msgid}) not found" if pending_size == @pending[user]
+    @journal.delete(msgid)
+  end
+
+  def disconnect(user)
+    @pending[user].each do |frame|
+      sendmsg(frame)
+    end
+  end
+    
+  def send_to_user(frame, user)
+    if user.ack
+      @pending[user.user] += [frame]
+    else
+      @journal.delete(frame.headers['message-id'])
+    end 
+    user.user.send_data(frame.to_s)
+  end
+  
+  def sendmsg(frame)
+    frame.command = "MESSAGE"
+    dest = frame.headers['destination']
+    @journal[frame.headers['message-id']] = frame
+
+    if user = @queues[dest].shift
+      send_to_user(frame, user)
+      @queues[dest].push(user)
+    else
+      @messages[dest] += [frame]
+    end
+  end  
+end

data/lib/stomp_frame.rb

@@ -0,0 +1,92 @@
+class StompFrame
+  attr_accessor :command, :headers, :body
+  def initialize(command=nil, headers=nil, body=nil)
+    @command = command
+    @headers = headers || {}
+    @body = body || ''
+  end
+  
+  def to_s
+    result = @command + "\n"
+    @headers['content-length'] = @body.size.to_s if @body.include?(0)
+    @headers.each_pair do |key, value|
+      result << "#{key}:#{value}\n"
+    end
+    result << "\n"
+    result << @body.to_s
+    result << "\000\n"  
+  end
+  
+  def dest
+    #@dest || (@dest = @headers['destination'])
+    @headers['destination']
+  end
+end
+
+class StompFrameRecognizer
+  attr_accessor :frames
+  
+  def initialize
+    @buffer = ''
+    @body_length = nil
+    @frame = StompFrame.new
+    @frames = []
+  end
+  
+  def parse_body(len)
+    raise RuntimeError.new("Invalid stompframe (missing null term)") unless @buffer[len] == 0
+    @frame.body = @buffer[0...len]
+    @buffer = @buffer[len+1..-1]
+    @frames << @frame
+    @frame = StompFrame.new
+  end
+  
+  def parse_binary_body
+    if @buffer.length > @body_length
+      parse_body(@body_length)
+    end
+  end
+  
+  def parse_text_body
+    if pos = @buffer.index(0)
+      parse_body(pos)
+    end
+  end
+  
+  def parse_header
+    if match = @buffer.match(/^\s*(\S+)$((?:\s*.*?\s*:\s*.*?\s*$)*)$\r?\n$\r?\n/)
+      @frame.command, headers = match.captures
+      @buffer = match.post_match
+      headers.split(/\n/).each do |data|
+        if data =~ /^\s*(\S+)\s*:\s*(.*?)\s*$/
+          @frame.headers[$1] = $2
+        end
+      end
+      
+      # body_length is nil, if there is no content-length, otherwise it is the length (as in integer)
+      @body_length = @frame.headers['content-length'] && @frame.headers['content-length'].to_i
+    end
+  end
+  
+  def parse
+    count = @frames.size
+    
+    parse_header unless @frame.command
+    if @frame.command
+      if @body_length
+        parse_binary_body
+      else
+        parse_text_body
+      end
+    end
+    
+    # parse_XXX_body return the frame if they succeed and nil if they fail
+    # the result will fall through
+    parse if count != @frames.size
+  end
+  
+  def<< (buf)
+    @buffer << buf
+    parse
+  end    
+end

data/lib/stomp_server.rb

@@ -0,0 +1,156 @@
+require 'eventmachine'
+require 'stomp_frame'
+require 'topic_manager'
+require 'queue_manager'
+require 'frame_journal'
+
+module StompServer
+  VERSION = '0.9.1'
+  VALID_COMMANDS = [:connect, :send, :subscribe, :unsubscribe, :begin, :commit, :abort, :ack, :disconnect]
+
+  def self.setup(j = FrameJournal.new, tm = TopicManager.new, qm = QueueManager.new(j))
+    @@journal = j
+    @@topic_manager = tm
+    @@queue_manager = qm
+  end
+    
+  def post_init
+    @sfr = StompFrameRecognizer.new
+    @transactions = {}
+    @connected = false
+  end
+  
+  def receive_data(data)
+    begin
+      puts "receive_data: #{data.inspect}" if $DEBUG
+      @sfr << data
+      process_frames
+    rescue Exception => e
+      puts "err: #{e} #{e.backtrace.join("\n")}" if $DEBUG
+      send_error(e.to_s)
+      close_connection_after_writing
+    end
+  end
+  
+  def process_frames
+    frame = nil
+    process_frame(frame) while frame = @sfr.frames.shift
+  end
+  
+  def process_frame(frame)
+    cmd = frame.command.downcase.to_sym
+    raise "Unhandled frame: #{cmd}" unless VALID_COMMANDS.include?(cmd)
+    raise "Not connected" if !@connected && cmd != :connect
+
+    # I really like this code, but my needs are a little trickier
+    # 
+
+    if trans = frame.headers['transaction']
+      handle_transaction(frame, trans, cmd)
+    else
+      cmd = :sendmsg if cmd == :send
+      send(cmd, frame) 
+    end
+    
+    send_receipt(frame.headers['receipt']) if frame.headers['receipt']
+  end
+  
+  def handle_transaction(frame, trans, cmd)
+    if [:begin, :commit, :abort].include?(cmd)
+      send(cmd, frame, trans)
+    else
+      raise "transaction does not exist" unless @transactions.has_key?(trans)
+      @transactions[trans] << frame
+    end    
+  end
+  
+  def connect(frame)
+    puts "Connecting" if $DEBUG
+    response = StompFrame.new("CONNECTED", {'session' => 'wow'})
+    send_data(response.to_s)
+    @connected = true
+  end
+  
+  def sendmsg(frame)
+    # set message id
+    frame.headers['message-id'] = "msg-#{@@journal.system_id}-#{@@journal.next_index}"
+    if frame.dest.match(%r|^/queue|)
+      @@queue_manager.sendmsg(frame)
+    else
+      @@topic_manager.sendmsg(frame)
+    end
+  end
+  
+  def subscribe(frame)
+    if frame.dest =~ %r|^/queue|
+      @@queue_manager.subscribe(frame.dest, self)
+    else
+      @@topic_manager.subscribe(frame.dest, self)
+    end
+  end
+  
+  def unsubscribe(frame)
+    if frame.dest =~ %r|^/queue|
+      @@queue_manager.unsubscribe(self)
+    else
+      @@topic_manager.unsubscribe(self)
+    end
+  end
+  
+  def begin(frame, trans=nil)
+    raise "Missing transaction" unless trans
+    raise "transaction exists" if @transactions.has_key?(trans)
+    @transactions[trans] = []
+  end
+  
+  def commit(frame, trans=nil)
+    raise "Missing transaction" unless trans
+    raise "transaction does not exist" unless @transactions.has_key?(trans)
+    
+    (@transactions[trans]).each do |frame|
+      frame.headers.delete('transaction')
+      process_frame(frame)
+    end
+    @transactions.delete(trans)
+  end
+  
+  def abort(frame, trans=nil)
+    raise "Missing transaction" unless trans
+    raise "transaction does not exist" unless @transactions.has_key?(trans)
+    @transactions.delete(trans)
+  end
+  
+  def ack(frame)
+    @@queue_manager.ack(self, frame)
+  end
+  
+  def disconnect(frame)
+    puts "Polite disconnect" if $DEBUG
+    close_connection_after_writing
+  end
+
+  def send_message(msg)
+    msg.command = "MESSAGE"
+    send_data(msg.to_s)
+  end
+    
+  def send_receipt(id)
+    send_frame("RECEIPT", { 'receipt-id' => id})
+  end
+  
+  def send_error(msg)
+    send_frame("ERROR",{},msg)
+  end
+  
+  def send_frame(command, headers={}, body='')
+    response = StompFrame.new(command, headers, body)
+    send_data(response.to_s)
+  end  
+end
+
+if $0 == __FILE__
+  StompServer.setup
+  EventMachine::run do
+    EventMachine.start_server "0.0.0.0", 61613, StompServer
+  end
+end

data/lib/topic_manager.rb

@@ -0,0 +1,24 @@
+# topic - non persistent, sent to all interested parties
+
+class TopicManager
+  def initialize
+    @topics = Hash.new { Array.new }
+  end  
+
+  def subscribe(topic, user)
+    @topics[topic] += [user]
+  end
+  
+  def unsubscribe(topic, user)
+    @topics[topic].delete(user) 
+  end
+  
+  def sendmsg(msg)
+    msg.command = "MESSAGE"
+    topic = msg.headers['destination']
+    payload = msg.to_s
+    @topics[topic].each do |user|
+      user.send_data(payload)
+    end
+  end  
+end