stomp 1.0.6 → 1.1

data/lib/stomp/client.rb

@@ -0,0 +1,207 @@
+module Stomp
+
+  # Typical Stomp client class. Uses a listener thread to receive frames
+  # from the server, any thread can send.
+  #
+  # Receives all happen in one thread, so consider not doing much processing
+  # in that thread if you have much message volume.
+  class Client
+
+    attr_reader :login, :passcode, :host, :port, :reliable, :running
+
+    # A new Client object can be initialized using two forms:
+    #
+    # Standard positional parameters:
+    #   login     (String,  default : '')
+    #   passcode  (String,  default : '')
+    #   host      (String,  default : 'localhost')
+    #   port      (Integer, default : 61613)
+    #   reliable  (Boolean, default : false)
+    #
+    #   e.g. c = Client.new('login', 'passcode', 'localhost', 61613, true)
+    #
+    # Stomp URL :
+    #   A Stomp URL must begin with 'stomp://' and can be in one of the following forms:
+    #
+    #   stomp://host:port
+    #   stomp://host.domain.tld:port
+    #   stomp://login:passcode@host:port
+    #   stomp://login:passcode@host.domain.tld:port
+    #
+    def initialize(login = '', passcode = '', host = 'localhost', port = 61613, reliable = false)
+
+      # Parse stomp:// URL's or set positional params
+      case login
+      when /stomp:\/\/([\w\.]+):(\d+)/ # e.g. stomp://host:port
+        # grabs the matching positions out of the regex which are stored as
+        # $1 (host), $2 (port), etc
+        @login = ''
+        @passcode = ''
+        @host = $1
+        @port = $2.to_i
+        @reliable = false
+      when /stomp:\/\/([\w\.]+):(\w+)@([\w\.]+):(\d+)/ # e.g. stomp://login:passcode@host:port
+        @login = $1
+        @passcode = $2
+        @host = $3
+        @port = $4.to_i
+        @reliable = false
+      else
+        @login = login
+        @passcode = passcode
+        @host = host
+        @port = port.to_i
+        @reliable = reliable
+      end
+
+      raise ArgumentError if @host.nil? || @host.empty?
+      raise ArgumentError if @port.nil? || @port == '' || @port < 1 || @port > 65535
+      raise ArgumentError unless @reliable.is_a?(TrueClass) || @reliable.is_a?(FalseClass)
+
+      @id_mutex = Mutex.new
+      @ids = 1
+      @connection = Connection.new(@login, @passcode, @host, @port, @reliable)
+      @listeners = {}
+      @receipt_listeners = {}
+      @running = true
+      @replay_messages_by_txn = {}
+
+      @listener_thread = Thread.start do
+        while @running
+          message = @connection.receive
+          case
+          when message.nil?
+            break
+          when message.command == 'MESSAGE'
+            if listener = @listeners[message.headers['destination']]
+              listener.call(message)
+            end
+          when message.command == 'RECEIPT'
+            if listener = @receipt_listeners[message.headers['receipt-id']]
+              listener.call(message)
+            end
+          end
+        end
+      end
+
+    end
+
+    # Syntactic sugar for 'Client.new' See 'initialize' for usage.
+    def self.open(login = '', passcode = '', host = 'localhost', port = 61613, reliable = false)
+      Client.new(login, passcode, host, port, reliable)
+    end
+
+    # Join the listener thread for this client,
+    # generally used to wait for a quit signal
+    def join
+      @listener_thread.join
+    end
+
+    # Begin a transaction by name
+    def begin(name, headers = {})
+      @connection.begin(name, headers)
+    end
+
+    # Abort a transaction by name
+    def abort(name, headers = {})
+      @connection.abort(name, headers)
+
+      # lets replay any ack'd messages in this transaction
+      replay_list = @replay_messages_by_txn[name]
+      if replay_list
+        replay_list.each do |message|
+          if listener = @listeners[message.headers['destination']]
+            listener.call(message)
+          end
+        end
+      end
+    end
+
+    # Commit a transaction by name
+    def commit(name, headers = {})
+      txn_id = headers[:transaction]
+      @replay_messages_by_txn.delete(txn_id)
+      @connection.commit(name, headers)
+    end
+
+    # Subscribe to a destination, must be passed a block
+    # which will be used as a callback listener
+    #
+    # Accepts a transaction header ( :transaction => 'some_transaction_id' )
+    def subscribe(destination, headers = {})
+      raise "No listener given" unless block_given?
+      @listeners[destination] = lambda {|msg| yield msg}
+      @connection.subscribe(destination, headers)
+    end
+
+    # Unsubecribe from a channel
+    def unsubscribe(name, headers = {})
+      @connection.unsubscribe(name, headers)
+      @listeners[name] = nil
+    end
+
+    # Acknowledge a message, used when a subscription has specified
+    # client acknowledgement ( connection.subscribe "/queue/a", :ack => 'client'g
+    #
+    # Accepts a transaction header ( :transaction => 'some_transaction_id' )
+    def acknowledge(message, headers = {})
+      txn_id = headers[:transaction]
+      if txn_id
+        # lets keep around messages ack'd in this transaction in case we rollback
+        replay_list = @replay_messages_by_txn[txn_id]
+        if replay_list.nil?
+          replay_list = []
+          @replay_messages_by_txn[txn_id] = replay_list
+        end
+        replay_list << message
+      end
+      if block_given?
+        headers['receipt'] = register_receipt_listener lambda {|r| yield r}
+      end
+      @connection.ack message.headers['message-id'], headers
+    end
+
+    # Send message to destination
+    #
+    # If a block is given a receipt will be requested and passed to the
+    # block on receipt
+    #
+    # Accepts a transaction header ( :transaction => 'some_transaction_id' )
+    def send(destination, message, headers = {})
+      if block_given?
+        headers['receipt'] = register_receipt_listener lambda {|r| yield r}
+      end
+      @connection.send(destination, message, headers)
+    end
+
+    # Is this client open?
+    def open?
+      @connection.open?
+    end
+
+    # Is this client closed?
+    def closed?
+      @connection.closed?
+    end
+
+    # Close out resources in use by this client
+    def close
+      @connection.disconnect
+      @running = false
+    end
+
+    private
+
+      def register_receipt_listener(listener)
+        id = -1
+        @id_mutex.synchronize do
+          id = @ids.to_s
+          @ids = @ids.succ
+        end
+        @receipt_listeners[id] = listener
+        id
+      end
+
+  end
+end
+

