right_agent 2.1.5-x86-mingw32 → 2.2.0-x86-mingw32

data/lib/right_agent/sender.rb

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2009-2013 RightScale Inc
+# Copyright (c) 2009-2014 RightScale Inc
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -75,14 +75,14 @@ module RightScale
     #   :offline_queueing(Boolean):: Whether to queue request if client currently disconnected,
     #     also requires agent invocation of initialize_offline_queue and start_offline_queue methods below,
     #     as well as enable_offline_mode and disable_offline_mode as client connection status changes
-    #   :ping_interval(Integer):: Minimum number of seconds since last message receipt to ping RightNet
+    #   :ping_interval(Numeric):: Minimum number of seconds since last message receipt to ping RightNet
     #     to check connectivity, defaults to 0 meaning do not ping
     #   :restart_callback(Proc):: Callback that is activated on each restart vote with votes being initiated
     #     by offline queue exceeding MAX_QUEUED_REQUESTS or by repeated failures to access RightNet when online
     #   :retry_timeout(Numeric):: Maximum number of seconds to retry request before give up
     #   :retry_interval(Numeric):: Number of seconds before initial request retry, increases exponentially
-    #   :time_to_live(Integer):: Number of seconds before a request expires and is to be ignored
-    #     by the receiver, 0 means never expire
+    #   :time_to_live(Numeric):: Number of seconds before a request expires and is to be ignored;
+    #     non-positive value means never expire
     #   :async_response(Boolean):: Whether to handle responses asynchronously or to handle them immediately
     #     upon arrival (for use by applications that were written expecting asynchronous AMQP responses)
     #   :secure(Boolean):: true indicates to use Security features of rabbitmq to restrict agents to themselves
@@ -188,7 +188,10 @@ module RightScale
     #       ones with no shard id
     #   :selector(Symbol):: Which of the matched targets to be selected, either :any or :all,
     #     defaults to :any
-    # token(String|NilClass):: Token uniquely identifying request; defaults to random generated
+    # options(Hash):: Request options
+    #   :token(String):: Universally unique ID for request; defaults to random generated
+    #   :time_to_live(Numeric):: Number of seconds before a request expires and is to be ignored;
+    #     non-positive value or nil means never expire; defaults to 0
     #
     # === Block
     # Optional block used to process routing responses asynchronously with the following parameter:
@@ -205,8 +208,8 @@ module RightScale
     # SendFailure:: If sending of request failed unexpectedly
     # TemporarilyOffline:: If cannot send request because RightNet client currently disconnected
     #   and offline queueing is disabled
-    def send_push(type, payload = nil, target = nil, token = nil, &callback)
-      build_and_send_packet(:send_push, type, payload, target, token, callback)
+    def send_push(type, payload = nil, target = nil, options = {}, &callback)
+      build_and_send_packet(:send_push, type, payload, target, options, &callback)
     end
 
     # Send a request to a single target with a response expected
@@ -231,7 +234,10 @@ module RightScale
     #     :account(Integer):: Restrict to agents with this account id
     #     :shard(Integer):: Restrict to agents with this shard id, or if value is Packet::GLOBAL,
     #       ones with no shard id
-    # token(String|NilClass):: Token uniquely identifying request; defaults to random generated
+    # options(Hash):: Request options
+    #   :token(String):: Universally unique ID for request; defaults to random generated
+    #   :time_to_live(Numeric):: Number of seconds before a request expires and is to be ignored;
+    #     non-positive value or nil means never expire; defaults to configured :time_to_live
     #
     # === Block
     # Required block used to process response asynchronously with the following parameter:
@@ -243,9 +249,9 @@ module RightScale
     #
     # === Raise
     # ArgumentError:: If target invalid or block missing
-    def send_request(type, payload = nil, target = nil, token = nil, &callback)
+    def send_request(type, payload = nil, target = nil, options = {}, &callback)
       raise ArgumentError, "Missing block for response callback" unless callback
-      build_and_send_packet(:send_request, type, payload, target, token, callback)
+      build_and_send_packet(:send_request, type, payload, target, options, &callback)
     end
 
     # Build and send packet
@@ -254,7 +260,7 @@ module RightScale
     # kind(Symbol):: Kind of request: :send_push or :send_request
     # type(String):: Dispatch route for the request; typically identifies actor and action
     # payload(Object):: Data to be sent with marshalling en route
