right_agent 0.13.5 → 0.14.0

data/right_agent.gemspec

@@ -24,8 +24,8 @@ require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name      = 'right_agent'
-  spec.version   = '0.13.5'
-  spec.date      = '2012-10-03'
+  spec.version   = '0.14.0'
+  spec.date      = '2012-10-01'
   spec.authors   = ['Lee Kirchhoff', 'Raphael Simon', 'Tony Spataro']
   spec.email     = 'lee@rightscale.com'
   spec.homepage  = 'https://github.com/rightscale/right_agent'
@@ -40,7 +40,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency('right_support', ['>= 2.4.1', '< 3.0'])
   spec.add_dependency('right_amqp', '~> 0.4')
   spec.add_dependency('json', ['~> 1.4'])
-  spec.add_dependency('eventmachine', '~> 0.12.10')
+  spec.add_dependency('eventmachine', ['>= 0.12.10', '< 2.0'])
   spec.add_dependency('right_popen', '~> 1.0.11')
   spec.add_dependency('msgpack', '0.4.4')
   spec.add_dependency('net-ssh', '~> 2.0')

data/spec/agent_spec.rb

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2009-2011 RightScale Inc
+# Copyright (c) 2009-2012 RightScale Inc
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -240,14 +240,7 @@ describe RightScale::Agent do
       @agent.tags.should include("sample_tag_1")
       @agent.tags.should include("sample_tag_2")
     end
-    
-    it "for threadpool_size" do
-      @agent = RightScale::Agent.new(:threadpool_size => 5, :identity => @identity)
-      flexmock(@agent).should_receive(:load_actors).and_return(true)
-      @agent.run
-      @agent.dispatcher.em.threadpool_size.should == 5
-    end
-    
+
   end
 
   describe "" do
@@ -312,7 +305,7 @@ describe RightScale::Agent do
           @broker.should_receive(:subscribe).with(hsh(:name => @identity), nil, hsh(:brokers => nil), Proc).
                                              and_return(@broker_ids.first(1)).once
           @agent.run
-          @agent.instance_variable_get(:@remaining_setup).should == {:setup_identity_queue => @broker_ids.last(1)}
+          @agent.instance_variable_get(:@remaining_queue_setup).should == {@identity => @broker_ids.last(1)}
           @sender.should_receive(:send_push).with("/registrar/connect", {:agent_identity => @identity, :host => "123",
                                                                          :port => 2, :id => 1, :priority => 1}).once
           @agent.__send__(:check_status)
@@ -422,188 +415,104 @@ describe RightScale::Agent do
     end
 
     describe "Handling messages" do
-  
+
       it "should use dispatcher to handle requests" do
         run_in_em do
           request = RightScale::Request.new("/foo/bar", "payload")
           @broker.should_receive(:subscribe).with(hsh(:name => @identity), nil, Hash, Proc).
                                              and_return(@broker_ids).and_yield(@broker_id, request, @header).once
-          @dispatcher.should_receive(:dispatch).with(request, @header).once
+          @dispatcher.should_receive(:dispatch).with(request).once
           @agent.run
         end
       end
 
-      it "should use sender to handle results" do
+      it "should publish result from dispatched request to response queue" do
         run_in_em do
-          result = RightScale::Result.new("token", "to", "results", "from")
+          request = RightScale::Request.new("/foo/bar", "payload")
           @broker.should_receive(:subscribe).with(hsh(:name => @identity), nil, Hash, Proc).
-                                             and_return(@broker_ids).and_yield(@broker_id, result, @header).once
-          @sender.should_receive(:handle_response).with(result, @header).once
+                                             and_return(@broker_ids).and_yield(@broker_id, request, @header).once
+          result = flexmock("result")
+          @dispatcher.should_receive(:dispatch).with(request).and_return(result).once
+          @broker.should_receive(:publish).with(hsh(:name => "response"), result,
+                                                hsh(:persistent => true, :mandatory => true)).once
           @agent.run
         end
       end
 
-      it "should notify sender when a message is received" do
+      it "should not publish result from dispatched request if there is none" do
         run_in_em do
