right_agent 2.0.8-x86-mingw32 → 2.1.0-x86-mingw32

data/spec/http_exceptions_spec.rb

@@ -0,0 +1,106 @@
+#--
+# Copyright (c) 2013 RightScale, Inc, All Rights Reserved Worldwide.
+#
+# THIS PROGRAM IS CONFIDENTIAL AND PROPRIETARY TO RIGHTSCALE
+# AND CONSTITUTES A VALUABLE TRADE SECRET.  Any unauthorized use,
+# reproduction, modification, or disclosure of this program is
+# strictly prohibited.  Any use of this program by an authorized
+# licensee is strictly subject to the terms and conditions,
+# including confidentiality obligations, set forth in the applicable
+# License Agreement between RightScale.com, Inc. and
+# the licensee.
+#++
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'right_agent', 'http_exceptions'))
+
+describe RightScale::HttpException do
+
+  class HttpTest < RightScale::HttpException; end
+
+  before(:each) do
+    @exception = HttpTest.new(999, "failed")
+  end
+
+  context :initialize do
+    it "stores HTTP code and body" do
+      @exception.http_code.should == 999
+      @exception.http_body.should == "failed"
+    end
+
+    it "allows generic description to be set" do
+      @exception.message = "Test"
+      @exception.to_s.should == "Test: failed"
+    end
+  end
+
+  context :inspect do
+    it "displays generic description and detailed message" do
+      @exception.inspect.should == "HttpTest: failed"
+    end
+  end
+
+  context :to_s do
+    it "inspects the exception" do
+      @exception.inspect.should == "HttpTest: failed"
+    end
+  end
+
+  context :message do
+    it "returns generic description" do
+      @exception.message = "Test"
+      @exception.message.should == "Test"
+    end
+
+    it "defaults to class name" do
+      @exception.message.should == "HttpTest"
+    end
+  end
+
+end # RightScale::HttpException
+
+describe RightScale::HttpExceptions do
+
+  before(:each) do
+    @header = {:location => "here"}
+  end
+
+  it "initializes list of standard HTTP exceptions" do
+    RightScale::HttpExceptions::HTTP_EXCEPTIONS_MAP.size.should > 50
+    RightScale::HttpExceptions::HTTP_EXCEPTIONS_MAP[400].should == RightScale::HttpExceptions::BadRequest
+  end
+
+  context :create do
+    it "creates instance of standard exception" do
+      e = RightScale::HttpExceptions.create(500, "failed")
+      e.class.should == RightScale::HttpExceptions::InternalServerError
+      e.response.headers.should == {}
+    end
+
+    it "creates exception whose message is the generic description" do
+      e = RightScale::HttpExceptions.create(500, "failed")
+      e.message.should == "500 Internal Server Error"
+      e.inspect.should == "500 Internal Server Error: failed"
+    end
+
+    it "creates RequestFailed exception if the HTTP code is not recognized" do
+      e = RightScale::HttpExceptions.create(999, "failed")
+      e.class.should == RightScale::HttpExceptions::RequestFailed
+      e.message.should == "HTTP status code 999"
+      e.inspect.should == "HTTP status code 999: failed"
+    end
+
+    it "puts header into a Response and stores in exception" do
+      e = RightScale::HttpExceptions.create(500, "failed", @header)
+      e.response.headers.should == {:location => "here"}
+    end
+  end
+
+  context :convert do
+    it "converts RestClient exception to HttpException" do
+      bad_request = RestClient::Exceptions::EXCEPTIONS_MAP[400].new(nil, 400)
+      RightScale::HttpExceptions.convert(bad_request).should be_a RightScale::HttpExceptions::BadRequest
+    end
+  end
+
+end # RightScale::HttpExceptions

data/spec/retryable_request_spec.rb

@@ -102,8 +102,8 @@ describe RightScale::RetryableRequest do
         request = RightScale::RetryableRequest.new('type', 'payload', :retry_on_error => true)
         flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).
             and_yield(RightScale::OperationResult.error('test')).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).once
         flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).once
         request.run
       end
 
@@ -114,8 +114,8 @@ describe RightScale::RetryableRequest do
         end
         flexmock(request).should_receive(:fail).never
         flexmock(request).should_receive(:succeed).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).never
         flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).never
         request.run
       end
 
@@ -124,8 +124,8 @@ describe RightScale::RetryableRequest do
         flexmock(RightScale::Log).should_receive(:info).with("Request type canceled (enough already)").once
         flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).
             and_yield(RightScale::OperationResult.cancel('enough already')).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).never
         flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).never
         request.run
       end
     end
@@ -141,8 +141,8 @@ describe RightScale::RetryableRequest do
         flexmock(RightScale::Log).should_receive(:info).with("Request non-delivery (test) for type").once
         flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).
             and_yield(RightScale::OperationResult.non_delivery('test')).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).once
         flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).once
         request.run
       end
 
