stomper 0.4 → 1.0.0

data/lib/stomper/frames/receipt.rb

@@ -1,16 +1,11 @@
 module Stomper
   module Frames
     # Encapsulates a "RECEIPT" server side frame for the Stomp Protocol.
-    #
-    # See the {Stomp Protocol Specification}[http://stomp.codehaus.org/Protocol]
-    # for more details.
     class Receipt < Stomper::Frames::ServerFrame
-      # This class is a factory for all RECEIPT commands received.
-      factory_for :receipt
 
       # Creates a new Receipt frame with the supplied +headers+ and +body+
       def initialize(headers, body)
-        super('RECEIPT', headers, body)
+        super(headers, body)
       end
 
       # Returns the 'receipt-id' header of the frame, which

data/lib/stomper/frames/send.rb

@@ -1,13 +1,9 @@
 module Stomper
   module Frames
     # Encapsulates a "SEND" frame from the Stomp Protocol.
-    #
-    # See the {Stomp Protocol Specification}[http://stomp.codehaus.org/Protocol]
-    # for more details.
     class Send < Stomper::Frames::ClientFrame
       def initialize(destination, body, headers={})
-        super('SEND', headers, body)
-        @headers.destination = destination
+        super(headers.merge({ :destination => destination }), body)
       end
     end
   end

data/lib/stomper/frames/server_frame.rb

@@ -1,31 +1,21 @@
 module Stomper
   module Frames
     # Encapsulates a server side frame for the Stomp Protocol.
-    #
-    # See the {Stomp Protocol Specification}[http://stomp.codehaus.org/Protocol]
-    # for more details.
-    class ServerFrame
-      attr_reader :command, :headers, :body
+    class ServerFrame < IndirectFrame
 
       # Creates a new server frame corresponding to the
       # supplied +command+ with the given +headers+ and +body+.
-      def initialize(command, headers={}, body=nil)
-        @command = command
-        @headers = Headers.new(headers)
-        @body = body
+      def initialize(headers={}, body=nil, command = nil)
+        super
       end
 
       class << self
-        # Provides a method for subclasses to register themselves
-        # as factories for particular stomp commands by passing a list
-        # of strings (or symbols) to this method.  Each element in
-        # the list is interpretted as the command for which we will
-        # defer to the calling subclass to build.
-        def factory_for(*args)
-          @@registered_commands ||= {}
-          args.each do |command|
-            @@registered_commands[command.to_s.upcase] = self
-          end
+        def inherited(server_frame) #:nodoc:
+          declared_frames << { :class => server_frame, :command => server_frame.name.split("::").last.downcase.to_sym }
+        end
+
+        def declared_frames
+          @declared_frames ||= []
         end
 
         # Builds a new ServerFrame instance by first checking to
@@ -35,11 +25,11 @@ module Stomper
         # ServerFrame instance is created with its +command+ attribute
         # set appropriately.
         def build(command, headers, body)
-          command = command.to_s.upcase
-          if @@registered_commands.has_key?(command)
-            @@registered_commands[command].new(headers, body)
+          com_sym = command.downcase.to_sym
+          if klass = declared_frames.detect { |frame| com_sym == frame[:command] }
+            klass[:class].new(headers, body)
           else
-            ServerFrame.new(command, headers, body)
+            ServerFrame.new(headers, body, command)
           end
         end
       end

data/lib/stomper/frames/subscribe.rb

@@ -1,46 +1,41 @@
 module Stomper
   module Frames
     # Encapsulates a "SUBSCRIBE" frame from the Stomp Protocol.
-    #
-    # See the {Stomp Protocol Specification}[http://stomp.codehaus.org/Protocol]
-    # for more details.
     class Subscribe < Stomper::Frames::ClientFrame
       def initialize(destination, headers={})
-        super('SUBSCRIBE', headers)
-        @headers['destination'] = destination
-        @headers['ack'] ||= 'auto'
+        super({ :ack => 'auto' }.merge(headers).merge({ :destination => destination }))
       end
 
       # Returns the ack mode of this subscription. (defaults to 'auto')
       #
       # This is a convenience method, and may also be accessed through