data/lib/stomp/connection.rb

@@ -0,0 +1,256 @@
+module Stomp
+
+  # Low level connection which maps commands and supports
+  # synchronous receives
+  class Connection
+
+
+    # A new Connection object accepts the following parameters:
+    #
+    #   login             (String,  default : '')
+    #   passcode          (String,  default : '')
+    #   host              (String,  default : 'localhost')
+    #   port              (Integer, default : 61613)
+    #   reliable          (Boolean, default : false)
+    #   reconnect_delay   (Integer, default : 5)
+    #
+    #   e.g. c = Client.new("username", "password", "localhost", 61613, true)
+    #
+# TODO
+    # Stomp URL :
+    #   A Stomp URL must begin with 'stomp://' and can be in one of the following forms:
+    #
+    #   stomp://host:port
+    #   stomp://host.domain.tld:port
+    #   stomp://user:pass@host:port
+    #   stomp://user:pass@host.domain.tld:port
+    #
+    def initialize(login = '', passcode = '', host = 'localhost', port = 61613, reliable = false, reconnect_delay = 5, connect_headers = {})
+      @host = host
+      @port = port
+      @login = login
+      @passcode = passcode
+      @transmit_semaphore = Mutex.new
+      @read_semaphore = Mutex.new
+      @socket_semaphore = Mutex.new
+      @reliable = reliable
+      @reconnect_delay = reconnect_delay
+      @connect_headers = connect_headers
+      @closed = false
+      @subscriptions = {}
+      @failure = nil
+      socket
+    end
+
+    # Syntactic sugar for 'Connection.new' See 'initialize' for usage.
+    def Connection.open(login = '', passcode = '', host = 'localhost', port = 61613, reliable = false, reconnect_delay = 5, connect_headers = {})
+      Connection.new(login, passcode, host, port, reliable, reconnect_delay, connect_headers)
+    end
+
+    def socket
+      # Need to look into why the following synchronize does not work.
+      #@read_semaphore.synchronize do
+        s = @socket;
+        while s.nil? || !@failure.nil?
+          @failure = nil
+          begin
+            s = TCPSocket.open @host, @port
+	    headers = @connect_headers.clone
+	    headers[:login] = @login
+	    headers[:passcode] = @passcode
+            _transmit(s, "CONNECT", headers)
+            @connect = _receive(s)
+            # replay any subscriptions.
+            @subscriptions.each { |k,v| _transmit(s, "SUBSCRIBE", v) }
+          rescue
+            @failure = $!;
+            s=nil;
+            raise unless @reliable
+            $stderr.print "connect failed: " + $! +" will retry in #{@reconnect_delay}\n";
+            sleep(@reconnect_delay);
+          end
+        end
+        @socket = s
+        return s;
+      #end
+    end
+
+    # Is this connection open?
+    def open?
+      !@closed
+    end
+
+    # Is this connection closed?
+    def closed?
+      @closed
+    end
+
+    # Begin a transaction, requires a name for the transaction
+    def begin(name, headers = {})
+      headers[:transaction] = name
+      transmit("BEGIN", headers)
+    end
+
+    # Acknowledge a message, used when a subscription has specified
+    # client acknowledgement ( connection.subscribe "/queue/a", :ack => 'client'g
+    #
+    # Accepts a transaction header ( :transaction => 'some_transaction_id' )
+    def ack(message_id, headers = {})
+      headers['message-id'] = message_id
+      transmit("ACK", headers)
+    end
+
+    # Commit a transaction by name
+    def commit(name, headers = {})
+      headers[:transaction] = name
+      transmit("COMMIT", headers)
+    end
+
+    # Abort a transaction by name
+    def abort(name, headers = {})
+      headers[:transaction] = name
+      transmit("ABORT", headers)
+    end
+
+    # Subscribe to a destination, must specify a name
+    def subscribe(name, headers = {}, subId = nil)
+      headers[:destination] = name
+      transmit("SUBSCRIBE", headers)
+
+      # Store the sub so that we can replay if we reconnect.
+      if @reliable
+        subId = name if subId.nil?
+        @subscriptions[subId] = headers
+      end
+    end
+
+    # Unsubscribe from a destination, must specify a name
+    def unsubscribe(name, headers = {}, subId = nil)
+      headers[:destination] = name
+      transmit("UNSUBSCRIBE", headers)
+      if @reliable
+        subId = name if subId.nil?
+        @subscriptions.delete(subId)
+      end
+    end
+
+    # Send message to destination
+    #
+    # Accepts a transaction header ( :transaction => 'some_transaction_id' )
+    def send(destination, message, headers = {})
+      headers[:destination] = destination
+      transmit("SEND", headers, message)
+    end
+
+    # Close this connection
+    def disconnect(headers = {})
+      transmit("DISCONNECT", headers)
+      @closed = true
+    end
+
+    # Return a pending message if one is available, otherwise
+    # return nil
+    def poll
+      @read_semaphore.synchronize do
+        return nil if @socket.nil? || !@socket.ready?
+        return receive
+      end
+    end
+
+    # Receive a frame, block until the frame is received
+    def __old_receive
+      # The recive my fail so we may need to retry.
+      while TRUE
+        begin
+          s = socket
+          return _receive(s)
+        rescue
+          @failure = $!;
+          raise unless @reliable
+          $stderr.print "receive failed: " + $!;
+        end
+      end
+    end
+
+    def receive
+      super_result = __old_receive()
+      if super_result.nil? && @reliable
+        $stderr.print "connection.receive returning EOF as nil - resetting connection.\n"
+        @socket = nil
+        super_result = __old_receive()
+      end
+      return super_result
+    end
+
+    private
+
+      def _receive( s )
+        line = ' '
+        @read_semaphore.synchronize do
+          line = s.gets while line =~ /^\s*$/
+          return nil if line.nil?
+
+          message = Message.new do |m|
+            m.command = line.chomp
+            m.headers = {}
+            until (line = s.gets.chomp) == ''
+              k = (line.strip[0, line.strip.index(':')]).strip
+              v = (line.strip[line.strip.index(':') + 1, line.strip.length]).strip
+              m.headers[k] = v
+            end
+
+            if (m.headers['content-length'])
+              m.body = s.read m.headers['content-length'].to_i
+              c = RUBY_VERSION > '1.9' ? s.getc.ord : s.getc
+              raise "Invalid content length received" unless c == 0
+            else
+              m.body = ''
+              if RUBY_VERSION > '1.9'
+                until (c = s.getc.ord) == 0
+                  m.body << c.chr
+                end
+              else
+                until (c = s.getc) == 0
+                  m.body << c.chr
+                end
+              end
+            end
+            #c = s.getc
+            #raise "Invalid frame termination received" unless c == 10
+          end # message
+          return message
+
+        end
+      end
+
+      def transmit(command, headers = {}, body = '')
+        # The transmit may fail so we may need to retry.
+        while TRUE
+          begin
+            s = socket
+            _transmit(s, command, headers, body)
+            return
+          rescue
+            @failure = $!;
+            raise unless @reliable
+            $stderr.print "transmit failed: " + $!+"\n";
+          end
+        end
+      end
+
+      def _transmit(s, command, headers = {}, body = '')
+        @transmit_semaphore.synchronize do
+          s.puts command
+          headers.each {|k,v| s.puts "#{k}:#{v}" }
+          s.puts "content-length: #{body.length}"
+          s.puts "content-type: text/plain; charset=UTF-8"
+          s.puts
+          s.write body
+          s.write "\0"
+        end
+      end
+
+  end
+
+end
+