@@ -152,8 +152,8 @@ describe RightScale::RetryableRequest do
         flexmock(RightScale::Log).should_receive(:info).with("Request type failed (test) and should be retried").once
         flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).
             and_yield(RightScale::OperationResult.retry('test')).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).once
         flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).once
         request.run
       end
 
@@ -163,8 +163,8 @@ describe RightScale::RetryableRequest do
         flexmock(RightScale::Log).should_receive(:info).with("Request type failed (RightScale not ready) and should be retried").once
         flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).
             and_yield(RightScale::OperationResult.retry).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).once
         flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).once
         request.run
       end
 
@@ -174,8 +174,8 @@ describe RightScale::RetryableRequest do
             and_yield(RightScale::OperationResult.success('test')).once
         flexmock(request).should_receive(:fail).once
         flexmock(request).should_receive(:succeed).never
-        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).never
         flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).never
         request.cancel('test')
         request.run
       end
@@ -185,8 +185,8 @@ describe RightScale::RetryableRequest do
         flexmock(RightScale::Log).should_receive(:info).with("Request type canceled (enough already)").once
         flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).
             and_yield(RightScale::OperationResult.cancel('enough already')).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).never
         flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).never
         request.run
       end
     end
@@ -197,8 +197,8 @@ describe RightScale::RetryableRequest do
         request = RightScale::RetryableRequest.new('type', 'payload', :retry_delay => retry_delay)
         flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).
             and_yield(RightScale::OperationResult.retry('test')).once
-        flexmock(EM).should_receive(:add_timer).with(retry_delay, Proc).once
         flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(retry_delay, Proc).once
         flexmock(EM).should_receive(:next_tick).never
         request.run
       end
@@ -208,8 +208,8 @@ describe RightScale::RetryableRequest do
         request = RightScale::RetryableRequest.new('type', 'payload', :retry_delay => retry_delay)
         flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).
             and_yield(RightScale::OperationResult.retry('test')).once
-        flexmock(EM).should_receive(:add_timer).with(retry_delay, Proc).never
         flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(retry_delay, Proc).never
         flexmock(EM).should_receive(:next_tick).once
         request.run
       end
@@ -224,9 +224,9 @@ describe RightScale::RetryableRequest do
                                                     :retry_delay_count => retry_delay_count)
         flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).
             and_yield(RightScale::OperationResult.retry('test')).twice
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
         flexmock(EM).should_receive(:add_timer).with(retry_delay, Proc).and_yield.once
         flexmock(EM).should_receive(:add_timer).with(retry_delay * backoff_factor, Proc).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
         flexmock(EM).should_receive(:next_tick).never
         request.run
       end
@@ -241,10 +241,10 @@ describe RightScale::RetryableRequest do
                                                     :max_retry_delay => max_retry_delay)
         flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).
             and_yield(RightScale::OperationResult.retry('test')).times(4)
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
         flexmock(EM).should_receive(:add_timer).with(retry_delay, Proc).and_yield.twice
         flexmock(EM).should_receive(:add_timer).with(retry_delay * backoff_factor, Proc).and_yield.once
         flexmock(EM).should_receive(:add_timer).with(max_retry_delay, Proc).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
         flexmock(EM).should_receive(:next_tick).never
         request.run
         request.instance_variable_get(:@retry_delay_count).should == retry_delay_count / 2
@@ -262,10 +262,10 @@ describe RightScale::RetryableRequest do
                                                     :max_retry_delay => max_retry_delay)
         flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).
             and_yield(RightScale::OperationResult.retry('test')).times(3)
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
         flexmock(EM).should_receive(:add_timer).with(retry_delay, Proc).and_yield.once
         flexmock(EM).should_receive(:add_timer).with(retry_delay * backoff_factor, Proc).and_yield.once
         flexmock(EM).should_receive(:add_timer).with(max_retry_delay, Proc).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
         flexmock(EM).should_receive(:next_tick).never
         request.run
       end

data/spec/sender_spec.rb

@@ -671,9 +671,47 @@ describe RightScale::Sender do
           @sender.send(:http_send, :send_push, @target, @packet, @received_at, @callback).should be_true
         end
 