-          result = RightScale::Result.new("token", "to", "results", "from")
+          request = RightScale::Request.new("/foo/bar", "payload")
           @broker.should_receive(:subscribe).with(hsh(:name => @identity), nil, Hash, Proc).
-                                             and_return(@broker_ids).and_yield(@broker_id, result, @header).once
-          @sender.should_receive(:handle_response).with(result, @header).once
-          @sender.should_receive(:message_received).once
+                                             and_return(@broker_ids).and_yield(@broker_id, request, @header).once
+          @dispatcher.should_receive(:dispatch).with(request).and_return(nil).once
+          @broker.should_receive(:publish).never
           @agent.run
         end
       end
 
-      it "should ignore and ack unrecognized messages" do
+      it "should ignore dispatcher duplicate request errors" do
         run_in_em do
-          request = RightScale::Stats.new(nil, nil)
+          request = RightScale::Request.new("/foo/bar", "payload")
           @broker.should_receive(:subscribe).with(hsh(:name => @identity), nil, Hash, Proc).
                                              and_return(@broker_ids).and_yield(@broker_id, request, @header).once
-          @dispatcher.should_receive(:dispatch).never
-          @header.should_receive(:ack).once
+          @dispatcher.should_receive(:dispatch).and_raise(RightScale::Dispatcher::DuplicateRequest).once
           @agent.run
         end
       end
 
-      it "should ignore unrecognized messages and not attempt to ack if there is no header" do
+      it "should use sender to handle results" do
         run_in_em do
-          request = RightScale::Stats.new(nil, nil)
+          result = RightScale::Result.new("token", "to", "results", "from")
           @broker.should_receive(:subscribe).with(hsh(:name => @identity), nil, Hash, Proc).