-    # target(Hash|NilClass):: Identity of specific target as string, or hash for selecting targets
+    # target(Hash|NilClass):: Target for request
     #   :agent_id(String):: Identity of specific target
     #   :tags(Array):: Tags that must all be associated with a target for it to be selected
     #   :scope(Hash):: Scoping to be used to restrict routing
@@ -262,20 +268,27 @@ module RightScale
     #     :shard(Integer):: Restrict to agents with this shard id, or if value is Packet::GLOBAL,
     #       ones with no shard id
     #   :selector(Symbol):: Which of the matched targets to be selected: :any or :all
-    # token(String|NilClass):: Token uniquely identifying request; defaults to random generated
-    # callback(Proc|nil):: Block used to process routing response
+    # options(Hash):: Request options
+    #   :token(String):: Universally unique ID for request; defaults to random generated
+    #   :time_to_live(Numeric):: Number of seconds before a request expires and is to be ignored;
+    #     non-positive value or nil means never expire for :send_push and means use configured
+    #     time-to-live for :send_request
+    #
+    # === Block
+    # Optional block used to process response asynchronously with the following parameter:
+    #   result(Result):: Response with an OperationResult of SUCCESS, RETRY, NON_DELIVERY, or ERROR
     #
     # === Return
     # true:: Always return true
     #
     # === Raise
     # ArgumentError:: If target invalid
-    def build_and_send_packet(kind, type, payload, target, token, callback)
-      if (packet = build_packet(kind, type, payload, target, token, callback))
+    def build_and_send_packet(kind, type, payload, target, options = {}, &callback)
+      if (packet = build_packet(kind, type, payload, target, options, &callback))
         action = type.split('/').last
         received_at = @request_stats.update(action, packet.token)
         @request_kind_stats.update((packet.selector == :all ? "fanout" : kind.to_s)[5..-1])
-        send("#{@mode}_send", kind, target, packet, received_at, callback)
+        send("#{@mode}_send", kind, target, packet, received_at, &callback)
       end
       true
     end
@@ -286,7 +299,7 @@ module RightScale
     # kind(Symbol):: Kind of request: :send_push or :send_request
     # type(String):: Dispatch route for the request; typically identifies actor and action
     # payload(Object):: Data to be sent with marshalling en route
-    # target(Hash|NilClass):: Identity of specific target as string, or hash for selecting targets
+    # target(Hash|NilClass):: Target for request
     #   :agent_id(String):: Identity of specific target
     #   :tags(Array):: Tags that must all be associated with a target for it to be selected
     #   :scope(Hash):: Scoping to be used to restrict routing
@@ -294,43 +307,52 @@ module RightScale
     #     :shard(Integer):: Restrict to agents with this shard id, or if value is Packet::GLOBAL,
     #       ones with no shard id
     #   :selector(Symbol):: Which of the matched targets to be selected: :any or :all
-    # token(String|NilClass):: Token uniquely identifying request; defaults to random generated
-    # callback(Boolean):: Whether this request has an associated response callback
+    # options(Hash):: Request options
+    #   :token(String):: Universally unique ID for request; defaults to random generated
+    #   :time_to_live(Numeric):: Number of seconds before a request expires and is to be ignored;
+    #     non-positive value or nil means never expire for :send_push and means use configured
+    #     time-to-live for :send_request
+    #
+    # === Block
+    # Optional block used to process response asynchronously with the following parameter:
+    #   result(Result):: Response with an OperationResult of SUCCESS, RETRY, NON_DELIVERY, or ERROR
     #
     # === Return
     # (Push|Request|NilClass):: Packet created, or nil if queued instead
     #
     # === Raise
     # ArgumentError:: If target is invalid
-    def build_packet(kind, type, payload, target, token, callback = false)
+    def build_packet(kind, type, payload, target, options = {}, &callback)
       validate_target(target, kind == :send_push)
-      if queueing?
-        @offline_handler.queue_request(kind, type, payload, target, callback)
-        nil
+      if kind == :send_push
+        packet = Push.new(type, payload)
+        packet.selector = target[:selector] || :any if target.is_a?(Hash)
+        packet.persistent = true
+        packet.confirm = true if callback
+        time_to_live = options[:time_to_live] || 0
       else