-      # frame.headers.ack or frame.headers[:ack] or frame.headers['ack']
+      # frame.headers[:ack]
       def ack
-        @headers['ack']
+        @headers[:ack]
       end
 
       # Returns the destination to which we are subscribing.
       #
       # This is a convenience method, and may also be accessed through
-      # frame.headers.destination or frame.headers[:destination] or frame.headers['destination']
+      # frame.headers[:destination]
       def destination
-        @headers['destination']
+        @headers[:destination]
       end
 
       # Returns the id of this subscription, if it has been set.
       #
       # This is a convenience method, and may also be accessed through
-      # frame.headers.id or frame.headers[:id] or frame.headers['id']
+      # frame.headers[:id]
       def id
-        @headers['id']
+        @headers[:id]
       end
 
       # Returns the selector header of this subscription, if it has been set.
       #
       # This is a convenience method, and may also be accessed through
-      # frame.headers.selector or frame.headers[:selector] or frame.headers['selector']
+      # frame.headers[:selector]
       def selector
-        @headers['selector']
+        @headers[:selector]
       end
     end
   end

data/lib/stomper/frames/unsubscribe.rb

@@ -1,22 +1,18 @@
 module Stomper
   module Frames
     # Encapsulates an "UNSUBSCRIBE" frame from the Stomp Protocol.
-    #
-    # See the {Stomp Protocol Specification}[http://stomp.codehaus.org/Protocol]
-    # for more details.
     class Unsubscribe < Stomper::Frames::ClientFrame
       def initialize(destination, headers={})
-        super('UNSUBSCRIBE', headers)
-        @headers['destination'] = destination
+        super(headers.merge({ :destination => destination }))
       end
 
       # Returns the id of the subscription being unsubscribed from, if it
       # exists.
       #
       # This is a convenience method, and may also be accessed through
-      # frame.headers.id or frame.headers[:id] or frame.headers['id']
+      # frame.headers[:id]
       def id
-        @headers['id']
+        @headers[:id]
       end
     end
   end

data/lib/stomper/open_uri_interface.rb

@@ -0,0 +1,41 @@
+module Stomper
+  module OpenUriInterface
+    def put(msg, headers={})
+      send(default_destination, msg, headers.merge(:generate_content_length => false))
+    end
+    alias_method :puts, :put
+
+    def write(msg, headers={})
+      send(default_destination, msg, headers.merge(:generate_content_length => true))
+    end
+
+    def first(n=1)
+      received = []
+      each do |m|
+        received << m
+        break if received.size == n
+      end
+      n == 1 ? received.first : received
+    end
+    alias_method :get, :first
+    alias_method :gets, :first
+    alias_method :read, :first
+
+    # This is the tricky one.
+    # The subscriber interface is not going to work here, because it is built
+    # for an entirely different use case (threaded receiving)
+    # This interface, by contrast, is blocking... fudge.
+    def each(&block)
+      subscription = subscribe(default_destination) { |m| m }
+      loop do
+        m = receive
+        yield m if m.is_a?(Stomper::Frames::Message) && subscription.accepts?(m)
+      end
+    end
+
+    private
+    def default_destination
+      uri.path
+    end
+  end
+end

data/lib/stomper/receipt_handlers.rb

@@ -0,0 +1,23 @@
+module Stomper
+  class ReceiptHandlers
+    def initialize
+      @recps = {}
+      @recp_lock = Mutex.new
+    end
+
+    def add(receipt_id, callback)
+      @recp_lock.synchronize { @recps[receipt_id] = callback }
+    end
+    
+    def size
+      @recps.size
+    end
+
+    def perform(receipt)
+      @recp_lock.synchronize do
+        callback = @recps.delete(receipt.for)
+        callback.call(receipt) if callback
+      end
+    end
+  end
+end

data/lib/stomper/receiptor.rb

