stompserver_ng 1.0.6

data/lib/stomp_server_ng/protocols/http.rb

@@ -0,0 +1,128 @@
+
+  class Mongrel::HttpRequest
+    attr_reader :body, :params
+
+    def initialize(params, initial_body)
+      @params = params
+      @body = StringIO.new
+      @body.write params.http_body
+    end
+  end
+
+module StompServer
+module StompServer::Protocols
+
+  class Http < EventMachine::Connection
+
+    def initialize *args
+      super
+      @buf = ''
+    end
+
+
+    def post_init
+      @parser = Mongrel::HttpParser.new
+      @params = Mongrel::HttpParams.new
+      @nparsed = 0
+      @request = nil
+      @request_method = nil
+      @request_length = 0
+      @state = :headers
+      @headers_out = {'Content-Length' => 0, 'Content-Type' => 'text/plain; charset=UTF-8'}
+    end
+
+    def receive_data data
+      parse_request(data)
+    end
+
+    def parse_request data
+      @buf << data
+      case @state
+      when :headers
+        @nparsed = @parser.execute(@params, @buf, @nparsed)
+        if @parser.finished?
+          @request = Mongrel::HttpRequest.new(@params,@buf)
+          @request_method = @request.params[Mongrel::Const::REQUEST_METHOD]
+          content_length = @request.params[Mongrel::Const::CONTENT_LENGTH].to_i
+          @request_length = @nparsed + content_length
+          @remain = content_length - @request.params.http_body.length
+          if @remain <= 0
+            @buf = @buf[@request_length+1..-1] || ''
+            process_request
+            post_init
+            return
+          end
+          @request.body.write @request.params.http_body
+          @state = :body
+        end
+      when :body
+        @remain -= @request.body.write data[0...@remain]
+        if @remain <= 0
+          @buf = @buf[@request_length+1..-1] || ''
+          process_request
+          post_init
+          return
+        end
+      end
+    end
+
+    def process_request
+      begin
+        @request.body.rewind
+        dest = @request.params[Mongrel::Const::REQUEST_PATH]
+        case @request_method
+        when 'PUT'
+          @frame = StompServer::StompFrame.new
+          @frame.command = 'SEND'
+          @frame.body = @request.body.read
+          @frame.headers['destination'] = dest
+          if @@queue_manager.enqueue(@frame)
+            create_response('200','Message Enqueued')
+          else
+            create_response('500','Error enqueueing message')
+          end
+        when 'GET'
+          if frame = @@queue_manager.dequeue(dest)
+            @headers_out['message-id'] = frame.headers['message-id']
+            create_response('200',frame.body)
+          else
+            create_response('404','No messages in queue')
+          end
+        else
+          create_response('500','Invalid Command')
+        end
+      rescue Exception => e
+        puts "err: #{e} #{e.backtrace.join("\n")}"
+        create_response('500',e)
+      end
+    end
+
+    def unbind
+      puts "Closing connection"
+      close_connection_after_writing
+    end
+
+    def create_response(code,response_text)
+      response = ''
+      @headers_out['Content-Length'] = response_text.size
+
+      case code
+      when '200'
+        response << "HTTP/1.1 200 OK\r\n"
+      when '500'
+        response << "HTTP/1.1 500 Server Error\r\n"
+      when '404'
+        response << "HTTP/1.1 404 Message Not Found\r\n"
+      end
+      @headers_out.each_pair do |key, value|
+        response << "#{key}:#{value}\r\n"
+      end
+      response << "\r\n"
+      response << response_text
+      send_data(response)
+      unbind if @request.params['HTTP_CONNECTION'] == 'close'
+    end
+  end
+
+end
+end

data/lib/stomp_server_ng/protocols/stomp.rb