-        if kind == :send_push
-          packet = Push.new(type, payload)
-          packet.selector = target[:selector] || :any if target.is_a?(Hash)
-          packet.persistent = true
-          packet.confirm = true if callback
-        else
-          packet = Request.new(type, payload)
-          ttl = @options[:time_to_live]
-          packet.expires_at = Time.now.to_i + ttl if ttl && ttl != 0
-          packet.selector = :any
-        end
-        packet.from = @identity
-        packet.token = token || RightSupport::Data::UUID.generate
-        if target.is_a?(Hash)
-          if (agent_id = target[:agent_id])
-            packet.target = agent_id
-          else
-            packet.tags = target[:tags] || []
-            packet.scope = target[:scope]
-          end
+        packet = Request.new(type, payload)
+        packet.selector = :any
+        time_to_live = options[:time_to_live] || @options[:time_to_live]
+      end
+      packet.from = @identity
+      packet.token = options[:token] || RightSupport::Data::UUID.generate
+      packet.expires_at = Time.now.to_i + time_to_live if time_to_live && time_to_live > 0
+      if target.is_a?(Hash)
+        if (agent_id = target[:agent_id])
+          packet.target = agent_id
         else
-          packet.target = target
+          packet.tags = target[:tags] || []
+          packet.scope = target[:scope]
         end
+      else
+        packet.target = target
+      end
+
+      if queueing?
+        @offline_handler.queue_request(kind, type, payload, target, packet.token, packet.expires_at, &callback)
+        nil
+      else
         packet
       end
     end
@@ -577,25 +599,28 @@ module RightScale
     #
     # === Parameters
     # kind(Symbol):: Kind of request: :send_push or :send_request
-    # target(Hash|String|nil):: Target for request
+    # target(Hash|NilClass):: Target for request
     # packet(Push|Request):: Request packet to send
     # received_at(Time):: Time when request received
-    # callback(Proc|nil):: Block used to process response
+    #
+    # === Block
+    # Optional block used to process response asynchronously with the following parameter:
+    #   result(Result):: Response with an OperationResult of SUCCESS, RETRY, NON_DELIVERY, or ERROR
     #
     # === Return
     # true:: Always return true
-    def http_send(kind, target, packet, received_at, callback)
+    def http_send(kind, target, packet, received_at, &callback)
       if @options[:async_response]
         EM_S.next_tick do
           begin
-            http_send_once(kind, target, packet, received_at, callback)
+            http_send_once(kind, target, packet, received_at, &callback)
           rescue Exception => e
             Log.error("Failed sending or handling response for #{packet.trace} #{packet.type}", e, :trace)
             @exception_stats.track("request", e)
           end
         end
       else
-        http_send_once(kind, target, packet, received_at, callback)
+        http_send_once(kind, target, packet, received_at, &callback)
       end
       true
     end
@@ -604,22 +629,27 @@ module RightScale
     #
     # === Parameters
     # kind(Symbol):: Kind of request: :send_push or :send_request
-    # target(Hash|String|nil):: Target for request
+    # target(Hash|NilClass):: Target for request
     # packet(Push|Request):: Request packet to send
     # received_at(Time):: Time when request received
-    # callback(Proc|nil):: Block used to process response
+    #
+    # === Block
+    # Optional block used to process response asynchronously with the following parameter:
+    #   result(Result):: Response with an OperationResult of SUCCESS, RETRY, NON_DELIVERY, or ERROR
     #
     # === Return
     # true:: Always return true
-    def http_send_once(kind, target, packet, received_at, callback)
+    def http_send_once(kind, target, packet, received_at, &callback)
       begin
         method = packet.class.name.split("::").last.downcase
-        result = success_result(@agent.client.send(method, packet.type, packet.payload, target, packet.token))
+        options = {:request_uuid => packet.token}
+        options[:time_to_live] = (packet.expires_at - Time.now.to_i) if packet.expires_at > 0
+        result = success_result(@agent.client.send(method, packet.type, packet.payload, target, options))
       rescue Exceptions::Unauthorized => e
         result = error_result(e.message)
       rescue Exceptions::ConnectivityFailure => e
         if queueing?
-          @offline_handler.queue_request(kind, packet.type, packet.payload, target, callback)
+          @offline_handler.queue_request(kind, packet.type, packet.payload, target, packet.token, packet.expires_at, &callback)
           result = nil
         else
           result = retry_result(e.message)
@@ -631,7 +661,7 @@ module RightScale
       rescue Exceptions::Terminating => e
         result = nil
       rescue StandardError => e