@@ -0,0 +1,38 @@
+module Stomper
+  module Receiptor
+    def self.included(base)
+      if base.method_defined?(:receive)
+        base.instance_eval do
+          alias_method :receive_without_receipt_dispatch, :receive
+          alias_method :receive, :receive_with_receipt_dispatch
+        end
+      end
+      if base.method_defined?(:send)
+        base.instance_eval do
+          alias_method :send_without_receipt_handler, :send
+          alias_method :send, :send_with_receipt_handler
+        end
+      end
+    end
+
+    # Receives a frame and dispatches it to the known receipt handlers, if the
+    # received frame is a RECEIPT frame.
+    def receive_with_receipt_dispatch
+      frame = receive_without_receipt_dispatch
+      receipt_handlers.perform(frame) if frame.is_a?(::Stomper::Frames::Receipt)
+      frame
+    end
+    
+    def send_with_receipt_handler(destination, body, headers={}, &block)
+      if block_given?
+        headers[:receipt] ||= "rcpt-#{Time.now.to_f}"
+        receipt_handlers.add(headers[:receipt], block)
+      end
+      send_without_receipt_handler(destination, body, headers)
+    end
+
+    def receipt_handlers
+      @receipt_handlers ||= ::Stomper::ReceiptHandlers.new
+    end
+  end
+end

data/lib/stomper/sockets.rb

@@ -0,0 +1,37 @@
+module Stomper
+  module Sockets
+    class SSL < DelegateClass(OpenSSL::SSL::SSLSocket)
+      include FrameReader
+      include FrameWriter
+
+      def initialize(host, port, *args)
+        @context = OpenSSL::SSL::SSLContext.new
+        @context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+        tcp_sock = TCPSocket.new(host, port)
+        @socket = OpenSSL::SSL::SSLSocket.new(tcp_sock, @context)
+        @socket.sync_close = true
+        @socket.connect
+        super(@socket)
+      end
+
+      def ready?
+        @socket.io.ready?
+      end
+      
+      def shutdown(mode=2)
+        @socket.io.shutdown(mode)
+      end
+    end
+
+    class TCP < DelegateClass(TCPSocket)
+      include FrameReader
+      include FrameWriter
+
+      def initialize(host, port, *args)
+        @socket = TCPSocket.new(host, port)
+        super(@socket)
+      end
+    end
+  end
+end

data/lib/stomper/subscriber.rb

@@ -0,0 +1,76 @@
+module Stomper
+  module Subscriber
+    def self.included(base)
+      if base.method_defined?(:receive)
+        base.instance_eval do
+          alias_method :receive_without_message_dispatch, :receive
+          alias_method :receive, :receive_with_message_dispatch
+        end
+      end
+    end
+
+    # Receives a frame and dispatches it to the known subscriptions, if the
+    # received frame is a MESSAGE frame.
+    def receive_with_message_dispatch
+      frame = receive_without_message_dispatch
+      subscriptions.perform(frame) if frame.is_a?(::Stomper::Frames::Message)
+      frame
+    end
+
+    # Subscribes to the specified +destination+, passing along
+    # the optional +headers+ inside the subscription frame.  When a message
+    # is received for this subscription, the supplied +block+ is
+    # called with the received message as its argument.
+    #
+    # Examples:
+    #
+    #   client.subscribe("/queue/test")  { |msg| puts "Got message: #{msg.body}" }
+    #
+    #   client.subscribe("/queue/test", :ack => 'client', 'id' => 'subscription-001') do |msg|
+    #     puts "Got message: #{msg.body}"
+    #   end
+    #
+    #   client.subscribe("/queue/test", :selector => 'cost > 5') do |msg|
+    #     puts "Got message: #{msg.body}"
+    #   end
+    #
+    # See also: unsubscribe, Stomper::Subscription
+    def subscribe(destination, headers={}, &block)
+      unless destination.is_a?(Subscription)
+        destination = Subscription.new(headers.merge(:destination => destination), &block)
+      end
+      subscriptions << destination
+      transmit(destination.to_subscribe)
+      destination
+    end
+
+    # Unsubscribes from the specified +destination+.  The +destination+
+    # parameter may be either a string, such as "/queue/test", or Stomper::Subscription
+    # object.  If the optional +sub_id+ is supplied, the client will unsubscribe
+    # from the subscription with an id matching +sub_id+, regardless if the
+    # +destination+ parameter matches that of the registered subscription.  For
+    # this reason, it is vital that subscription ids, if manually specified, be
+    # unique.
+    #
+    # Examples:
+    #
+    #   client.unsubscribe("/queue/test")
+    #   # unsubscribes from all "naive" subscriptions for "/queue/test"
+    #
+    #   client.unsubscribe("/queue/does/not/matter", "sub-0013012031")
+    #   # unsubscribes from all subscriptions with id of "sub-0013012031"
+    #
+    #   client.unsubscribe(some_subscription)
+    #
+    # See also: subscribe, Stomper::Subscription
+    def unsubscribe(destination, sub_id=nil)
+      subscriptions.remove(destination, sub_id).each do |unsub|
+        transmit(unsub.to_unsubscribe)
+      end
+    end
+
+    def subscriptions
+      @subscriptions ||= ::Stomper::Subscriptions.new
+    end
+  end
+end

