onstomp 1.0.0pre1 → 1.0.0

data/lib/onstomp/interfaces/event_manager.rb

@@ -32,6 +32,13 @@ module OnStomp::Interfaces::EventManager
   
   # Mixin to allow includers to define custom event methods
   module ClassMethods
+    # A convenient way to get a list of all of the event methods a class
+    # has defined for itself. Returns an array of event method names as symbols.
+    # @return [Array<Symbol>]
+    def event_methods
+      @event_methods ||= []
+    end
+    
     # Creates a convenience method for binding callbacks to the given
     # event name.
     # @param [Symbol] name
@@ -44,6 +51,7 @@ module OnStomp::Interfaces::EventManager
     #
     #   example_obj.do_event { |arg1, arg2| ... }
     def create_event_method name
+      event_methods << name
       module_eval "def #{name}(&block); bind_event(:#{name}, block); end"
     end
 

data/lib/onstomp/interfaces/uri_configurable.rb

@@ -29,7 +29,7 @@ module OnStomp::Interfaces::UriConfigurable
     def attr_configurable *args, &block
       opts = args.last.is_a?(Hash) ? args.pop : {}
       args.each do |attr_name|
-        __init_config_attribute__ attr_name, opts
+        init_config_attribute attr_name, opts
         attr_reader attr_name
         define_method :"#{attr_name}=" do |v|
           instance_variable_set(:"@#{attr_name}", (block ? block.call(v) : v))
@@ -44,7 +44,7 @@ module OnStomp::Interfaces::UriConfigurable
     # created by this method are assigned an +Array+, only the first element
     # will be used as their value.
     def attr_configurable_single *args, &block
-      trans = __attr_configurable_wrap__ lambda { |v| v.is_a?(Array) ? v.first : v }, block
+      trans = attr_configurable_wrap lambda { |v| v.is_a?(Array) ? v.first : v }, block
       attr_configurable(*args, &trans)
     end
     
@@ -55,7 +55,7 @@ module OnStomp::Interfaces::UriConfigurable
     # created by this method will be treated as though they were created
     # with {#attr_configurable_single} and will also be converted into Strings.
     def attr_configurable_str *args, &block
-      trans = __attr_configurable_wrap__ lambda { |v| v.to_s }, block
+      trans = attr_configurable_wrap lambda { |v| v.to_s }, block
       attr_configurable_single(*args, &trans)
     end
     
@@ -66,7 +66,7 @@ module OnStomp::Interfaces::UriConfigurable
     # created by this method are assigned a value that is not an +Array+, the
     # value will be wrapped in an array.
     def attr_configurable_arr *args, &block
-      trans = __attr_configurable_wrap__ lambda { |v| Array(v) }, block
+      trans = attr_configurable_wrap lambda { |v| Array(v) }, block
       attr_configurable(*args, &trans)
     end
     
@@ -78,12 +78,12 @@ module OnStomp::Interfaces::UriConfigurable
     # with {#attr_configurable_single} and will also be converted into Class
     # or Module objects.
     def attr_configurable_class *args, &block
-      trans = __attr_configurable_wrap__ lambda { |v| OnStomp.constantize(v) }, block
+      trans = attr_configurable_wrap lambda { |v| OnStomp.constantize(v) }, block
       attr_configurable_single(*args, &trans)
     end
     
     private
-    def __attr_configurable_wrap__(trans, block)
+    def attr_configurable_wrap(trans, block)
       if block
         lambda { |v| block.call(trans.call(v)) }
       else
@@ -91,7 +91,7 @@ module OnStomp::Interfaces::UriConfigurable
       end
     end
     
-    def __init_config_attribute__(name, opts)
+    def init_config_attribute(name, opts)
       unless respond_to?(:config_attributes)
         class << self
           def config_attributes