+        context "when :async_response enabled" do
+          before(:each) do
+            @sender = create_sender(:http, :async_response => true)
+            flexmock(EM).should_receive(:next_tick).and_yield.once
+          end
+
+          it "sends in next_tick if :async_response option set" do
+            @packet = @sender.build_packet(:send_push, @type, @payload, @target, @token, @callback)
+            @client.should_receive(:push).with(@type, @payload, @target, @token).and_return(nil).once
+            @sender.send(:http_send, :send_push, @target, @packet, @received_at, @callback).should be_true
+          end
+
+          it "logs unexpected exception" do
+            flexmock(@sender).should_receive(:handle_response).and_raise(RuntimeError).once
+            @log.should_receive(:error).with(/Failed sending or handling response/, RuntimeError, :trace).once
+            @packet = @sender.build_packet(:send_request, @type, @payload, @target, @token, @callback)
+            @client.should_receive(:request).with(@type, @payload, @target, @token).and_return("result").once
+            @sender.send(:http_send, :send_request, @target, @packet, @received_at, @callback).should be_true
+          end
+        end
+      end
+
+      context :http_send_once do
+        before(:each) do
+          @received_at = Time.now
+          flexmock(Time).should_receive(:now).and_return(@received_at)
+          flexmock(RightSupport::Data::UUID).should_receive(:generate).and_return(@token).by_default
+          @packet = @sender.build_packet(:send_request, @type, @payload, @target, @token, @callback)
+          @response = nil
+          @callback = lambda { |response| @response = response }
+        end
+
+        it "sends request using configured client" do
+          @packet = @sender.build_packet(:send_push, @type, @payload, @target, @token, @callback)
+          @client.should_receive(:push).with(@type, @payload, @target, @token).and_return(nil).once
+          @sender.send(:http_send_once, :send_push, @target, @packet, @received_at, @callback).should be_true
+        end
+
         it "responds with success result containing response" do
           @client.should_receive(:request).with(@type, @payload, @target, @token).and_return("result").once
-          @sender.send(:http_send, :send_request, @target, @packet, @received_at, @callback).should be_true
+          @sender.send(:http_send_once, :send_request, @target, @packet, @received_at, @callback).should be_true
           @response.token.should == @token
           @response.results.success?.should be_true
           @response.results.content.should == "result"
@@ -683,19 +721,7 @@ describe RightScale::Sender do
 
         it "responds with success result when response is nil" do
           @client.should_receive(:request).with(@type, @payload, @target, @token).and_return(nil).once
-          @sender.send(:http_send, :send_request, @target, @packet, @received_at, @callback).should be_true
-          @response.token.should == @token
-          @response.results.success?.should be_true
-          @response.results.content.should be_nil
-          @response.from.should == @target
-          @response.received_at.should == @received_at.to_f
-        end
-
-        it "responds asynchronously if requested" do
-          @sender = create_sender(:http, :async_response => true)
-          flexmock(EM).should_receive(:next_tick).and_yield.once
-          @client.should_receive(:request).with(@type, @payload, @target, @token).and_return(nil).once
-          @sender.send(:http_send, :send_request, @target, @packet, @received_at, @callback).should be_true
+          @sender.send(:http_send_once, :send_request, @target, @packet, @received_at, @callback).should be_true
           @response.token.should == @token
           @response.results.success?.should be_true
           @response.results.content.should be_nil
@@ -713,12 +739,12 @@ describe RightScale::Sender do
               flexmock(@sender.offline_handler).should_receive(:queue_request).with(:send_request, @type,
                   @payload, @target, @callback).once
               flexmock(@sender).should_receive(:handle_response).never
-              @sender.send(:http_send, :send_request, @target, @packet, @received_at, @callback).should be_true
+              @sender.send(:http_send_once, :send_request, @target, @packet, @received_at, @callback).should be_true
             end
 
             it "responds with retry result if not queueing" do
               @client.should_receive(:request).and_raise(RightScale::Exceptions::ConnectivityFailure, "Server not responding").once
-              @sender.send(:http_send, :send_request, @target, @packet, @received_at, @callback).should be_true
+              @sender.send(:http_send_once, :send_request, @target, @packet, @received_at, @callback).should be_true
               @response.results.retry?.should be_true
               @response.results.content.should == "Server not responding"
             end
@@ -726,14 +752,14 @@ describe RightScale::Sender do
 
           it "responds with retry result if retryable error" do
             @client.should_receive(:request).and_raise(RightScale::Exceptions::RetryableError, "try again").once
-            @sender.send(:http_send, :send_request, @target, @packet, @received_at, @callback).should be_true
+            @sender.send(:http_send_once, :send_request, @target, @packet, @received_at, @callback).should be_true
             @response.results.retry?.should be_true
             @response.results.content.should == "try again"
           end
 
           it "responds with error result if internal error" do
             @client.should_receive(:request).and_raise(RightScale::Exceptions::InternalServerError.new("unprocessable", "Router")).once
-            @sender.send(:http_send, :send_request, @target, @packet, @received_at, @callback).should be_true
+            @sender.send(:http_send_once, :send_request, @target, @packet, @received_at, @callback).should be_true
             @response.results.error?.should be_true
             @response.results.content.should == "Router internal error"
           end