-        # These errors are either unexpected errors or RestClient errors with an http_body
+        # These errors are either unexpected errors or HttpExceptions with an http_body
         # giving details about the error that are conveyed in the error_result
         if e.respond_to?(:http_body)
           # No need to log here since any HTTP request errors have already been logged
@@ -658,14 +688,17 @@ module RightScale
     #
     # === Parameters
     # kind(Symbol):: Kind of request: :send_push or :send_request
-    # target(Hash|String|nil):: Target for request
-    # received_at(Time):: Time when request received
+    # target(Hash|NilClass):: Target for request
     # packet(Push|Request):: Request packet to send
-    # callback(Proc|nil):: Block used to process response
+    # received_at(Time):: Time when request received
+    #
+    # === Block
+    # Optional block used to process response asynchronously with the following parameter:
+    #   result(Result):: Response with an OperationResult of SUCCESS, RETRY, NON_DELIVERY, or ERROR
     #
     # === Return
     # true:: Always return true
-    def amqp_send(kind, target, packet, received_at, callback)
+    def amqp_send(kind, target, packet, received_at, &callback)
       begin
         @pending_requests[packet.token] = PendingRequest.new(kind, received_at, callback) if callback
         if packet.class == Request
@@ -676,7 +709,7 @@ module RightScale
       rescue TemporarilyOffline => e
         if queueing?
           # Queue request until come back online
-          @offline_handler.queue_request(kind, packet.type, packet.payload, target, callback)
+          @offline_handler.queue_request(kind, packet.type, packet.payload, target, packet.token, packet.expires_at, &callback)
           @pending_requests.delete(packet.token) if callback
         else
           # Send retry response so that requester, e.g., RetryableRequest, can retry
@@ -751,7 +784,7 @@ module RightScale
             if @pending_requests[parent_token]
               count += 1
               elapsed += interval
-              if elapsed < @retry_timeout
+              if elapsed < @retry_timeout && (packet.expires_at <= 0 || Time.now.to_i < packet.expires_at)
                 packet.tries << packet.token
                 packet.token = RightSupport::Data::UUID.generate
                 @pending_requests[parent_token].retry_parent_token = parent_token if count == 1

data/right_agent.gemspec

@@ -25,8 +25,8 @@ require 'rbconfig'
 
 Gem::Specification.new do |spec|
   spec.name      = 'right_agent'
-  spec.version   = '2.1.5'
-  spec.date      = '2014-04-15'
+  spec.version   = '2.2.0'
+  spec.date      = '2014-05-06'
   spec.authors   = ['Lee Kirchhoff', 'Raphael Simon', 'Tony Spataro', 'Scott Messier']
   spec.email     = 'lee@rightscale.com'
   spec.homepage  = 'https://github.com/rightscale/right_agent'

data/spec/agent_tag_manager_spec.rb

@@ -60,6 +60,14 @@ describe RightScale::AgentTagManager do
       @result.should == [@tag]
     end
 