data/lib/onstomp/open-uri.rb

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+require 'open-uri'
+
+class OnStomp::Components::URI::STOMP
+  # Creates a new {OnStomp::Client}, extends it with
+  # {OnStomp::OpenURI::ClientExtensions} and either returns it directly or
+  # connects it, yields it to a given block and the disconnects it.
+  # @param [arg1, arg2, ...] args additional arguments to pass to {OnStomp::Client#initialize}
+  # @yield [client] block to evaluate within a connected client
+  # @yieldparam [OnStomp::Client] client
+  # @return [OnStomp::Client]
+  def open(*args)
+    client = OnStomp::Client.new(self, *args)
+    client.extend OnStomp::OpenURI::ClientExtensions
+    client.auto_destination = self.path
+    if block_given?
+      begin
+        client.connect
+        yield client
+      ensure
+        client.disconnect
+      end
+    end
+    client
+  end
+end
+
+# Namespace for OnStomp open-uri extensions.
+module OnStomp::OpenURI
+  # Raised if a client's
+  # {OnStomp::OpenURI::ClientExtensions#auto_destination auto_destination} has
+  # not been properly set.
+  class UnusableDestinationError < OnStomp::OnStompError; end
+end
+
+require 'onstomp/open-uri/message_queue'
+require 'onstomp/open-uri/client_extensions'

data/lib/onstomp/open-uri/client_extensions.rb

@@ -0,0 +1,88 @@
+# -*- encoding: utf-8 -*-
+
+# Mixin of extensions added to {OnStomp::Client clients} when they are
+# created by opening a stomp:// URI.
+module OnStomp::OpenURI::ClientExtensions
+  attr_reader :auto_destination, :openuri_message_queue
+  
+  # Aliases {#send_with_openuri} as +send+
+  def self.extended inst
+    inst.instance_eval do
+      alias :send_without_openuri :send
+      alias :send :send_with_openuri
+      alias :puts :send
+    end
+  end
+  
+  # Adds the ability for clients to generate SEND frames without specifying
+  # a destination by using {#auto_destination} instead.
+  # @return [OnStomp::Components::Frame] SEND frame
+  def send_with_openuri *args, &block
+    headers = args.last.is_a?(Hash) ? args.pop : {}
+    dest, body = args
+    if body.nil?
+      body, dest = dest, verified_auto_destination
+    end
+    send_without_openuri dest, body, headers, &block
+  end
+  
+  # Creates a subscription to {#auto_destination} and yields each MESSAGE frame
+  # read from the subscription to the supplied block. If no block is provided
+  # an enumerator is returned.
+  # @yield [m] block to call for each MESSAGE frame
+  # @yieldparam [OnStomp::Components::Frame] m
+  # @return [Enumerator,self] 
+  def each(&block)
+    if block
+      subscribe_to_auto_destination
+      loop do
+        yield openuri_message_queue.shift
+      end
+    else
+      OnStomp::ENUMERATOR_KLASS.new(self)
+    end
+  end
+
+  # Returns +n+ frames read from the subscription. If +n+ is ommited,
+  # the next frame is returned, otherwise an array of the next +n+ frames
+  # is returned.
+  # @see #each
+  # @param [Fixnum,nil] n
+  # @return [OnStomp::Components::Frame,Array<OnStomp::Components::Frame>]
+  def first(n=nil)
+    to_recv = n || 1
+    received = []
+    each do |m|
+      received << m
+      break if received.size == to_recv
+    end
+    n ? received : received.first
+  end
+  alias :take :first
+  alias :gets :first
+  
+  # Assigns the auto destination. When a stomp:// URI is opened, this
+  # will initially be set to the +path+ of the URI.
+  # @param [String] dest
+  # @return [String,nil]
+  def auto_destination= dest
+    @auto_destination = (dest == '/') ? nil : dest
+  end
+  
+  private
+  def subscribe_to_auto_destination
+    unless @subscribe
+      @openuri_message_queue = OnStomp::OpenURI::MessageQueue.new
+      @subscribe = subscribe(verified_auto_destination) do |m|
+        openuri_message_queue << m
+      end
+    end
+  end
+  
+  def verified_auto_destination
+    if auto_destination.nil? || auto_destination.empty?
+      raise OnStomp::OpenURI::UnusableDestinationError
+    end
+    auto_destination
+  end
+end