data/lib/stomper/subscription.rb

@@ -36,23 +36,23 @@ module Stomper
     #
     # If no +subscription_id+ is specified, either explicitly or through a
     # hash key of 'id' in +destination_or_options+, one may be automatically
-    # generated of the form "sub-#{Time.now.to_f}".  The automatic generation
+    # generated of the form +sub-<Time.now.to_f>+.  The automatic generation
     # of a subscription id occurs if and only if naive? returns false.
     #
     # While direct creation of Subscription instances is possible, the preferred
     # method is for them to be constructed by a Stomper::Client through the use
     # of the Stomper::Client#subscribe method.
     #
-    # See also: naive?, Stomper::Client#subscribe, Stomper::Client#unsubscribe,
-    # Stomper::Client#ack
-    #
+    # @see naive?
+    # @see Subscriber#subscribe
+    # @see Subscriber#unsubscribe
+    # @see Client#ack
     def initialize(destination_or_options, subscription_id=nil, ack=nil, selector=nil, &block)
       if destination_or_options.is_a?(Hash)
-        options = Stomper::Frames::Headers.new(destination_or_options)
-        destination = options.destination
-        subscription_id ||= options.id
-        ack ||= options.ack
-        selector ||= options.selector
+        destination = destination_or_options[:destination]
+        subscription_id ||= destination_or_options[:id]
+        ack ||= destination_or_options[:ack]
+        selector ||= destination_or_options[:selector]
       else
         destination = destination_or_options.to_s
       end
@@ -110,9 +110,9 @@ module Stomper
     # Stomper::Frames::Subscribe client frame that can be transmitted
     # to a stomp broker through a Stomper::Connection instance.
     def to_subscribe
-      headers = { 'destination' => @destination, 'ack' => @ack.to_s }
-      headers['id'] = @id unless @id.nil?
-      headers['selector'] = @selector unless @selector.nil?
+      headers = { :destination => @destination, :ack => @ack.to_s }
+      headers[:id] = @id unless @id.nil?
+      headers[:selector] = @selector unless @selector.nil?
       Stomper::Frames::Subscribe.new(@destination, headers)
     end
 
@@ -120,8 +120,8 @@ module Stomper
     # Stomper::Frames::Unsubscribe client frame that can be transmitted
     # to a stomp broker through a Stomper::Connection instance.
     def to_unsubscribe
-      headers = { 'destination' => @destination }
-      headers['id'] = @id unless @id.nil?
+      headers = { :destination => @destination }
+      headers[:id] = @id unless @id.nil?
       Stomper::Frames::Unsubscribe.new(@destination, headers)
     end
   end