@@ -741,12 +767,12 @@ describe RightScale::Sender do
           it "does not respond to request if terminating" do
             @client.should_receive(:request).and_raise(RightScale::Exceptions::Terminating, "going down").once
             flexmock(@sender).should_receive(:handle_response).never
-            @sender.send(:http_send, :send_request, @target, @packet, @received_at, @callback).should be_true
+            @sender.send(:http_send_once, :send_request, @target, @packet, @received_at, @callback).should be_true
           end
 
           it "responds with error result if HTTP error" do
-            @client.should_receive(:request).and_raise(RestExceptionMock.new(400, "bad data")).once
-            @sender.send(:http_send, :send_request, @target, @packet, @received_at, @callback).should be_true
+            @client.should_receive(:request).and_raise(RightScale::HttpExceptions.create(400, "bad data")).once
+            @sender.send(:http_send_once, :send_request, @target, @packet, @received_at, @callback).should be_true
             @response.results.error?.should be_true
             @response.results.content.should == "400 Bad Request: bad data"
           end
@@ -754,7 +780,7 @@ describe RightScale::Sender do
           it "responds with error result if unexpected error" do
             @log.should_receive(:error).with(/Failed to send/, StandardError, :trace).once
             @client.should_receive(:request).and_raise(StandardError, "unexpected").once
-            @sender.send(:http_send, :send_request, @target, @packet, @received_at, @callback).should be_true
+            @sender.send(:http_send_once, :send_request, @target, @packet, @received_at, @callback).should be_true
             @response.results.error?.should be_true
             @response.results.content.should == "Agent agent internal error"
           end

data/spec/spec_helper.rb

@@ -75,32 +75,6 @@ module RightScale
 
 end
 
-# Mock RestClient exceptions since cannot create directly without a
-# RestClient::Response, but need RestClient interface for error reporting
-class RestExceptionMock < RestClient::Exception
-  class Response
-    attr_reader :headers
-
-    def initialize(headers)
-      @headers = headers || {}
-    end
-  end
-
-  attr_accessor :message
-  attr_reader :http_code, :http_body, :response
-
-  def initialize(http_code, http_body = nil, response_headers = nil)
-    @message = "#{http_code} #{RestClient::STATUSES[http_code]}"
-    @http_code = http_code
-    @http_body = http_body
-    @response = Response.new(response_headers)
-  end
-
-  def inspect
-    "#{@message}: #{@http_body}"
-  end
-end
-
 # Functions for setting version per ProtocolVersionMixin
 def version_cannot_put_version_in_packet; RightScale::Packet::DEFAULT_VERSION end
 def version_can_put_version_in_packet; 12 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: right_agent
 version: !ruby/object:Gem::Version
-  version: 2.0.8
+  version: 2.1.0
   prerelease: 
 platform: x86-mingw32
 authors:
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-03 00:00:00.000000000 Z
+date: 2014-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: right_support
@@ -255,6 +255,8 @@ files:
 - lib/right_agent/clients/auth_client.rb
 - lib/right_agent/clients/balanced_http_client.rb
 - lib/right_agent/clients/base_retry_client.rb
+- lib/right_agent/clients/blocking_client.rb
+- lib/right_agent/clients/non_blocking_client.rb
 - lib/right_agent/clients/right_http_client.rb
 - lib/right_agent/clients/router_client.rb
 - lib/right_agent/command.rb
@@ -291,8 +293,10 @@ files:
 - lib/right_agent/dispatched_cache.rb
 - lib/right_agent/dispatcher.rb
 - lib/right_agent/enrollment_result.rb
+- lib/right_agent/eventmachine_spawn.rb
 - lib/right_agent/exceptions.rb
 - lib/right_agent/history.rb
+- lib/right_agent/http_exceptions.rb
 - lib/right_agent/log.rb
 - lib/right_agent/minimal.rb
 - lib/right_agent/monkey_patches.rb
@@ -360,6 +364,8 @@ files:
 - spec/clients/auth_client_spec.rb
 - spec/clients/balanced_http_client_spec.rb
 - spec/clients/base_retry_client_spec.rb
+- spec/clients/blocking_client_spec.rb
+- spec/clients/non_blocking_client_spec.rb
 - spec/clients/router_client_spec.rb
 - spec/clients/spec_helper.rb
 - spec/command/agent_manager_commands_spec.rb
@@ -380,6 +386,7 @@ files:
 - spec/dispatcher_spec.rb
 - spec/enrollment_result_spec.rb
 - spec/history_spec.rb
+- spec/http_exceptions_spec.rb
 - spec/log_spec.rb
 - spec/monkey_patches/eventmachine_spec.rb
 - spec/multiplexer_spec.rb
@@ -437,7 +444,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1395793302884247070
+      hash: -514675308971748709
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.26