data/lib/onstomp/open-uri/message_queue.rb

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+
+# A simple synchronized message queue used to handle yielding MESSAGE frames
+# to {OnStomp::OpenURI::ClientExtensions#each} blocks.
+class OnStomp::OpenURI::MessageQueue
+  def initialize
+    @queue = []
+    @queue.extend MonitorMixin
+    @empty_check = @queue.new_cond
+  end
+  
+  # Waits until the queue contains at least one element, then takes it out
+  # and returns it.
+  def shift
+    take_from_queue :shift
+  end
+  
+  # Puts a new object into the queue.
+  def push msg
+    put_in_queue :push, msg
+  end
+  alias :<< :push
+  
+  private
+  def put_in_queue meth, msg
+    @queue.synchronize do
+      @queue.send meth, msg
+      @empty_check.signal
+    end
+  end
+  
+  def take_from_queue meth
+    @queue.synchronize do
+      @empty_check.wait_while { @queue.empty? }
+      @queue.send meth
+    end
+  end
+end

data/lib/onstomp/version.rb

@@ -9,5 +9,5 @@ module OnStomp
   # Patch version
   PATCH = 0
   # Complete version
-  VERSION = "#{MAJOR}.#{MINOR}.#{PATCH}pre1"
+  VERSION = "#{MAJOR}.#{MINOR}.#{PATCH}"
 end

data/spec/onstomp/client_spec.rb

@@ -124,6 +124,7 @@ module OnStomp
         client.stub(:processor => processor_class)
       end
       it "should call disconnect_without_flush and join the processor" do
+        processor.should_receive(:prepare_to_close)
         processor.should_receive(:join)
         client.should_receive(:disconnect_without_flush).with(headers).and_return(frame)
         client.disconnect_with_flush(headers).should == frame
@@ -235,10 +236,6 @@ module OnStomp
         client.processor = '::Module'
         client.processor.should == Module
       end
-      it "should use the NilProcessor if set to nil" do
-        client.processor = nil
-        client.processor.should == OnStomp::Components::NilProcessor
-      end
     end
     
     describe ".login" do

data/spec/onstomp/components/frame_headers_spec.rb

@@ -6,10 +6,7 @@ module OnStomp::Components
     let(:headers) {
       FrameHeaders.new
     }
-    let(:enumerator_module) {
-      RUBY_VERSION >= '1.9' ? Enumerator : Enumerable::Enumerator
-    }
-    
+        
     describe ".initialize" do
       it "should create an empty set of headers" do
         FrameHeaders.new.names.should == []
@@ -133,7 +130,7 @@ module OnStomp::Components
       end
       
       it "should yield an enumerator if called without a block" do
-        headers.each.should be_a_kind_of(enumerator_module)
+        headers.each.should be_a_kind_of(OnStomp::ENUMERATOR_KLASS)
       end
       
       it "should yield header names and values as pairs of strings" do

data/spec/onstomp/connections/stomp_1_0_spec.rb

@@ -27,6 +27,28 @@ module OnStomp::Connections
       end
     end
     