+    it "applies timeout when retrieving agent tags" do
+      @retryable_request.should_receive(:new).with("/router/query_tags",
+          {:agent_identity => @identity, :hrefs => [@agent_href]}, {:timeout => 30}).and_return(@request).once
+      @request.should_receive(:callback).and_yield({@agent_href => {"tags" => [@tag]}}).once
+      @manager.tags(:timeout => 30) { |r| @result = r }
+      @result.should == [@tag]
+    end
+
     it "retrieves current agent tags using agent ID if not in :http mode" do
       @agent.should_receive(:mode).and_return(:amqp)
       @retryable_request.should_receive(:new).with("/router/query_tags",
@@ -123,6 +131,13 @@ describe RightScale::AgentTagManager do
       @result.should == {@agent_href => {"tags" => @tags}}
     end
 
+    it "applies timeout when querying for agents with tags" do
+      @retryable_request.should_receive(:new).with("/router/query_tags",
+          {:agent_identity => @identity, :tags => [@tag]}, {:timeout => 30}).and_return(@request).once
+      @request.should_receive(:callback).and_yield({@identity => {"tags" => [@tag]}, @agent_href => {"tags" => [@tag]}}).once
+      @manager.query_tags(@tag, :timeout => 30) { |r| @result = r }
+    end
+
     it "forwards options" do
       @retryable_request.should_receive(:new).with("/router/query_tags",
           {:agent_identity => @identity, :tags => @tags}, {:timeout => 9}).and_return(@request).once
@@ -181,6 +196,13 @@ describe RightScale::AgentTagManager do
       @result.should == "raw response"
     end
 
+    it "applies timeout when querying" do
+      @retryable_request.should_receive(:new).with("/router/query_tags",
+          {:agent_identity => @identity, :hrefs => @hrefs, :tags => @tags}, {:timeout => 30}).and_return(@request).once
+      @request.should_receive(:callback).and_yield({@agent_href => {"tags" => @tags}}).once
+      @manager.query_tags_raw(@tags, @hrefs, :timeout => 30) { |r| @result = r }
+    end
+
     it "forwards timeout option" do
       @retryable_request.should_receive(:new).with("/router/query_tags",
           {:agent_identity => @identity, :tags => @tags}, {:timeout => 9}).and_return(@request).once
@@ -199,17 +221,22 @@ describe RightScale::AgentTagManager do
     end
 
     it "adds individual tag to agent" do
-      @retryable_request.should_receive(:new).with("/router/add_tags", {:tags => [@tag]}).and_return(@request).once
+      @retryable_request.should_receive(:new).with("/router/add_tags", {:tags => [@tag]}, {}).and_return(@request).once
       @manager.add_tags(@tag).should be_true
     end
 
     it "adds multiple tags to agent" do
-      @retryable_request.should_receive(:new).with("/router/add_tags", {:tags => @tags}).and_return(@request).once
+      @retryable_request.should_receive(:new).with("/router/add_tags", {:tags => @tags}, {}).and_return(@request).once
       @manager.add_tags(@tags).should be_true
     end
 
+    it "applies timeout when adding tags" do
+      @retryable_request.should_receive(:new).with("/router/add_tags", {:tags => [@tag]}, {:timeout => 30}).and_return(@request).once
+      @manager.add_tags(@tag, :timeout => 30).should be_true
+    end
+
     it "optionally yields raw response" do
-      @retryable_request.should_receive(:new).with("/router/add_tags", {:tags => @tags}).and_return(@request).once
+      @retryable_request.should_receive(:new).with("/router/add_tags", {:tags => @tags}, {}).and_return(@request).once
       @request.should_receive(:callback).and_yield("result").once
       @manager.add_tags(@tags) { |r| @result = r }
       @result.should == "raw response"
@@ -218,7 +245,7 @@ describe RightScale::AgentTagManager do
     it "updates local tags" do
       @agent.should_receive(:tags).and_return([@tag1]).once
       @agent.should_receive(:tags=).should_receive([@tag]).once
-      @retryable_request.should_receive(:new).with("/router/add_tags", {:tags => [@tag]}).and_return(@request).once
+      @retryable_request.should_receive(:new).with("/router/add_tags", {:tags => [@tag]}, {}).and_return(@request).once
       @manager.add_tags(@tag).should be_true
     end
   end
@@ -232,17 +259,22 @@ describe RightScale::AgentTagManager do
     end
 
     it "removes individual tag to agent" do
-      @retryable_request.should_receive(:new).with("/router/delete_tags", {:tags => [@tag]}).and_return(@request).once
+      @retryable_request.should_receive(:new).with("/router/delete_tags", {:tags => [@tag]}, {}).and_return(@request).once
       @manager.remove_tags(@tag).should be_true
     end
 
     it "removes multiple tags to agent" do
-      @retryable_request.should_receive(:new).with("/router/delete_tags", {:tags => @tags}).and_return(@request).once
+      @retryable_request.should_receive(:new).with("/router/delete_tags", {:tags => @tags}, {}).and_return(@request).once
       @manager.remove_tags(@tags).should be_true
     end
 
+    it "applies timeout when removing tags" do
+      @retryable_request.should_receive(:new).with("/router/delete_tags", {:tags => [@tag]}, {:timeout => 30}).and_return(@request).once
+      @manager.remove_tags(@tag, :timeout => 30).should be_true
+    end
+
     it "optionally yields raw response" do
-      @retryable_request.should_receive(:new).with("/router/delete_tags", {:tags => @tags}).and_return(@request).once
+      @retryable_request.should_receive(:new).with("/router/delete_tags", {:tags => @tags}, {}).and_return(@request).once
       @request.should_receive(:callback).and_yield("result").once
       @manager.remove_tags(@tags) { |r| @result = r }
       @result.should == "raw response"
@@ -251,7 +283,7 @@ describe RightScale::AgentTagManager do
     it "updates local tags" do
       @agent.should_receive(:tags).and_return([]).once
       @agent.should_receive(:tags=).should_receive([@tag]).once
-      @retryable_request.should_receive(:new).with("/router/delete_tags", {:tags => [@tag]}).and_return(@request).once
+      @retryable_request.should_receive(:new).with("/router/delete_tags", {:tags => [@tag]}, {}).and_return(@request).once
       @manager.remove_tags(@tag).should be_true
     end
   end
@@ -276,19 +308,24 @@ describe RightScale::AgentTagManager do
     end
 
     it "adds tags for agent" do
-      @retryable_request.should_receive(:new).with("/router/add_tags", {:tags => [@tag]}).and_return(@request).once
+      @retryable_request.should_receive(:new).with("/router/add_tags", {:tags => [@tag]}, {}).and_return(@request).once
       @agent.should_receive(:tags=).never
       @manager.send(:do_update, [@tag], []).should be_true
     end
 
     it "removes tags for agent" do
-      @retryable_request.should_receive(:new).with("/router/delete_tags", {:tags => [@tag1]}).and_return(@request).once
+      @retryable_request.should_receive(:new).with("/router/delete_tags", {:tags => [@tag1]}, {}).and_return(@request).once
       @agent.should_receive(:tags=).never
       @manager.send(:do_update, [], [@tag1]).should be_true
     end
 
+    it "applies timeout" do
+      @retryable_request.should_receive(:new).with("/router/add_tags", {:tags => [@tag]}, {:timeout => 30}).and_return(@request).once
+      @manager.send(:do_update, [@tag], [], :timeout => 30).should be_true
+    end
+
     it "yields raw response if block given" do
-      @retryable_request.should_receive(:new).with("/router/add_tags", {:tags => [@tag]}).and_return(@request).once
+      @retryable_request.should_receive(:new).with("/router/add_tags", {:tags => [@tag]}, {}).and_return(@request).once
       @request.should_receive(:raw_response).and_return("raw response").once
       @agent.should_receive(:tags=).once
       @manager.send(:do_update, [@tag], []) { |r| @result = r }
@@ -296,7 +333,7 @@ describe RightScale::AgentTagManager do
     end
 
     it "updates local tags if block given and successful" do
-      @retryable_request.should_receive(:new).with("/router/add_tags", {:tags => [@tag]}).and_return(@request).once
+      @retryable_request.should_receive(:new).with("/router/add_tags", {:tags => [@tag]}, {}).and_return(@request).once
       @request.should_receive(:raw_response).and_return("raw response").once
       @agent.should_receive(:tags=).with([@tag]).once
       @manager.send(:do_update, [@tag], []) { |r| @result = r }
@@ -304,7 +341,7 @@ describe RightScale::AgentTagManager do
     end
 
     it "yields error result and does not update local tags" do
-      @retryable_request.should_receive(:new).with("/router/add_tags", {:tags => [@tag]}).and_return(@request).once
+      @retryable_request.should_receive(:new).with("/router/add_tags", {:tags => [@tag]}, {}).and_return(@request).once
       @request.should_receive(:raw_response).and_return("error").once
       @request.should_receive(:errback).and_yield("error").once
       @request.should_receive(:callback).once
@@ -320,9 +357,17 @@ describe RightScale::AgentTagManager do
       @request.should_receive(:raw_response).and_return("raw response").once
       @agent.should_receive(:tags).and_return(@tags).twice
       @agent.should_receive(:tags=).with([]).once
-      @retryable_request.should_receive(:new).with("/router/delete_tags", {:tags => @tags}).and_return(@request).once
+      @retryable_request.should_receive(:new).with("/router/delete_tags", {:tags => @tags}, {}).and_return(@request).once
       @manager.clear { |r| @result = r }
       @result.should == "raw response"
     end
+
+    it "applies timeout" do
+      @request.should_receive(:raw_response).and_return("raw response").once
+      @agent.should_receive(:tags).and_return(@tags).twice
+      @agent.should_receive(:tags=).with([]).once
+      @retryable_request.should_receive(:new).with("/router/delete_tags", {:tags => @tags}, {:timeout => 30}).and_return(@request).once
+      @manager.clear(:timeout => 30) { |r| @result = r }
+    end
   end
 end