stompmq 0.5

data/lib/stompmq.rb

@@ -0,0 +1,2 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+require 'stompmq/connection'

data/lib/stompmq/connection.rb

@@ -0,0 +1,139 @@
+require 'socket'
+require 'stompmq/frame'
+require 'stompmq/message'
+
+module StompMq
+  class InvalidFrameType < StandardError; end
+  class CorruptFrame < StandardError; end
+  class CorruptHeader < StandardError; end
+  class ProtocolSequenceViolation < StandardError; end
+  class StompErrorReceived < StandardError; end
+  
+  # Represents a connection to a STOMP message broker.
+  class Connection
+    # Connect to a STOMP broker and log in.
+    def initialize(opts = { :broker => 'localhost', :port => 61613, :username => nil, :passcode => nil })
+      @buffer = ""
+      @broker   = opts[:broker]   || 'localhost'
+      @port     = opts[:port]     || 61613
+      @username = opts[:username]
+      @passcode = opts[:passcode]
+      @sock = TCPSocket.new @broker, @port
+      send_frame :connect, {:login => @username, :passcode => @passcode}
+      frame = receive_frame(15)
+      # some brokers add a \n after null-terminators, including after CONNECTED frames.
+      @buffer = ""
+      raise ProtocolSequenceViolation unless frame.cmd == 'CONNECTED'
+      self
+    end
+    
+    # Subscribe to a STOMP queue.
+    def subscribe(opts = { :queue => nil, :selector => nil })
+      if opts[:selector]
+        send_frame :subscribe, {:destination => opts[:queue], :selector => opts[:selector]}
+      else
+        send_frame :subscribe, {:destination => opts[:queue]}
+      end
+    end
+    
+    # Send a STOMP message to a queue.
+    def send_message(opts = { :queue => nil, :header => {}, :content => {} })
+      queue   = opts[:queue]
+      content = opts[:content] || {}
+      header  = opts[:header] || {}
+      
+      header = {:destination => queue}.merge(header)
+      send_frame :send, header, content
+    end
+    
+    # Receive a STOMP message.
+    def receive_message(timeout = nil)
+      frame = receive_frame(timeout)
+      return nil if !frame
+      raise StompErrorReceived.new(frame.content) if frame.cmd == 'ERROR'
+      raise ProtocolSequenceViolation unless frame.cmd == 'MESSAGE'
+      StompMq::Message.new(frame.header, frame.content)
+    end
+    
+    private
+    
+    # Transmit a standard STOMP frame.
+    def send_frame(function, header = {}, content = '')
+      frame = "#{function.to_s.upcase}\n"
+      header['content-length'] = content.to_s.length if content.to_s.include?("\000")
+      header.each do |key, val|
+        frame += "#{key.to_s}:#{val.to_s}\n"
+      end
+      frame += "\n"
+      frame += "#{content.to_s}\000"
+      @sock.write(frame)
+    end
+    
+    # Receive a standard STOMP frame.
+    def receive_frame(timeout = nil)
+      frame = parse_frame
+      return frame unless frame.nil?
+      # FIXME: we'll violate the timeout given if half a packet comes in at first, then more later.
+      until frame do
+        return nil if receive_data(timeout) == nil
+        frame = parse_frame
+      end
+      frame
+    end
+    
+    # Receive data waiting on a socket.  If timeout is passed, block for this many seconds,
+    # otherwise don't block, return nil if no frame is waiting.
+    def receive_data(timeout = nil)
+      sock_ready = select([@sock], nil, nil, timeout)
+      return nil if !sock_ready
+      @buffer += @sock.recv(1024)
+    end
+    
+    # Parse the instance buffer and pick out one frame.  If one entire frame is not available
+    # in the buffer, returns nil.
+    def parse_frame
+      return nil if !@buffer["\000"]
+      
+      cmd = header_text = nil
+      @buffer.lstrip!
+      raise CorruptFrame.new("No end to header found.") unless @buffer.include?("\n\n")
+      begin
+        cmd = @buffer.slice!(0..@buffer.index("\n")).chomp
+        header_text = @buffer.slice!(0..@buffer.index("\n\n")+1).chomp
+      rescue ArgumentError => e
+        raise CorruptFrame.new(e.message)
+      end
+      raise CorruptHeader.new("Found null in header.") if header_text.include?("\000")
+      
+      # split the header text up into a proper hash
+      header = {}
+      header_text.split("\n").each do |keyval|
+        key,val = keyval.split(':', 2)
+        header[key] = val
+      end
+      
+      # content runs until the first null, or per the content-length header if present.
+      content_length = @buffer.index("\000")
+      content_length = header['content-length'].to_i if header['content-length']
+      content = ''
+      if(@buffer.length) <= content_length then
+        # turns out we don't have a full frame after all! push the cmd/header back in.
+        @buffer = "#{cmd}\n#{header_text}\n#{@buffer}"
+        return nil
+      end
+      if(content_length > 0) then
+        content = @buffer[0..content_length-1]
+        @buffer[0..content_length] = ''
+      else
+        content = nil
+        @buffer[0] = ''
+      end
+      
+      raise InvalidFrameType.new("Invalid command: '#{cmd}'") unless ['CONNECTED', 'RECEIPT', 'MESSAGE', 'ERROR'].include?(cmd)
+      
+      return StompMq::Frame.new(cmd, header, content)
+    end
+    
+    attr_accessor :buffer
+  end
+end

data/lib/stompmq/frame.rb

@@ -0,0 +1,12 @@
+module StompMq
+  # Holds a STOMP frame of any type.
+  class Frame
+    attr_reader :cmd, :header, :content
+    
+    def initialize(cmd, header, content)
+      @cmd = cmd
+      @header = header
+      @content = content
+    end
+  end
+end

data/lib/stompmq/message.rb

@@ -0,0 +1,11 @@
+module StompMq
+  # Holds a STOMP message.
+  class Message
+    attr_reader :header, :content
+    
+    def initialize(header, content)
+      @header = header
+      @content = content
+    end
+  end
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification 
+name: stompmq
+version: !ruby/object:Gem::Version 
+  version: "0.5"
+platform: ruby
+authors: 
+- Sarah Nordstrom
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-09-13 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: 
+email: sarahemm@sarahemm.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/stompmq
+- lib/stompmq/connection.rb
+- lib/stompmq/frame.rb
+- lib/stompmq/message.rb
+- lib/stompmq.rb
+- README
+has_rdoc: true
+homepage: http://www.rubyforge.org/stompmq/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: stompmq
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Support for the STOMP messaging protocol in Ruby.
+test_files: []
+