+    describe ".subscribe_frame" do
+      it "should automatically generate an 'id' header if one is not supplied" do
+        frame = connection.subscribe_frame('/queue/test', :ack => 'client',
+          :destination => '/queue/not-test')
+        frame.should be_an_onstomp_frame('SUBSCRIBE', {:ack => 'client',
+          :destination => '/queue/test'}, nil)
+        frame.header?(:id).should be_true
+      end
+      it "should build a SUBSCRIBE frame" do
+        connection.subscribe_frame('/queue/test', :ack => 'auto',
+          :destination => '/queue/not-test', :id => 's-1234'
+        ).should be_an_onstomp_frame('SUBSCRIBE', {:ack => 'auto',
+          :destination => '/queue/test', :id => 's-1234'}, nil)
+      end
+      it "should set ack mode to auto if it is not set to client" do
+        connection.subscribe_frame('/queue/test', :ack => 'fudge!',
+          :destination => '/queue/not-test', :id => 's-1234'
+        ).should be_an_onstomp_frame('SUBSCRIBE', {:ack => 'auto',
+          :destination => '/queue/test', :id => 's-1234'}, nil)
+      end
+    end
+    
     describe ".ack_frame" do
       let(:message_frame) {
         OnStomp::Components::Frame.new('MESSAGE', :'message-id' => 'm-1234')

data/spec/onstomp/connections/stomp_1_1_spec.rb

@@ -30,6 +30,28 @@ module OnStomp::Connections
       end
     end
     
+    describe ".subscribe_frame" do
+      it "should automatically generate an 'id' header if one is not supplied" do
+        frame = connection.subscribe_frame('/queue/test', :ack => 'client',
+          :destination => '/queue/not-test')
+        frame.should be_an_onstomp_frame('SUBSCRIBE', {:ack => 'client',
+          :destination => '/queue/test'}, nil)
+        frame.header?(:id).should be_true
+      end
+      it "should build a SUBSCRIBE frame" do
+        connection.subscribe_frame('/queue/test', :ack => 'client-individual',
+          :destination => '/queue/not-test', :id => 's-1234'
+        ).should be_an_onstomp_frame('SUBSCRIBE', {:ack => 'client-individual',
+          :destination => '/queue/test', :id => 's-1234'}, nil)
+      end
+      it "should set ack mode to auto if it is not set to client or client-individual" do
+        connection.subscribe_frame('/queue/test', :ack => 'fudge!',
+          :destination => '/queue/not-test', :id => 's-1234'
+        ).should be_an_onstomp_frame('SUBSCRIBE', {:ack => 'auto',
+          :destination => '/queue/test', :id => 's-1234'}, nil)
+      end
+    end
+    
     describe ".ack_frame" do
       let(:message_frame) {
         OnStomp::Components::Frame.new('MESSAGE',

data/spec/onstomp/connections/stomp_1_spec.rb

@@ -64,27 +64,10 @@ module OnStomp::Connections
       end
     end
     
-    describe ".subscribe_frame" do
-      it "should automatically generate an 'id' header if one is not supplied" do
-        frame = connection.subscribe_frame('/queue/test', :ack => 'client',
-          :destination => '/queue/not-test')
-        frame.should be_an_onstomp_frame('SUBSCRIBE', {:ack => 'client',
-          :destination => '/queue/test'}, nil)
-        frame.header?(:id).should be_true
-      end
-      it "should build a SUBSCRIBE frame" do
-        connection.subscribe_frame('/queue/test', :ack => 'auto',
-          :destination => '/queue/not-test', :id => 's-1234'
-        ).should be_an_onstomp_frame('SUBSCRIBE', {:ack => 'auto',
-          :destination => '/queue/test', :id => 's-1234'}, nil)
-      end
-    end
-    
     describe ".unsubscribe_frame" do
       it "should build an UNSUBSCRIBE frame from a SUBSCRIBE frame" do
-        subscribe_frame = connection.subscribe_frame('/queue/test',
-          :ack => 'auto',
-          :destination => '/queue/not-test', :id => 's-1234')
+        subscribe_frame = OnStomp::Components::Frame.new('SUBSCRIBE',
+          :id => 's-1234', :ack => 'auto')
         unsubscribe_frame = connection.unsubscribe_frame(subscribe_frame,
           :header1 => 'value 1')
         unsubscribe_frame.should be_an_onstomp_frame('UNSUBSCRIBE',

data/spec/onstomp/connections_spec.rb

@@ -63,6 +63,10 @@ module OnStomp
         Connections::PROTOCOL_VERSIONS['1.0'] = stomp_1_0_class
         Connections::PROTOCOL_VERSIONS['1.1'] = stomp_1_1_class
       end
+      after(:each) do
+        Connections::PROTOCOL_VERSIONS['1.0'] = Connections::Stomp_1_0
+        Connections::PROTOCOL_VERSIONS['1.1'] = Connections::Stomp_1_1
+      end
       
       describe "TCP connections" do
         before(:each) do

data/spec/onstomp/failover/buffers/written_spec.rb

@@ -0,0 +1,8 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module OnStomp::Failover::Buffers
+  describe Written, :failover => true do
+  
+  end
+end

data/spec/onstomp/failover/client_spec.rb

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module OnStomp::Failover
+  describe Client, :failover => true do
+    let(:active_client) {
+      mock('active client')
+    }
+    let(:client) {
+      Client.new('failover:(stomp:///,stomp+ssl:///)').tap do |c|
+        c.stub(:active_client => active_client)
+      end
+    }
+    describe ".connected?" do
+      it "should be connected if it has an active client that's connected" do
+        active_client.stub(:connected? => true)
+        client.connected?.should be_true
+      end
+      it "should not be connected if it has an active client that's not connected" do
+        active_client.stub(:connected? => false)
+        client.connected?.should be_false
+      end
+      it "should not be connected if it has no active client" do
+        client.stub(:active_client => nil)
+        client.connected?.should be_false
+      end
+    end
+    
+    describe ".transmit" do
+      it "should transmit on the active client if there is one" do
+        active_client.should_receive(:transmit).with('test', :coming => 'home')
+        client.transmit 'test', :coming => 'home'
+        client.stub(:active_client => nil)
+        client.transmit(mock('frame')).should be_nil
+      end
+    end
+  end
+end

data/spec/onstomp/failover/failover_events_spec.rb

@@ -0,0 +1,75 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module OnStomp::Failover
+  describe FailoverEvents, :failover => true do
+    let(:events) {
+      mock('events', :active_client => nil).tap do |m|
+        m.extend FailoverEvents
+      end
+    }
+    let(:client1) {
+      mock('client 1', :connection => nil).tap do |m|
+        m.extend OnStomp::Interfaces::ClientEvents
+      end
+    }
+    let(:client2) {
+      mock('client 2', :connection => nil).tap do |m|
+        m.extend OnStomp::Interfaces::ClientEvents
+      end
+    }
+    let(:client_pool) {
+      [client1, client2]
+    }
+    describe "client events" do
+      before(:each) do
+        events.stub(:client_pool => client_pool)
+      end
+      OnStomp::Interfaces::ClientEvents.event_methods.each do |meth|
+        it "should bind #{meth} to each client" do
+          client_pool.each { |c| c.should_receive(meth) }
+          events.__send__(meth) { |*_| true }
+        end
+        it "should only invoke the event if the triggering client is active" do
+          triggered = false
+          events.__send__(meth) { |*_| triggered = true }
+          events.stub(:active_client => client2)
+          client1.trigger_event meth
+          triggered.should be_false
+          triggered = false
+          client2.trigger_event meth
+          triggered.should be_true
+        end
+      end
+      
+      [:on_connection_established, :on_connection_died,
+        :on_connection_terminated, :on_connection_closed].each do |meth|
+        it "should bind #{meth} to each client" do
+          client_pool.each { |c| c.should_receive(meth) }
+          events.__send__(meth) { |*_| true }
+        end
+      end
+    end
+    
+    describe "failover events" do
+      [:before, :after].each do |pref|
+        it "should have an event :#{pref}_failover_retry" do
+          triggered = false
+          events.send(:"#{pref}_failover_retry") { |*_| triggered = true }
+          events.trigger_failover_retry pref, 1
+          triggered.should be_true
+        end
+      end
+      
+      [:connect_failure, :retries_exceeded,
+        :lost, :connected].each do |ev|
+        it "should have an event :on_failover_#{ev}" do
+          triggered = false
+          events.send(:"on_failover_#{ev}") { |*_| triggered = true }
+          events.trigger_failover_event ev, :on
+          triggered.should be_true
+        end
+      end
+    end
+  end
+end