-                                             and_return(@broker_ids).and_yield(@broker_id, request, nil).once
-          @dispatcher.should_receive(:dispatch).never
-          @agent.run
-        end
-      end
-
-    end
-
-    describe "Tuning heartbeat" do
-
-      it "should tune heartbeat for all broker connections" do
-        run_in_em do
-          @log.should_receive(:info).with(/\[start\] Agent #{@identity} starting; time: .*$/).once
-          @log.should_receive(:info).with(/Reconnecting each broker to tune heartbeat to 45/).once
-          @log.should_receive(:info).with(/Tuned heartbeat to 45 seconds for broker/).twice
-          @agent = RightScale::Agent.new(:user => "me", :identity => @identity)
-          flexmock(@agent).should_receive(:load_actors).and_return(true)
-          flexmock(@agent).should_receive(:update_configuration).with(:heartbeat => 45).and_return(true).once
-          @agent.run
-          @broker.should_receive(:heartbeat=).with(45).once
-          @broker.should_receive(:connect).with("123", 1, 0, 0, true, Proc).and_yield(@broker_id).once
-          @broker.should_receive(:connect).with("123", 2, 1, 1, true, Proc).and_yield(@broker_id2).once
-          flexmock(@agent).should_receive(:setup_queues).with([@broker_id]).once
-          flexmock(@agent).should_receive(:setup_queues).with([@broker_id2]).once
-          @agent.tune_heartbeat(45).should be_nil
-        end
-      end
-
-      it "should tune heartbeat for all broker connections as deferred task" do
-        run_in_em do
-          @log.should_receive(:info).with(/\[start\] Agent #{@identity} starting; time: .*$/).once
-          @log.should_receive(:info).with(/Reconnecting each broker to tune heartbeat to 45/).once
-          @log.should_receive(:info).with(/Tuned heartbeat to 45 seconds for broker/).twice
-          @agent = RightScale::Agent.new(:user => "me", :identity => @identity)
-          flexmock(@agent).should_receive(:load_actors).and_return(true)
-          flexmock(@agent).should_receive(:update_configuration).with(:heartbeat => 45).and_return(true).once
-          @agent.run
-          @broker.should_receive(:heartbeat=).with(45).once
-          @broker.should_receive(:connect).with("123", 1, 0, 0, true, Proc).and_yield(@broker_id).once
-          @broker.should_receive(:connect).with("123", 2, 1, 1, true, Proc).and_yield(@broker_id2).once
-          flexmock(@agent).should_receive(:setup_queues).with([@broker_id]).once
-          flexmock(@agent).should_receive(:setup_queues).with([@broker_id2]).once
-          flexmock(@agent).should_receive(:finish_setup)
-          @agent.defer_task { @agent.tune_heartbeat(45).should be_nil }
-          @agent.__send__(:check_status)
-          @agent.instance_variable_get(:@deferred_tasks).should == []
-        end
-      end
-
-      it "should disable heartbeat for all broker connections" do
-        run_in_em do
-          @log.should_receive(:info).with(/\[start\] Agent #{@identity} starting; time: .*$/).once
-          @log.should_receive(:info).with(/Reconnecting each broker to tune heartbeat to 0/).once
-          @log.should_receive(:info).with(/Disabled heartbeat for broker/).twice
-          @agent = RightScale::Agent.new(:user => "me", :identity => @identity)
-          flexmock(@agent).should_receive(:load_actors).and_return(true)
-          flexmock(@agent).should_receive(:update_configuration).with(:heartbeat => 0).and_return(true).once
+                                             and_return(@broker_ids).and_yield(@broker_id, result, @header).once
+          @sender.should_receive(:handle_response).with(result).once
           @agent.run
-          @broker.should_receive(:heartbeat=).with(0).once
-          @broker.should_receive(:connect).with("123", 1, 0, 0, true, Proc).and_yield(@broker_id).once
-          @broker.should_receive(:connect).with("123", 2, 1, 1, true, Proc).and_yield(@broker_id2).once
-          flexmock(@agent).should_receive(:setup_queues).with([@broker_id]).once
-          flexmock(@agent).should_receive(:setup_queues).with([@broker_id2]).once
-          @agent.tune_heartbeat(0).should be_nil
         end
       end
 
-      it "should log error if any broker connect attempts fail" do
+      it "should notify sender when a message is received" do
         run_in_em do
-          @log.should_receive(:info).with(/\[start\] Agent #{@identity} starting; time: .*$/).once
-          @log.should_receive(:info).with(/Reconnecting each broker to tune heartbeat to 45/).once
-          @log.should_receive(:info).with(/Tuned heartbeat to 45 seconds for broker #{@broker_id2}/).once
-          @log.should_receive(:error).with("Failed to reconnect to broker #{@broker_id} to tune heartbeat", Exception, :trace).once
-          @agent = RightScale::Agent.new(:user => "me", :identity => @identity)
-          flexmock(@agent).should_receive(:load_actors).and_return(true)
-          flexmock(@agent).should_receive(:update_configuration).with(:heartbeat => 45).and_return(true).once
+          result = RightScale::Result.new("token", "to", "results", "from")
+          @broker.should_receive(:subscribe).with(hsh(:name => @identity), nil, Hash, Proc).
+                                             and_return(@broker_ids).and_yield(@broker_id, result, @header).once
+          @sender.should_receive(:handle_response).with(result).once
+          @sender.should_receive(:message_received).once
           @agent.run
-          @broker.should_receive(:heartbeat=).with(45).once
-          @broker.should_receive(:connect).with("123", 1, 0, 0, true, Proc).and_raise(Exception).once
-          @broker.should_receive(:connect).with("123", 2, 1, 1, true, Proc).and_yield(@broker_id2).once
-          flexmock(@agent).should_receive(:setup_queues).with([@broker_id]).never
-          flexmock(@agent).should_receive(:setup_queues).with([@broker_id2]).once
-          @agent.tune_heartbeat(45).should == "Failed to tune heartbeat for brokers [\"#{@broker_id}\"]"
         end
       end
 
-      it "should log error if any brokers do not connect" do
+      it "should ignore and ack unrecognized messages" do
         run_in_em do
-          @log.should_receive(:info).with(/\[start\] Agent #{@identity} starting; time: .*$/).once
-          @log.should_receive(:info).with(/Reconnecting each broker to tune heartbeat to 45/).once
-          @log.should_receive(:info).with(/Tuned heartbeat to 45 seconds for broker #{@broker_id2}/).once
-          @log.should_receive(:error).with(/Failed to reconnect to broker #{@broker_id} to tune heartbeat, status/).once
-          @agent = RightScale::Agent.new(:user => "me", :identity => @identity)
-          flexmock(@agent).should_receive(:load_actors).and_return(true)
-          flexmock(@agent).should_receive(:update_configuration).with(:heartbeat => 45).and_return(true).once
+          request = RightScale::Stats.new(nil, nil)
+          @broker.should_receive(:subscribe).with(hsh(:name => @identity), nil, Hash, Proc).
+                                             and_return(@broker_ids).and_yield(@broker_id, request, @header).once
+          @dispatcher.should_receive(:dispatch).never
+          @header.should_receive(:ack).once
           @agent.run
-          @broker.should_receive(:heartbeat=).with(45).once
-          @broker.should_receive(:connect).with("123", 1, 0, 0, true, Proc).and_yield(@broker_id).once
-          @broker.should_receive(:connect).with("123", 2, 1, 1, true, Proc).and_yield(@broker_id2).once
-          @broker.should_receive(:connection_status).with({:one_off => 60, :brokers => [@broker_id]}, Proc).and_yield(:failed)
-          @broker.should_receive(:connection_status).with({:one_off => 60, :brokers => [@broker_id2]}, Proc).and_yield(:connected)
-          flexmock(@agent).should_receive(:setup_queues).with([@broker_id]).never
-          flexmock(@agent).should_receive(:setup_queues).with([@broker_id2]).once
-          @agent.tune_heartbeat(45).should be_nil
         end
       end
 
-      it "should log error if any broker queue setup fails" do
+      it "should ack if request dispatch fails" do
         run_in_em do
-          @log.should_receive(:info).with(/\[start\] Agent #{@identity} starting; time: .*$/).once
-          @log.should_receive(:info).with(/Reconnecting each broker to tune heartbeat to 45/).once
-          @log.should_receive(:info).with(/Tuned heartbeat to 45 seconds for broker #{@broker_id2}/).once
-          @log.should_receive(:error).with(/Failed to setup queues for broker #{@broker_id} when tuning heartbeat/, Exception, :trace).once
-          @agent = RightScale::Agent.new(:user => "me", :identity => @identity)
-          flexmock(@agent).should_receive(:load_actors).and_return(true)
-          flexmock(@agent).should_receive(:update_configuration).with(:heartbeat => 45).and_return(true).once
+          request = RightScale::Request.new("/foo/bar", "payload")
+          @log.should_receive(:error).with(/Failed to dispatch request/, Exception, :trace).once
+          @broker.should_receive(:subscribe).with(hsh(:name => @identity), nil, Hash, Proc).
+                                             and_return(@broker_ids).and_yield(@broker_id, request, @header).once
+          @dispatcher.should_receive(:dispatch).and_raise(Exception)
+          @header.should_receive(:ack).once
           @agent.run
-          @broker.should_receive(:heartbeat=).with(45).once
-          @broker.should_receive(:connect).with("123", 1, 0, 0, true, Proc).and_yield(@broker_id).once
-          @broker.should_receive(:connect).with("123", 2, 1, 1, true, Proc).and_yield(@broker_id2).once
-          flexmock(@agent).should_receive(:setup_queues).with([@broker_id]).and_raise(Exception)
-          flexmock(@agent).should_receive(:setup_queues).with([@broker_id2]).once
-          @agent.tune_heartbeat(45).should be_nil
         end
       end
 
-      it "should log error if an exception is raised" do
+      it "should ack if response delivery fails" do
         run_in_em do
-          @log.should_receive(:error).with(/Failed tuning broker connection heartbeat/, Exception, :trace).once
-          @agent = RightScale::Agent.new(:user => "me", :identity => @identity)
-          flexmock(@agent).should_receive(:load_actors).and_return(true)
-          flexmock(@agent).should_receive(:update_configuration).with(:heartbeat => 45).and_raise(Exception).once
+          result = RightScale::Result.new("token", "to", "results", "from")
+          @log.should_receive(:error).with(/Failed to deliver response/, Exception, :trace).once
+          @broker.should_receive(:subscribe).with(hsh(:name => @identity), nil, Hash, Proc).
+                                             and_return(@broker_ids).and_yield(@broker_id, result, @header).once
+          @sender.should_receive(:handle_response).and_raise(Exception)
+          @header.should_receive(:ack).once
           @agent.run
-          @broker.should_receive(:heartbeat=).with(45).once
-          @agent.tune_heartbeat(45).should =~ /Failed tuning broker connection heartbeat/
         end
       end
 
@@ -651,33 +560,8 @@ describe RightScale::Agent do
         end
       end
 
-      it "should wait to terminate if there are recent dispatches" do
-        @sender.should_receive(:terminate).and_return([0, 20]).once
-        @dispatcher.should_receive(:dispatch_age).and_return(20).and_return(@timer).once
-        flexmock(EM::Timer).should_receive(:new).with(10, Proc).once
-        run_in_em do
-          @agent = RightScale::Agent.new(:user => "me", :identity => @identity)
-          flexmock(@agent).should_receive(:load_actors).and_return(true)
-          @agent.run
-          @agent.terminate
-        end
-      end
-
-      it "should wait to terminate if there are recent unfinished requests or recent dispatches" do
-        @sender.should_receive(:terminate).and_return([1, 21]).once
-        @dispatcher.should_receive(:dispatch_age).and_return(22).once
-        flexmock(EM::Timer).should_receive(:new).with(9, Proc).and_return(@timer).once
-        run_in_em do
-          @agent = RightScale::Agent.new(:user => "me", :identity => @identity)
-          flexmock(@agent).should_receive(:load_actors).and_return(true)
-          @agent.run
-          @agent.terminate
-        end
-      end
-
       it "should log that terminating and then log the reason for waiting to terminate" do
         @sender.should_receive(:terminate).and_return([1, 21]).once
-        @dispatcher.should_receive(:dispatch_age).and_return(22).once
         flexmock(EM::Timer).should_receive(:new).with(9, Proc).and_return(@timer).once
         run_in_em do
           @agent = RightScale::Agent.new(:user => "me", :identity => @identity)
@@ -691,7 +575,6 @@ describe RightScale::Agent do
 
       it "should not log reason for waiting to terminate if no need to wait" do
         @sender.should_receive(:terminate).and_return([0, nil]).twice
-        @dispatcher.should_receive(:dispatch_age).and_return(nil).once
         @broker.should_receive(:close).once
         flexmock(EM::Timer).should_receive(:new).with(0, Proc).never
         run_in_em do
@@ -707,7 +590,6 @@ describe RightScale::Agent do
       it "should continue with termination after waiting and log that continuing" do
         @sender.should_receive(:terminate).and_return([1, 10]).twice
         @sender.should_receive(:dump_requests).and_return(["request"]).once
-        @dispatcher.should_receive(:dispatch_age).and_return(10).once
         @broker.should_receive(:close).once
         flexmock(EM::Timer).should_receive(:new).with(20, Proc).and_return(@timer).and_yield.once
         run_in_em do
@@ -725,7 +607,6 @@ describe RightScale::Agent do
       it "should execute block after all brokers have been closed" do
         @sender.should_receive(:terminate).and_return([1, 10]).twice
         @sender.should_receive(:dump_requests).and_return(["request"]).once
-        @dispatcher.should_receive(:dispatch_age).and_return(10).once
         @broker.should_receive(:close).and_yield.once
         flexmock(EM::Timer).should_receive(:new).with(20, Proc).and_return(@timer).and_yield.once
         run_in_em do
@@ -741,7 +622,6 @@ describe RightScale::Agent do
       it "should stop EM if no block specified" do
         @sender.should_receive(:terminate).and_return([1, 10]).twice
         @sender.should_receive(:dump_requests).and_return(["request"]).once
-        @dispatcher.should_receive(:dispatch_age).and_return(10).once
         @broker.should_receive(:close).and_yield.once
         flexmock(EM::Timer).should_receive(:new).with(20, Proc).and_return(@timer).and_yield.once
         run_in_em(stop_event_loop = false) do
@@ -762,7 +642,6 @@ describe RightScale::Agent do
 
       it "should terminate immediately if called a second time but should still execute block" do
         @sender.should_receive(:terminate).and_return([1, 10]).once
-        @dispatcher.should_receive(:dispatch_age).and_return(10).once
         flexmock(EM::Timer).should_receive(:new).with(20, Proc).and_return(@timer).once
         @timer.should_receive(:cancel).once
         @periodic_timer.should_receive(:cancel).once

data/spec/dispatched_cache_spec.rb

@@ -54,43 +54,37 @@ describe "RightScale::DispatchedCache" do
   context "store" do
 
     it "should store request token" do
-      @cache.store(@token1, nil)
+      @cache.store(@token1)
       @cache.instance_variable_get(:@cache)[@token1].should == @now.to_i
       @cache.instance_variable_get(:@lru).should == [@token1]
     end
 
     it "should update lru list when store to existing entry" do
-      @cache.store(@token1, nil)
+      @cache.store(@token1)
       @cache.instance_variable_get(:@cache)[@token1].should == @now.to_i
       @cache.instance_variable_get(:@lru).should == [@token1]
-      @cache.store(@token2, nil)
+      @cache.store(@token2)
       @cache.instance_variable_get(:@cache)[@token2].should == @now.to_i
       @cache.instance_variable_get(:@lru).should == [@token1, @token2]
       flexmock(Time).should_receive(:now).and_return(@now += 10)
-      @cache.store(@token1, nil)
+      @cache.store(@token1)
       @cache.instance_variable_get(:@cache)[@token1].should == @now.to_i
       @cache.instance_variable_get(:@lru).should == [@token2, @token1]
     end
 
     it "should remove old cache entries when store new one" do
-      @cache.store(@token1, nil)
-      @cache.store(@token2, nil)
+      @cache.store(@token1)
+      @cache.store(@token2)
       @cache.instance_variable_get(:@cache).keys.should =~ [@token1, @token2]
       @cache.instance_variable_get(:@lru).should == [@token1, @token2]
       flexmock(Time).should_receive(:now).and_return(@now += RightScale::DispatchedCache::MAX_AGE + 1)
-      @cache.store(@token3, nil)
+      @cache.store(@token3)
       @cache.instance_variable_get(:@cache).keys.should == [@token3]
       @cache.instance_variable_get(:@lru).should == [@token3]
     end
 
-    it "should not store anything if this is a shared queue request" do
-      @cache.store(@token1, "shared")
-      @cache.instance_variable_get(:@cache)[@token1].should be_nil
-      @cache.instance_variable_get(:@lru).should be_empty
-    end
-
     it "should not store anything if token is nil" do
-      @cache.store(nil, nil)
+      @cache.store(nil)
       @cache.instance_variable_get(:@cache).should be_empty
       @cache.instance_variable_get(:@lru).should be_empty
     end
@@ -100,8 +94,8 @@ describe "RightScale::DispatchedCache" do
   context "serviced_by" do
 
     it "should return who request was serviced by and make it the most recently used" do
-      @cache.store(@token1, nil)
-      @cache.store(@token2, nil)
+      @cache.store(@token1)
+      @cache.store(@token2)
       @cache.instance_variable_get(:@lru).should == [@token1, @token2]
       @cache.serviced_by(@token1).should == @agent_id
       @cache.instance_variable_get(:@lru).should == [@token2, @token1]
@@ -109,7 +103,7 @@ describe "RightScale::DispatchedCache" do
 
     it "should return nil if request was not previously serviced" do
       @cache.serviced_by(@token1).should be_nil
-      @cache.store(@token1, nil)
+      @cache.store(@token1)
       @cache.serviced_by(@token1).should == @agent_id
       @cache.serviced_by(@token2).should be_nil
     end
@@ -123,9 +117,9 @@ describe "RightScale::DispatchedCache" do
     end
 
     it "should return total and max age" do
-      @cache.store(@token1, nil)
+      @cache.store(@token1)
       flexmock(Time).should_receive(:now).and_return(@now += 10)
-      @cache.store(@token2, nil)
+      @cache.store(@token2)
       @cache.stats.should == {
         "local total" => 2,
         "local max age" => "10 sec"