@@ -0,0 +1,407 @@
+#
+module StompServer
+module StompServer::Protocols
+#
+VALID_COMMANDS = [
+  :abort,         # Explicit method supplied
+  :ack,           # Explicit method supplied
+  :begin,         # Explicit method supplied
+  :commit,        # Explicit method supplied
+  :connect,       # Explicit method supplied
+  :disconnect,    # Explicit method supplied
+  :send,          # Explicit method supplied
+  :subscribe,     # Explicit method supplied
+  :unsubscribe    # Explicit method supplied
+]
+#
+# = Stomp Protocol Handler.
+#
+class Stomp < EventMachine::Connection
+
+  attr_reader :session_id
+
+  # Protocol handler initialization
+  def initialize(*args)
+    super(*args)
+    #
+    @@log = Logger.new(STDOUT)
+    @@log.level = StompServer::LogHelper.get_loglevel()
+    #
+    @@options = (Hash === args.last) ? args.pop : {}
+    # Arguments are passed from EventMachine::start_server
+    @@auth_required = args[0]
+    @@queue_manager = args[1]
+    @@topic_manager = args[2]
+    @@stompauth =     args[3]
+    #
+    # N.B.: The session ID is an instance variable!
+    #
+    if @@options[:session_cache] == 0
+      lt = Time.now
+      @session_id = "ssng_#{lt.to_f}"
+    else
+      @session_id = StompServer::SessionIDManager.get_cache_id(@@options[:session_cache])
+    end
+    @@log.debug("#{@session_id} #{self} Session ID assigned")
+    #
+    @@log.warn("#{@session_id} #{self} Protocol initialization complete")
+  end
+
+# :stopdoc:
+#
+# <tt>EM::Connection.close_connection()</tt>
+#
+# <tt>EM::Connection.close_connection_after_writing()</tt>
+#
+# <tt>EM::Connection.comm_inactivity_timeout()</tt>
+#
+# <tt>EM::Connection.comm_inactivity_timeout=(value)</tt>
+#
+# <tt>EM::Connection.connection_completed()</tt>
+#
+# <tt>EM::Connection.detach()</tt>
+#
+# <tt>EM::Connection.error?()</tt>
+#
+# <tt>EM::Connection.get_peer_cert()</tt>
+#
+# <tt>EM::Connection.get_peername()</tt>
+#
+# <tt>EM::Connection.get_pid()</tt>
+#
+# <tt>EM::Connection.get_sock_opt(level,option)</tt>
+#
+# <tt>EM::Connection.get_sockname()</tt>
+#
+# <tt>EM::Connection.get_status()</tt>
+#
+# <tt>EM::Connection.notify_readable=(mode)</tt>
+#
+# <tt>EM::Connection.notify_readable?()</tt>
+#
+# <tt>EM::Connection.notify_writable=(mode)</tt>
+#
+# <tt>EM::Connection.notify_writable?()</tt>
+#
+# <tt>EM::Connection.pause()</tt>
+#
+# <tt>EM::Connection.paused?()</tt>
+#
+# <tt>EM::Connection.pending_connect_timeout()</tt>
+#
+# <tt>EM::Connection.pending_connect_timeout=(value)</tt>
+#
+
+# :startdoc:
+
+  # <tt>EM::Connection.post_init()</tt>
+  #
+  # Protocol handler post initialization.
+  def post_init
+    @sfr = StompServer::StompFrameRecognizer.new
+    @transactions = {}
+    @connected = false
+    @@log.debug("#{@session_id} protocol post_init complete")
+  end
+
+# :stopdoc:
+
+#
+# <tt>EM::Connection.proxy_incoming_to(conn,bufsize=0)</tt>
+#
+# <tt>EM::Connection.proxy_target_unbound()</tt>
+#
+
+# :startdoc:
+
+  # <tt>EM::Connection.receive_data(data)</tt>
+  #
+  # Delegate to stomp_receive_data helper.
+  #
+  def receive_data(data)
+    stomp_receive_data(data)
+  end
+
+# :stopdoc:
+
+# <tt>EM::Connection.reconnect(server,port)</tt>
+#
+# <tt>EM::Connection.resume()</tt>
+#
+
+# :startdoc:
+
+  # <tt>EM::Connection.send_data(data)</tt>
+  #
+  # Just calls super.
+  #
+  def send_data(data)
+    super(data)
+  end  
+
+# :stopdoc:
+
+# <tt>EM::Connection.send_datagram(data,recipient_address,recipient_port)</tt>
+#
+# <tt>EM::Connection.send_file_data(filename)</tt>
+#
+# <tt>EM::Connection.set_comm_inactivity_timeout(value)</tt>
+#
+# <tt>EM::Connection.set_pending_connect_timeout(value)</tt>
+#
+# <tt>EM::Connection.ssl_handshake_completed()</tt>
+#
+# <tt>EM::Connection.ssl_verify_peer(cert)</tt>
+#
+# <tt>EM::Connection.start_tls(args={})</tt>
+#
+# <tt>EM::Connection.stop_proxying()</tt>
+#
+# <tt>EM::Connection.stream_file_data(filename, args={})</tt>
+#
+
+# :startdoc:
+
+  # <tt>EM::Connection.unbind()</tt>
+  #
+  # Unbind the connection.
+  #
+  def unbind()
+    @@log.warn "#{@session_id} Unbind called"
+    @connected = false
+    @@queue_manager.disconnect(self)
+    @@topic_manager.disconnect(self)
+  end
+
+# :stopdoc:
+
+# Stomp Protocol Verbs
+
+# :startdoc:
+  #
+  # Stomp Protocol - ABORT
+  #
+  def abort(frame, trans=nil)
+    raise "#{@session_id} Missing transaction" unless trans
+    raise "#{@session_id} transaction does not exist" unless @transactions.has_key?(trans)
+    @transactions.delete(trans)
+  end
+  #
+  # Stomp Protocol - ACK
+  #
+  # Delegated to the queue manager.
+  #
+  def ack(frame)
+    @@queue_manager.ack(self, frame)
+  end
+  #
+  # Stomp Protocol - BEGIN
+  #
+  def begin(frame, trans=nil)
+    raise "#{@session_id} Missing transaction" unless trans
+    raise "#{@session_id} transaction exists" if @transactions.has_key?(trans)
+    @transactions[trans] = []
+  end
+  #
+  # Stomp Protocol - COMMIT
+  #
+  def commit(frame, trans=nil)
+    raise "#{@session_id} Missing transaction" unless trans
+    raise "#{@session_id} 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
+  #
+  # Stomp Protocol - CONNECT
+  #
+  def connect(frame)
+    if @@auth_required
+      unless frame.headers['login'] and frame.headers['passcode'] and  @@stompauth.authorized[frame.headers['login']] == frame.headers['passcode']
+        raise "#{@session_id} {self} Invalid Login"
+      end
+    end
+    @@log.warn "#{@session_id} Connecting"
+    response = StompServer::StompFrame.new("CONNECTED", {'session' => @session_id})
+    #
+    stomp_send_data(response)
+    @connected = true
+  end
+  #
+  # Stomp Protocol - DISCONNECT
+  #
+  def disconnect(frame)
+    @@log.warn "#{@session_id} Polite disconnect"
+    close_connection_after_writing
+  end
+  #
+  # Stomp Protocol - SEND
+  #
+  # The stomp SEND verb is by routing through:
+  #
+  # * receive_data(data)
+  # * stomp_receive_data
+  # * process_frames
+  # * process_frame
+  # * use Object#__send__ to call this method
+  #
+  def send(frame)
+    # set message id
+    if frame.dest.match(%r|^/queue|)
+      @@queue_manager.sendmsg(frame)
+    else
+      frame.headers['message-id'] = "msg-#stompcma-#{@@topic_manager.next_index}"
+      @@topic_manager.sendmsg(frame)
+    end
+  end
+  #
+  #
+  # Stomp Protocol - SUBSCRIBE
+  #
+  # Delegated to the queue or topic manager.
+  #
+  def subscribe(frame)
+    use_ack = false
+    use_ack = true  if frame.headers['ack'] == 'client'
+    #
+    if frame.headers['id']
+      subid = frame.headers['id']
+    elsif frame.headers[:id]
+      subid = frame.headers[:id]
+    else
+      subid = nil
+    end
+    #
+    if frame.dest =~ %r|^/queue|
+      @@queue_manager.subscribe(frame.dest, self, use_ack, subid)
+    else
+      @@topic_manager.subscribe(frame.dest, self)
+    end
+  end
+  #
+  # Stomp Protocol - UNSUBSCRIBE
+  #
+  # Delegated to the queue or topic manager.
+  #
+  def unsubscribe(frame)
+    if frame.dest =~ %r|^/queue|
+      @@queue_manager.unsubscribe(frame.dest,self)
+    else
+      @@topic_manager.unsubscribe(frame.dest,self)
+    end
+  end
+
+  # :stopdoc:
+
+  # Helper methods
+
+  # :startdoc:
+  #
+  # stomp_receive_data
+  #
+  # Called from <tt>EM::Connection.receive_data(data)</tt>.  This is where
+  # we begin processing a set of data fresh off the wire.
+  # 
+  def stomp_receive_data(data)
+    begin
+      # Limit log message length.
+      logdata = data
+      logdata = data[0..256] + "...truncated..." if data.length > 256
+      @@log.debug "#{@session_id} receive_data: #{logdata.inspect}"
+      # Append all data to the recognizer buffer.
+      @sfr << data
+      # Process any stomp frames in this set of data.
+      process_frames
+    rescue Exception => e
+      @@log.error "#{@session_id} err: #{e} #{e.backtrace.join("\n")}"
+      send_error(e.to_s)
+      close_connection_after_writing
+    end
+  end 
+  #
+  # process_frames
+  #
+  # Handle all stomp frames currently in the recognizer's accumulated
+  # array of frames.
+  #
+  def process_frames
+    frame = nil
+    process_frame(frame) while frame = @sfr.frames.shift
+  end
+  #
+  # process_frame
+  #
+  # Process and individual stomp frame.
+  #
+  def process_frame(frame)
+    cmd = frame.command.downcase.to_sym
+    raise "#{@session_id} #{self} Unhandled frame: #{cmd}" unless VALID_COMMANDS.include?(cmd)
+    raise "#{@session_id} #{self} Not connected" if !@connected && cmd != :connect
+    @@log.debug("#{@session_id} process_frame: #{frame.command}")
+    # Add session ID to the frame headers
+    frame.headers['session'] = @session_id
+    # Send receipt first if required
+    send_receipt(frame.headers['receipt']) if frame.headers['receipt']
+    #
+    if trans = frame.headers['transaction']
+      # Handle transactional frame if required.
+      handle_transaction(frame, trans, cmd)
+    else
+      # Otherwise, just route the non-transactional frame.
+      __send__(cmd, frame) # Object#send alias call
+    end
+  end
+  #
+  # handle_transaction  
+  #
+  def handle_transaction(frame, trans, cmd)
+    if [:begin, :commit, :abort].include?(cmd)
+      __send__(cmd, frame, trans) # Object#send alias call
+    else
+      raise "#{@session_id} transaction does not exist" unless @transactions.has_key?(trans)
+      @transactions[trans] << frame
+    end    
+  end
+  #
+  # send_error
+  #
+  # Send a single error frame.
+  #
+  def send_error(msg)
+    send_frame("ERROR",{'message' => 'See below'},msg)
+  end
+  #
+  # send_frame
+  #
+  # Send an individual stomp frame.
+  #
+  def send_frame(command, headers={}, body='')
+    headers['content-length'] = body.size.to_s
+    response = StompServer::StompFrame.new(command, headers, body)
+    stomp_send_data(response)
+  end
+  #
+  # send_receipt
+  #
+  # Send a single receipt frame.
+  # 
+  def send_receipt(id)
+    send_frame("RECEIPT", { 'receipt-id' => id})
+  end
+  #
+  # stomp_send_data
+  #
+  def stomp_send_data(frame)
+    @@log.debug "#{@session_id} Sending frame #{frame.to_s}"
+    send_data(frame.to_s)
+  end
+
+  #
+end # class Stomp < EventMachine::Connection
+#
+end # module StompServer::Protocols
+end # module StompServer
+