From f945415210f0e18c2c6d941fda6b7d45cb0f06f1 Mon Sep 17 00:00:00 2001
From: Don Kjer <don@lindenlab.com>
Date: Wed, 13 Mar 2013 06:26:25 +0000
Subject: Large changes to the LLCurl::Responder API, as well as pulling in
 some changes to common libraries from the server codebase:

* Additional error checking in http handlers.
* Uniform log spam for http errors.
* Switch to using constants for http heads and status codes.
* Fixed bugs in incorrectly checking if parsing LLSD xml resulted in an error.
* Reduced spam regarding LLSD parsing errors in the default completedRaw http handler.  It should not longer be necessary to short-circuit completedRaw to avoid spam.
* Ported over a few bug fixes from the server code.
* Switch mode http status codes to use S32 instead of U32.
* Ported LLSD::asStringRef from server code; avoids copying strings all over the place.
* Ported server change to LLSD::asBinary; this always returns a reference now instead of copying the entire binary blob.
* Ported server pretty notation format (and pretty binary format) to llsd serialization.

* The new LLCurl::Responder API no longer has two error handlers to choose from.  Overriding the following methods have been deprecated:
** error - use httpFailure
** errorWithContent - use httpFailure
** result - use httpSuccess
** completed - use httpCompleted
** completedHeader - no longer necessary; call getResponseHeaders() from a completion method to obtain these headers.

* In order to 'catch' a completed http request, override one of these methods:
** httpSuccess - Called for any 2xx status code.
** httpFailure - Called for any non-2xx status code.
** httpComplete - Called for all status codes.  Default implementation is to call either httpSuccess or httpFailure.
* It is recommended to keep these methods protected/private in order to avoid triggering of these methods without using a 'push' method (see below).

* Uniform error handling should followed whenever possible by calling a variant of this during httpFailure:
** llwarns << dumpResponse() << llendl;
* Be sure to include LOG_CLASS(your_class_name) in your class in order for the log entry to give more context.

* In order to 'push' a result into the responder, you should no longer call error, errorWithContent, result, or completed.
* Nor should you directly call httpSuccess/Failure/Completed (unless passing a message up to a parent class).
* Instead, you can set the internal content of a responder and trigger a corresponding method using the following methods:
** successResult - Sets results and calls httpSuccess
** failureResult - Sets results and calls httpFailure
** completedResult - Sets results and calls httpCompleted

* To obtain information about a the response from a reponder method, use the following getters:
** getStatus - HTTP status code
** getReason - Reason string
** getContent - Content (Parsed body LLSD)
** getResponseHeaders - Response Headers (LLSD map)
** getHTTPMethod - HTTP method of the request
** getURL - URL of the request

* It is still possible to override completeRaw if you want to manipulate data directly out of LLPumpIO.

* See indra/llmessage/llcurl.h for more information.
---
 indra/newview/tests/llmediadataclient_test.cpp     |  8 ++++----
 indra/newview/tests/llremoteparcelrequest_test.cpp | 16 +++++++++-------
 indra/newview/tests/lltranslate_test.cpp           | 12 ++++++------
 3 files changed, 19 insertions(+), 17 deletions(-)

(limited to 'indra/newview/tests')

diff --git a/indra/newview/tests/llmediadataclient_test.cpp b/indra/newview/tests/llmediadataclient_test.cpp
index 41cb344808..01195d1269 100644
--- a/indra/newview/tests/llmediadataclient_test.cpp
+++ b/indra/newview/tests/llmediadataclient_test.cpp
@@ -33,7 +33,7 @@
 #include "llsdserialize.h"
 #include "llsdutil.h"
 #include "llerrorcontrol.h"
-#include "llhttpstatuscodes.h"
+#include "llhttpconstants.h"
 
 #include "../llmediadataclient.h"
 #include "../llvovolume.h"
@@ -128,7 +128,7 @@ void LLHTTPClient::post(
 	{
 		LLSD content;
 		content["reason"] = "fake reason";
-		responder->errorWithContent(HTTP_SERVICE_UNAVAILABLE, "fake reason", content);
+		responder->failureResult(HTTP_SERVICE_UNAVAILABLE, "fake reason", content);
 		return;
 	}
 	else if (url == FAKE_OBJECT_MEDIA_NAVIGATE_CAP_URL_ERROR) 
@@ -136,8 +136,8 @@ void LLHTTPClient::post(
 		LLSD error;
 		error["code"] = LLObjectMediaNavigateClient::ERROR_PERMISSION_DENIED_CODE;
 		result["error"] = error;
-	}	
-	responder->result(result);
+	}
+	responder->successResult(result);
 }
 
 const F32 HTTP_REQUEST_EXPIRY_SECS = 60.0f;
diff --git a/indra/newview/tests/llremoteparcelrequest_test.cpp b/indra/newview/tests/llremoteparcelrequest_test.cpp
index ed66066b0a..c49b0350e9 100644
--- a/indra/newview/tests/llremoteparcelrequest_test.cpp
+++ b/indra/newview/tests/llremoteparcelrequest_test.cpp
@@ -40,12 +40,14 @@ namespace {
 
 LLCurl::Responder::Responder() { }
 LLCurl::Responder::~Responder() { }
-void LLCurl::Responder::error(U32,std::string const &) { }
-void LLCurl::Responder::result(LLSD const &) { }
-void LLCurl::Responder::errorWithContent(U32 status,std::string const &,LLSD const &) { }
-void LLCurl::Responder::completedRaw(U32 status, std::string const &, LLChannelDescriptors const &,boost::shared_ptr<LLBufferArray> const &) { }
-void LLCurl::Responder::completed(U32 status, std::string const &, LLSD const &) { }
-void LLCurl::Responder::completedHeader(U32 status, std::string const &, LLSD const &) { }
+void LLCurl::Responder::httpFailure() { }
+void LLCurl::Responder::httpSuccess() { }
+void LLCurl::Responder::httpCompleted() { }
+void LLCurl::Responder::failureResult(S32 status, const std::string& reason, const LLSD& content) { }
+void LLCurl::Responder::successResult(const LLSD& content) { }
+void LLCurl::Responder::completeResult(S32 status, const std::string& reason, const LLSD& content) { }
+std::string LLCurl::Responder::dumpResponse() const { return "(failure)"; }
+void LLCurl::Responder::completedRaw(LLChannelDescriptors const &,boost::shared_ptr<LLBufferArray> const &) { }
 void LLMessageSystem::getF32(char const *,char const *,F32 &,S32) { }
 void LLMessageSystem::getU8(char const *,char const *,U8 &,S32) { }
 void LLMessageSystem::getS32(char const *,char const *,S32 &,S32) { }
@@ -85,7 +87,7 @@ namespace tut
 
 		virtual void setParcelID(const LLUUID& parcel_id) { }
 
-		virtual void setErrorStatus(U32 status, const std::string& reason) { }
+		virtual void setErrorStatus(S32 status, const std::string& reason) { }
 
 		bool mProcessed;
 	};
diff --git a/indra/newview/tests/lltranslate_test.cpp b/indra/newview/tests/lltranslate_test.cpp
index fd9527d631..b28eb5db43 100644
--- a/indra/newview/tests/lltranslate_test.cpp
+++ b/indra/newview/tests/lltranslate_test.cpp
@@ -34,6 +34,8 @@
 #include "lltrans.h"
 #include "llui.h"
 
+#include "../../llmessage/llhttpconstants.cpp"
+
 static const std::string GOOGLE_VALID_RESPONSE1 =
 "{\
  \"data\": {\
@@ -300,12 +302,10 @@ std::string LLControlGroup::getString(const std::string& name) { return "dummy";
 LLControlGroup::~LLControlGroup() {}
 
 LLCurl::Responder::Responder() {}
-void LLCurl::Responder::completedHeader(U32, std::string const&, LLSD const&) {}
-void LLCurl::Responder::completedRaw(U32, const std::string&, const LLChannelDescriptors&, const LLIOPipe::buffer_ptr_t& buffer) {}
-void LLCurl::Responder::completed(U32, std::string const&, LLSD const&) {}
-void LLCurl::Responder::error(U32, std::string const&) {}
-void LLCurl::Responder::errorWithContent(U32, std::string const&, LLSD const&) {}
-void LLCurl::Responder::result(LLSD const&) {}
+void LLCurl::Responder::httpFailure() { }
+void LLCurl::Responder::httpSuccess() { }
+void LLCurl::Responder::httpCompleted() { }
+void LLCurl::Responder::completedRaw(LLChannelDescriptors const &,boost::shared_ptr<LLBufferArray> const &) { }
 LLCurl::Responder::~Responder() {}
 
 void LLHTTPClient::get(const std::string&, const LLSD&, ResponderPtr, const LLSD&, const F32) {}
-- 
cgit v1.3


From a8cdcfc9a893b7debf7c006022b57c389b50bf0d Mon Sep 17 00:00:00 2001
From: "Brad Payne (Vir Linden)" <vir@lindenlab.com>
Date: Fri, 12 Apr 2013 09:16:25 -0400
Subject: SH-4061 WIP - moved retry policy to newview so it can work with
 either llmessage or CoreHttp libraries. Updated tests.

---
 indra/llmessage/CMakeLists.txt                   |   2 -
 indra/llmessage/llhttpretrypolicy.cpp            |  82 -------
 indra/llmessage/llhttpretrypolicy.h              |  93 --------
 indra/llmessage/tests/llhttpretrypolicy_test.cpp | 220 ------------------
 indra/newview/CMakeLists.txt                     |   5 +
 indra/newview/llhttpretrypolicy.cpp              | 117 ++++++++++
 indra/newview/llhttpretrypolicy.h                |  94 ++++++++
 indra/newview/lltexturefetch.h                   |   2 +-
 indra/newview/tests/llhttpretrypolicy_test.cpp   | 275 +++++++++++++++++++++++
 9 files changed, 492 insertions(+), 398 deletions(-)
 delete mode 100755 indra/llmessage/llhttpretrypolicy.cpp
 delete mode 100755 indra/llmessage/llhttpretrypolicy.h
 delete mode 100755 indra/llmessage/tests/llhttpretrypolicy_test.cpp
 mode change 100644 => 100755 indra/newview/CMakeLists.txt
 create mode 100755 indra/newview/llhttpretrypolicy.cpp
 create mode 100755 indra/newview/llhttpretrypolicy.h
 create mode 100755 indra/newview/tests/llhttpretrypolicy_test.cpp

(limited to 'indra/newview/tests')

diff --git a/indra/llmessage/CMakeLists.txt b/indra/llmessage/CMakeLists.txt
index 6df724f960..6fa2669be6 100755
--- a/indra/llmessage/CMakeLists.txt
+++ b/indra/llmessage/CMakeLists.txt
@@ -67,7 +67,6 @@ set(llmessage_SOURCE_FILES
     llpartdata.cpp
     llproxy.cpp
     llpumpio.cpp
-    llhttpretrypolicy.cpp
     llsdappservices.cpp
     llsdhttpserver.cpp
     llsdmessage.cpp
@@ -267,6 +266,5 @@ if (LL_TESTS)
   LL_ADD_INTEGRATION_TEST(llhttpclientadapter "" "${test_libs}")
   LL_ADD_INTEGRATION_TEST(llpartdata "" "${test_libs}")
   LL_ADD_INTEGRATION_TEST(llxfer_file "" "${test_libs}")
-  LL_ADD_INTEGRATION_TEST(llhttpretrypolicy "" "${test_libs}")
 endif (LL_TESTS)
 
diff --git a/indra/llmessage/llhttpretrypolicy.cpp b/indra/llmessage/llhttpretrypolicy.cpp
deleted file mode 100755
index 7e4dfc7250..0000000000
--- a/indra/llmessage/llhttpretrypolicy.cpp
+++ /dev/null
@@ -1,82 +0,0 @@
-/** 
- * @file llhttpretrypolicy.h
- * @brief Header for a retry policy class intended for use with http responders.
- *
- * $LicenseInfo:firstyear=2013&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2013, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "linden_common.h"
-#include "llhttpretrypolicy.h"
-
-bool LLAdaptiveRetryPolicy::getRetryAfter(const LLSD& headers, retry_header_time)
-{
-	return (headers.has(HTTP_IN_HEADER_RETRY_AFTER)
-			&& getSecondsUntilRetryAfter(headers[HTTP_IN_HEADER_RETRY_AFTER].asStringRef(), retry_header_time));
-}
-
-void LLAdaptiveRetryPolicy::onFailure(S32 status, const LLSD& headers)
-{
-	F32 retry_header_time;
-	bool has_retry_header_time = getRetryAfter(headers,retry_header_time);
-	onFailureCommon(status, has_retry_header_time, retry_header_time);
-}
-
-void LLAdaptiveRetryPolicy::onFailureCommon(S32 status, bool has_retry_header_time, F32 retry_header_time)
-{
-	if (mRetryCount > 0)
-	{
-		mDelay = llclamp(mDelay*mBackoffFactor,mMinDelay,mMaxDelay);
-	}
-	// Honor server Retry-After header.
-	// Status 503 may ask us to wait for a certain amount of time before retrying.
-	F32 wait_time = mDelay;
-	if (has_retry_header_time)
-	{
-		wait_time = retry_header_time;
-	}
-
-	if (mRetryCount>=mMaxRetries)
-	{
-		llinfos << "Too many retries " << mRetryCount << ", will not retry" << llendl;
-		mShouldRetry = false;
-	}
-	if (!isHttpServerErrorStatus(status))
-	{
-		llinfos << "Non-server error " << status << ", will not retry" << llendl;
-		mShouldRetry = false;
-	}
-	if (mShouldRetry)
-	{
-		llinfos << "Retry count " << mRetryCount << " should retry after " << wait_time << llendl;
-		mRetryTimer.reset();
-		mRetryTimer.setTimerExpirySec(wait_time);
-	}
-	mRetryCount++;
-}
-	
-
-bool LLAdaptiveRetryPolicy::shouldRetry(F32& seconds_to_wait) const
-{
-	llassert(mRetryCount>0); // have to call onFailure() before shouldRetry()
-	seconds_to_wait = mShouldRetry ? mRetryTimer.getRemainingTimeF32() : F32_MAX;
-	return mShouldRetry;
-}
diff --git a/indra/llmessage/llhttpretrypolicy.h b/indra/llmessage/llhttpretrypolicy.h
deleted file mode 100755
index cf27bb3048..0000000000
--- a/indra/llmessage/llhttpretrypolicy.h
+++ /dev/null
@@ -1,93 +0,0 @@
-/** 
- * @file file llhttpretrypolicy.h
- * @brief declarations for http retry policy class.
- *
- * $LicenseInfo:firstyear=2013&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2013, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-										
-#ifndef LL_RETRYPOLICY_H
-#define LL_RETRYPOLICY_H
-
-#include "lltimer.h"
-#include "llthread.h"
-
-#include "llhttpconstants.h"
-
-// For compatibility with new core http lib.
-#include "httpresponse.h"
-#include "httpheaders.h"
-
-// This is intended for use with HTTP Clients/Responders, but is not
-// specifically coupled with those classes.
-class LLHTTPRetryPolicy: public LLThreadSafeRefCount
-{
-public:
-	LLHTTPRetryPolicy() {}
-	virtual ~LLHTTPRetryPolicy() {}
-	// Call once after an HTTP failure to update state.
-	virtual void onFailure(S32 status, const LLSD& headers) = 0;
-
-	virtual void onFailure(const HttpResponse *response, const HttpHeaders *headers) = 0;
-
-	virtual bool shouldRetry(F32& seconds_to_wait) const = 0;
-};
-
-// Very general policy with geometric back-off after failures,
-// up to a maximum delay, and maximum number of retries.
-class LLAdaptiveRetryPolicy: public LLHTTPRetryPolicy
-{
-public:
-	LLAdaptiveRetryPolicy(F32 min_delay, F32 max_delay, F32 backoff_factor, U32 max_retries):
-		mMinDelay(min_delay),
-		mMaxDelay(max_delay),
-		mBackoffFactor(backoff_factor),
-		mMaxRetries(max_retries),
-		mDelay(min_delay),
-		mRetryCount(0),
-		mShouldRetry(true)
-	{
-	}
-
-	// virtual
-	void onFailure(S32 status, const LLSD& headers);
-	// virtual
-	void onFailure(const HttpResponse *response, const HttpHeaders *headers);
-	// virtual
-	bool shouldRetry(F32& seconds_to_wait) const;
-
-protected:
-	bool getRetryAfter(const LLSD& headers, retry_header_time)
-	void onFailureCommon(S32 status, bool has_retry_header_time, F32 retry_header_time);
-
-private:
-
-	F32 mMinDelay; // delay never less than this value
-	F32 mMaxDelay; // delay never exceeds this value
-	F32 mBackoffFactor; // delay increases by this factor after each retry, up to mMaxDelay.
-	U32 mMaxRetries; // maximum number of times shouldRetry will return true.
-	F32 mDelay; // current default delay.
-	U32 mRetryCount; // number of times shouldRetry has been called.
-	LLTimer mRetryTimer; // time until next retry.
-	bool mShouldRetry; // Becomes false after too many retries, or the wrong sort of status received, etc.
-};
-
-#endif
diff --git a/indra/llmessage/tests/llhttpretrypolicy_test.cpp b/indra/llmessage/tests/llhttpretrypolicy_test.cpp
deleted file mode 100755
index ebf626d9a8..0000000000
--- a/indra/llmessage/tests/llhttpretrypolicy_test.cpp
+++ /dev/null
@@ -1,220 +0,0 @@
-/** 
- * @file llhttpretrypolicy_test.cpp
- * @brief Header tests to exercise the LLHTTPRetryPolicy classes.
- *
- * $LicenseInfo:firstyear=2013&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2013, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "linden_common.h"
-#include "llhttpretrypolicy.h"
-#include "lltut.h"
-
-namespace tut
-{
-struct TestData
-{
-};
-
-typedef test_group<TestData>	RetryPolicyTestGroup;
-typedef RetryPolicyTestGroup::object		RetryPolicyTestObject;
-RetryPolicyTestGroup retryPolicyTestGroup("retry_policy");
-
-template<> template<>
-void RetryPolicyTestObject::test<1>()
-{
-	LLAdaptiveRetryPolicy never_retry(1.0,1.0,1.0,0);
-	LLSD headers;
-	F32 wait_seconds;
-	
-	never_retry.onFailure(500,headers);
-	ensure("never retry", !never_retry.shouldRetry(wait_seconds)); 
-}
-
-template<> template<>
-void RetryPolicyTestObject::test<2>()
-{
-	LLAdaptiveRetryPolicy retry404(1.0,2.0,3.0,10);
-	LLSD headers;
-	F32 wait_seconds;
-	
-	retry404.onFailure(404,headers);
-	ensure("no retry on 404", !retry404.shouldRetry(wait_seconds)); 
-}
-
-template<> template<>
-void RetryPolicyTestObject::test<3>()
-{
-	// Should retry after 1.0, 2.0, 3.0, 3.0 seconds.
-	LLAdaptiveRetryPolicy basic_retry(1.0,3.0,2.0,4);
-	LLSD headers;
-	F32 wait_seconds;
-	bool should_retry;
-	U32 frac_bits = 6;
-
-	// Starting wait 1.0
-	basic_retry.onFailure(500,headers);
-	should_retry = basic_retry.shouldRetry(wait_seconds);
-	ensure("basic_retry 1", should_retry);
-	ensure_approximately_equals("basic_retry 1", wait_seconds, 1.0F, frac_bits);
-
-	// Double wait to 2.0
-	basic_retry.onFailure(500,headers);
-	should_retry = basic_retry.shouldRetry(wait_seconds);
-	ensure("basic_retry 2", should_retry);
-	ensure_approximately_equals("basic_retry 2", wait_seconds, 2.0F, frac_bits);
-
-	// Hit max wait of 3.0 (4.0 clamped to max 3)
-	basic_retry.onFailure(500,headers);
-	should_retry = basic_retry.shouldRetry(wait_seconds);
-	ensure("basic_retry 3", should_retry);
-	ensure_approximately_equals("basic_retry 3", wait_seconds, 3.0F, frac_bits);
-
-	// At max wait, should stay at 3.0
-	basic_retry.onFailure(500,headers);
-	should_retry = basic_retry.shouldRetry(wait_seconds);
-	ensure("basic_retry 4", should_retry);
-	ensure_approximately_equals("basic_retry 4", wait_seconds, 3.0F, frac_bits);
-
-	// Max retries, should fail now.
-	basic_retry.onFailure(500,headers);
-	should_retry = basic_retry.shouldRetry(wait_seconds);
-	ensure("basic_retry 5", !should_retry);
-}
-
-// Retries should stop as soon as a non-5xx error is received.
-template<> template<>
-void RetryPolicyTestObject::test<4>()
-{
-	// Should retry after 1.0, 2.0, 3.0, 3.0 seconds.
-	LLAdaptiveRetryPolicy killer404(1.0,3.0,2.0,4);
-	LLSD headers;
-	F32 wait_seconds;
-	bool should_retry;
-	U32 frac_bits = 6;
-
-	// Starting wait 1.0
-	killer404.onFailure(500,headers);
-	should_retry = killer404.shouldRetry(wait_seconds);
-	ensure("killer404 1", should_retry);
-	ensure_approximately_equals("killer404 1", wait_seconds, 1.0F, frac_bits);
-
-	// Double wait to 2.0
-	killer404.onFailure(500,headers);
-	should_retry = killer404.shouldRetry(wait_seconds);
-	ensure("killer404 2", should_retry);
-	ensure_approximately_equals("killer404 2", wait_seconds, 2.0F, frac_bits);
-
-	// Should fail on non-5xx
-	killer404.onFailure(404,headers);
-	should_retry = killer404.shouldRetry(wait_seconds);
-	ensure("killer404 3", !should_retry);
-
-	// After a non-5xx, should keep failing.
-	killer404.onFailure(500,headers);
-	should_retry = killer404.shouldRetry(wait_seconds);
-	ensure("killer404 4", !should_retry);
-}
-
-// Test handling of "retry-after" header. If present, this header
-// value overrides the computed delay, but does not affect the
-// progression of delay values.  For example, if the normal
-// progression of delays would be 1,2,4,8..., but the 2nd and 3rd calls
-// get a retry header of 33, the pattern would become 1,33,33,8...
-template<> template<>
-void RetryPolicyTestObject::test<5>()
-{
-	LLAdaptiveRetryPolicy policy(1.0,25.0,2.0,6);
-	LLSD headers_with_retry;
-	headers_with_retry[HTTP_IN_HEADER_RETRY_AFTER] = "666";
-	LLSD headers_without_retry;
-	F32 wait_seconds;
-	bool should_retry;
-	U32 frac_bits = 6;
-
-	policy.onFailure(500,headers_without_retry);
-	should_retry = policy.shouldRetry(wait_seconds);
-	ensure("retry header 1", should_retry);
-	ensure_approximately_equals("retry header 1", wait_seconds, 1.0F, frac_bits);
-
-	policy.onFailure(500,headers_without_retry);
-	should_retry = policy.shouldRetry(wait_seconds);
-	ensure("retry header 2", should_retry);
-	ensure_approximately_equals("retry header 2", wait_seconds, 2.0F, frac_bits);
-
-	policy.onFailure(500,headers_with_retry);
-	should_retry = policy.shouldRetry(wait_seconds);
-	ensure("retry header 3", should_retry);
-	// 4.0 overrides by header -> 666.0
-	ensure_approximately_equals("retry header 3", wait_seconds, 666.0F, frac_bits);
-
-	policy.onFailure(500,headers_with_retry);
-	should_retry = policy.shouldRetry(wait_seconds);
-	ensure("retry header 4", should_retry);
-	// 8.0 overrides by header -> 666.0
-	ensure_approximately_equals("retry header 4", wait_seconds, 666.0F, frac_bits);
-
-	policy.onFailure(500,headers_without_retry);
-	should_retry = policy.shouldRetry(wait_seconds);
-	ensure("retry header 5", should_retry);
-	ensure_approximately_equals("retry header 5", wait_seconds, 16.0F, frac_bits);
-
-	policy.onFailure(500,headers_without_retry);
-	should_retry = policy.shouldRetry(wait_seconds);
-	ensure("retry header 6", should_retry);
-	ensure_approximately_equals("retry header 6", wait_seconds, 25.0F, frac_bits);
-
-	policy.onFailure(500,headers_with_retry);
-	should_retry = policy.shouldRetry(wait_seconds);
-	ensure("retry header 7", !should_retry);
-}
-
-// Test getSecondsUntilRetryAfter(const std::string& retry_after, F32& seconds_to_wait),
-// used by header parsing of the retry policy.
-template<> template<>
-void RetryPolicyTestObject::test<6>()
-{
-	F32 seconds_to_wait;
-	bool success;
-
-	std::string str1("0");
-	seconds_to_wait = F32_MAX;
-	success = getSecondsUntilRetryAfter(str1, seconds_to_wait);
-	ensure("parse 1", success);
-	ensure_equals("parse 1", seconds_to_wait, 0.0);
-
-	std::string str2("999.9");
-	seconds_to_wait = F32_MAX;
-	success = getSecondsUntilRetryAfter(str2, seconds_to_wait);
-	ensure("parse 2", success);
-	ensure_approximately_equals("parse 2", seconds_to_wait, 999.9F, 8);
-
-	time_t nowseconds;
-	time(&nowseconds);
-	std::string str3 = LLDate((F64)nowseconds).asRFC1123();
-	seconds_to_wait = F32_MAX;
-	success = getSecondsUntilRetryAfter(str3, seconds_to_wait);
-	ensure("parse 3", success);
-	ensure_approximately_equals("parse 3", seconds_to_wait, 0.0F, 6);
-}
-
-}
-
diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt
old mode 100644
new mode 100755
index 05736f6360..27dbe15005
--- a/indra/newview/CMakeLists.txt
+++ b/indra/newview/CMakeLists.txt
@@ -299,6 +299,7 @@ set(viewer_SOURCE_FILES
     llgroupmgr.cpp
     llhints.cpp
     llhomelocationresponder.cpp
+    llhttpretrypolicy.cpp
     llhudeffect.cpp
     llhudeffectbeam.cpp
     llhudeffectlookat.cpp
@@ -877,6 +878,7 @@ set(viewer_HEADER_FILES
     llgrouplist.h
     llgroupmgr.h
     llhints.h
+    llhttpretrypolicy.h
     llhomelocationresponder.h
     llhudeffect.h
     llhudeffectbeam.h
@@ -2152,6 +2154,7 @@ if (LL_TESTS)
 
   set(test_libs
     ${LLMESSAGE_LIBRARIES}
+    ${LLCOREHTTP_LIBRARIES}
     ${WINDOWS_LIBRARIES}
     ${LLVFS_LIBRARIES}
     ${LLMATH_LIBRARIES}
@@ -2197,6 +2200,8 @@ if (LL_TESTS)
     "${test_libs}"
     )
 
+  LL_ADD_INTEGRATION_TEST(llhttpretrypolicy "llhttpretrypolicy.cpp" "${test_libs}")
+
   #ADD_VIEWER_BUILD_TEST(llmemoryview viewer)
   #ADD_VIEWER_BUILD_TEST(llagentaccess viewer)
   #ADD_VIEWER_BUILD_TEST(lltextureinfo viewer)
diff --git a/indra/newview/llhttpretrypolicy.cpp b/indra/newview/llhttpretrypolicy.cpp
new file mode 100755
index 0000000000..5c6dabbe99
--- /dev/null
+++ b/indra/newview/llhttpretrypolicy.cpp
@@ -0,0 +1,117 @@
+/** 
+ * @file llhttpretrypolicy.h
+ * @brief Header for a retry policy class intended for use with http responders.
+ *
+ * $LicenseInfo:firstyear=2013&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2013, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "llviewerprecompiledheaders.h"
+
+#include "llhttpretrypolicy.h"
+
+bool LLAdaptiveRetryPolicy::getRetryAfter(const LLSD& headers, F32& retry_header_time)
+{
+	return (headers.has(HTTP_IN_HEADER_RETRY_AFTER)
+			&& getSecondsUntilRetryAfter(headers[HTTP_IN_HEADER_RETRY_AFTER].asStringRef(), retry_header_time));
+}
+
+bool LLAdaptiveRetryPolicy::getRetryAfter(const LLCore::HttpHeaders *headers, F32& retry_header_time)
+{
+	// Look for matching header. Hopefully it's correct enough to let
+	// us extract the field we are looking for. Does not purport to be
+	// in any way a viable general HTTP header parser.
+	if (headers)
+	{
+		for (std::vector<std::string>::const_iterator it = headers->mHeaders.begin();
+			 it != headers->mHeaders.end();
+			 ++it)
+		{
+			const std::string& str = *it;
+			const std::string match = HTTP_IN_HEADER_RETRY_AFTER + ":";
+			size_t pos = str.find(match);
+			if ((pos != std::string::npos) &&
+				(pos+match.length() <= str.length()))
+			{
+				retry_header_time = strtod(str.substr(pos+match.length()).c_str(), NULL);
+				return true;
+			}
+		}
+	}
+	return false;
+}
+
+void LLAdaptiveRetryPolicy::onFailure(S32 status, const LLSD& headers)
+{
+	F32 retry_header_time;
+	bool has_retry_header_time = getRetryAfter(headers,retry_header_time);
+	onFailureCommon(status, has_retry_header_time, retry_header_time);
+}
+  
+// TODO: replace this parsing junk once CoreHttp has its own header parsing capabilities.
+void LLAdaptiveRetryPolicy::onFailure(const LLCore::HttpResponse *response)
+{
+	F32 retry_header_time;
+	const LLCore::HttpHeaders *headers = response->getHeaders();
+	bool has_retry_header_time = getRetryAfter(headers,retry_header_time);
+	onFailureCommon(response->getStatus().mType, has_retry_header_time, retry_header_time);
+}
+
+void LLAdaptiveRetryPolicy::onFailureCommon(S32 status, bool has_retry_header_time, F32 retry_header_time)
+{
+	if (mRetryCount > 0)
+	{
+		mDelay = llclamp(mDelay*mBackoffFactor,mMinDelay,mMaxDelay);
+	}
+	// Honor server Retry-After header.
+	// Status 503 may ask us to wait for a certain amount of time before retrying.
+	F32 wait_time = mDelay;
+	if (has_retry_header_time)
+	{
+		wait_time = retry_header_time;
+	}
+
+	if (mRetryCount>=mMaxRetries)
+	{
+		llinfos << "Too many retries " << mRetryCount << ", will not retry" << llendl;
+		mShouldRetry = false;
+	}
+	if (!isHttpServerErrorStatus(status))
+	{
+		llinfos << "Non-server error " << status << ", will not retry" << llendl;
+		mShouldRetry = false;
+	}
+	if (mShouldRetry)
+	{
+		llinfos << "Retry count " << mRetryCount << " should retry after " << wait_time << llendl;
+		mRetryTimer.reset();
+		mRetryTimer.setTimerExpirySec(wait_time);
+	}
+	mRetryCount++;
+}
+	
+
+bool LLAdaptiveRetryPolicy::shouldRetry(F32& seconds_to_wait) const
+{
+	llassert(mRetryCount>0); // have to call onFailure() before shouldRetry()
+	seconds_to_wait = mShouldRetry ? mRetryTimer.getRemainingTimeF32() : F32_MAX;
+	return mShouldRetry;
+}
diff --git a/indra/newview/llhttpretrypolicy.h b/indra/newview/llhttpretrypolicy.h
new file mode 100755
index 0000000000..ca37e5f73c
--- /dev/null
+++ b/indra/newview/llhttpretrypolicy.h
@@ -0,0 +1,94 @@
+/** 
+ * @file file llhttpretrypolicy.h
+ * @brief declarations for http retry policy class.
+ *
+ * $LicenseInfo:firstyear=2013&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2013, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+										
+#ifndef LL_RETRYPOLICY_H
+#define LL_RETRYPOLICY_H
+
+#include "lltimer.h"
+#include "llthread.h"
+
+#include "llhttpconstants.h"
+
+// For compatibility with new core http lib.
+#include "httpresponse.h"
+#include "httpheaders.h"
+
+// This is intended for use with HTTP Clients/Responders, but is not
+// specifically coupled with those classes.
+class LLHTTPRetryPolicy: public LLThreadSafeRefCount
+{
+public:
+	LLHTTPRetryPolicy() {}
+	virtual ~LLHTTPRetryPolicy() {}
+	// Call once after an HTTP failure to update state.
+	virtual void onFailure(S32 status, const LLSD& headers) = 0;
+
+	virtual void onFailure(const LLCore::HttpResponse *response) = 0;
+
+	virtual bool shouldRetry(F32& seconds_to_wait) const = 0;
+};
+
+// Very general policy with geometric back-off after failures,
+// up to a maximum delay, and maximum number of retries.
+class LLAdaptiveRetryPolicy: public LLHTTPRetryPolicy
+{
+public:
+	LLAdaptiveRetryPolicy(F32 min_delay, F32 max_delay, F32 backoff_factor, U32 max_retries):
+		mMinDelay(min_delay),
+		mMaxDelay(max_delay),
+		mBackoffFactor(backoff_factor),
+		mMaxRetries(max_retries),
+		mDelay(min_delay),
+		mRetryCount(0),
+		mShouldRetry(true)
+	{
+	}
+
+	// virtual
+	void onFailure(S32 status, const LLSD& headers);
+	// virtual
+	void onFailure(const LLCore::HttpResponse *response);
+	// virtual
+	bool shouldRetry(F32& seconds_to_wait) const;
+
+protected:
+	bool getRetryAfter(const LLSD& headers, F32& retry_header_time);
+	bool getRetryAfter(const LLCore::HttpHeaders *headers, F32& retry_header_time);
+	void onFailureCommon(S32 status, bool has_retry_header_time, F32 retry_header_time);
+
+private:
+
+	F32 mMinDelay; // delay never less than this value
+	F32 mMaxDelay; // delay never exceeds this value
+	F32 mBackoffFactor; // delay increases by this factor after each retry, up to mMaxDelay.
+	U32 mMaxRetries; // maximum number of times shouldRetry will return true.
+	F32 mDelay; // current default delay.
+	U32 mRetryCount; // number of times shouldRetry has been called.
+	LLTimer mRetryTimer; // time until next retry.
+	bool mShouldRetry; // Becomes false after too many retries, or the wrong sort of status received, etc.
+};
+
+#endif
diff --git a/indra/newview/lltexturefetch.h b/indra/newview/lltexturefetch.h
index c6bd342a7b..12226d51c8 100755
--- a/indra/newview/lltexturefetch.h
+++ b/indra/newview/lltexturefetch.h
@@ -397,7 +397,7 @@ private:
 	e_tex_source mOriginFetchSource;
 
 	// Retry logic
-	LLAdaptiveRetryPolicy mFetchRetryPolicy;
+	//LLAdaptiveRetryPolicy mFetchRetryPolicy;
 	
 public:
 	//debug use
diff --git a/indra/newview/tests/llhttpretrypolicy_test.cpp b/indra/newview/tests/llhttpretrypolicy_test.cpp
new file mode 100755
index 0000000000..39bd15d62f
--- /dev/null
+++ b/indra/newview/tests/llhttpretrypolicy_test.cpp
@@ -0,0 +1,275 @@
+/** 
+ * @file llhttpretrypolicy_test.cpp
+ * @brief Header tests to exercise the LLHTTPRetryPolicy classes.
+ *
+ * $LicenseInfo:firstyear=2013&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2013, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "../llviewerprecompiledheaders.h"
+#include "../llhttpretrypolicy.h"
+#include "lltut.h"
+
+namespace tut
+{
+struct TestData
+{
+};
+
+typedef test_group<TestData>	RetryPolicyTestGroup;
+typedef RetryPolicyTestGroup::object		RetryPolicyTestObject;
+RetryPolicyTestGroup retryPolicyTestGroup("retry_policy");
+
+template<> template<>
+void RetryPolicyTestObject::test<1>()
+{
+	LLAdaptiveRetryPolicy never_retry(1.0,1.0,1.0,0);
+	LLSD headers;
+	F32 wait_seconds;
+	
+	never_retry.onFailure(500,headers);
+	ensure("never retry", !never_retry.shouldRetry(wait_seconds)); 
+}
+
+template<> template<>
+void RetryPolicyTestObject::test<2>()
+{
+	LLAdaptiveRetryPolicy retry404(1.0,2.0,3.0,10);
+	LLSD headers;
+	F32 wait_seconds;
+	
+	retry404.onFailure(404,headers);
+	ensure("no retry on 404", !retry404.shouldRetry(wait_seconds)); 
+}
+
+template<> template<>
+void RetryPolicyTestObject::test<3>()
+{
+	// Should retry after 1.0, 2.0, 3.0, 3.0 seconds.
+	LLAdaptiveRetryPolicy basic_retry(1.0,3.0,2.0,4);
+	LLSD headers;
+	F32 wait_seconds;
+	bool should_retry;
+	U32 frac_bits = 6;
+
+	// Starting wait 1.0
+	basic_retry.onFailure(500,headers);
+	should_retry = basic_retry.shouldRetry(wait_seconds);
+	ensure("basic_retry 1", should_retry);
+	ensure_approximately_equals("basic_retry 1", wait_seconds, 1.0F, frac_bits);
+
+	// Double wait to 2.0
+	basic_retry.onFailure(500,headers);
+	should_retry = basic_retry.shouldRetry(wait_seconds);
+	ensure("basic_retry 2", should_retry);
+	ensure_approximately_equals("basic_retry 2", wait_seconds, 2.0F, frac_bits);
+
+	// Hit max wait of 3.0 (4.0 clamped to max 3)
+	basic_retry.onFailure(500,headers);
+	should_retry = basic_retry.shouldRetry(wait_seconds);
+	ensure("basic_retry 3", should_retry);
+	ensure_approximately_equals("basic_retry 3", wait_seconds, 3.0F, frac_bits);
+
+	// At max wait, should stay at 3.0
+	basic_retry.onFailure(500,headers);
+	should_retry = basic_retry.shouldRetry(wait_seconds);
+	ensure("basic_retry 4", should_retry);
+	ensure_approximately_equals("basic_retry 4", wait_seconds, 3.0F, frac_bits);
+
+	// Max retries, should fail now.
+	basic_retry.onFailure(500,headers);
+	should_retry = basic_retry.shouldRetry(wait_seconds);
+	ensure("basic_retry 5", !should_retry);
+}
+
+// Retries should stop as soon as a non-5xx error is received.
+template<> template<>
+void RetryPolicyTestObject::test<4>()
+{
+	// Should retry after 1.0, 2.0, 3.0, 3.0 seconds.
+	LLAdaptiveRetryPolicy killer404(1.0,3.0,2.0,4);
+	LLSD headers;
+	F32 wait_seconds;
+	bool should_retry;
+	U32 frac_bits = 6;
+
+	// Starting wait 1.0
+	killer404.onFailure(500,headers);
+	should_retry = killer404.shouldRetry(wait_seconds);
+	ensure("killer404 1", should_retry);
+	ensure_approximately_equals("killer404 1", wait_seconds, 1.0F, frac_bits);
+
+	// Double wait to 2.0
+	killer404.onFailure(500,headers);
+	should_retry = killer404.shouldRetry(wait_seconds);
+	ensure("killer404 2", should_retry);
+	ensure_approximately_equals("killer404 2", wait_seconds, 2.0F, frac_bits);
+
+	// Should fail on non-5xx
+	killer404.onFailure(404,headers);
+	should_retry = killer404.shouldRetry(wait_seconds);
+	ensure("killer404 3", !should_retry);
+
+	// After a non-5xx, should keep failing.
+	killer404.onFailure(500,headers);
+	should_retry = killer404.shouldRetry(wait_seconds);
+	ensure("killer404 4", !should_retry);
+}
+
+// Test handling of "retry-after" header. If present, this header
+// value overrides the computed delay, but does not affect the
+// progression of delay values.  For example, if the normal
+// progression of delays would be 1,2,4,8..., but the 2nd and 3rd calls
+// get a retry header of 33, the pattern would become 1,33,33,8...
+template<> template<>
+void RetryPolicyTestObject::test<5>()
+{
+	LLAdaptiveRetryPolicy policy(1.0,25.0,2.0,6);
+	LLSD headers_with_retry;
+	headers_with_retry[HTTP_IN_HEADER_RETRY_AFTER] = "666";
+	LLSD headers_without_retry;
+	F32 wait_seconds;
+	bool should_retry;
+	U32 frac_bits = 6;
+
+	policy.onFailure(500,headers_without_retry);
+	should_retry = policy.shouldRetry(wait_seconds);
+	ensure("retry header 1", should_retry);
+	ensure_approximately_equals("retry header 1", wait_seconds, 1.0F, frac_bits);
+
+	policy.onFailure(500,headers_without_retry);
+	should_retry = policy.shouldRetry(wait_seconds);
+	ensure("retry header 2", should_retry);
+	ensure_approximately_equals("retry header 2", wait_seconds, 2.0F, frac_bits);
+
+	policy.onFailure(500,headers_with_retry);
+	should_retry = policy.shouldRetry(wait_seconds);
+	ensure("retry header 3", should_retry);
+	// 4.0 overrides by header -> 666.0
+	ensure_approximately_equals("retry header 3", wait_seconds, 666.0F, frac_bits);
+
+	policy.onFailure(500,headers_with_retry);
+	should_retry = policy.shouldRetry(wait_seconds);
+	ensure("retry header 4", should_retry);
+	// 8.0 overrides by header -> 666.0
+	ensure_approximately_equals("retry header 4", wait_seconds, 666.0F, frac_bits);
+
+	policy.onFailure(500,headers_without_retry);
+	should_retry = policy.shouldRetry(wait_seconds);
+	ensure("retry header 5", should_retry);
+	ensure_approximately_equals("retry header 5", wait_seconds, 16.0F, frac_bits);
+
+	policy.onFailure(500,headers_without_retry);
+	should_retry = policy.shouldRetry(wait_seconds);
+	ensure("retry header 6", should_retry);
+	ensure_approximately_equals("retry header 6", wait_seconds, 25.0F, frac_bits);
+
+	policy.onFailure(500,headers_with_retry);
+	should_retry = policy.shouldRetry(wait_seconds);
+	ensure("retry header 7", !should_retry);
+}
+
+// Test getSecondsUntilRetryAfter(const std::string& retry_after, F32& seconds_to_wait),
+// used by header parsing of the retry policy.
+template<> template<>
+void RetryPolicyTestObject::test<6>()
+{
+	F32 seconds_to_wait;
+	bool success;
+
+	std::string str1("0");
+	seconds_to_wait = F32_MAX;
+	success = getSecondsUntilRetryAfter(str1, seconds_to_wait);
+	ensure("parse 1", success);
+	ensure_equals("parse 1", seconds_to_wait, 0.0);
+
+	std::string str2("999.9");
+	seconds_to_wait = F32_MAX;
+	success = getSecondsUntilRetryAfter(str2, seconds_to_wait);
+	ensure("parse 2", success);
+	ensure_approximately_equals("parse 2", seconds_to_wait, 999.9F, 8);
+
+	time_t nowseconds;
+	time(&nowseconds);
+	std::string str3 = LLDate((F64)nowseconds).asRFC1123();
+	seconds_to_wait = F32_MAX;
+	success = getSecondsUntilRetryAfter(str3, seconds_to_wait);
+	ensure("parse 3", success);
+	ensure_approximately_equals("parse 3", seconds_to_wait, 0.0F, 6);
+}
+
+// Test retry-after field in both llmessage and CoreHttp headers.
+template<> template<>
+void RetryPolicyTestObject::test<7>()
+{
+	LLSD sd_headers;
+	time_t nowseconds;
+	time(&nowseconds);
+	sd_headers[HTTP_IN_HEADER_RETRY_AFTER] = LLDate((F64)nowseconds).asRFC1123();
+	LLAdaptiveRetryPolicy policy(17.0,644.0,3.0,10);
+	F32 seconds_to_wait;
+	bool should_retry;
+
+	// no retry header, use default.
+	policy.onFailure(500,LLSD());
+	should_retry = policy.shouldRetry(seconds_to_wait);
+	ensure("header 1", should_retry);
+	ensure_approximately_equals("header 1", seconds_to_wait, 17.0F, 6);
+
+	// retry header should override, give delay of 0
+	policy.onFailure(503,sd_headers);
+	should_retry = policy.shouldRetry(seconds_to_wait);
+	ensure("header 2", should_retry);
+	ensure_approximately_equals("header 2", seconds_to_wait, 0.0F, 6);
+
+	// retry header in LLCore::HttpHeaders
+	{
+		LLCore::HttpResponse *response = new LLCore::HttpResponse();
+		LLCore::HttpHeaders *headers = new LLCore::HttpHeaders();
+		response->setStatus(503);
+		response->setHeaders(headers);
+		headers->mHeaders.push_back("retry-after: 600");
+		policy.onFailure(response);
+		should_retry = policy.shouldRetry(seconds_to_wait);
+		ensure("header 3",should_retry);
+		ensure_approximately_equals("header 3", seconds_to_wait, 600.0F, 6);
+		response->release();
+	}
+
+	// retry header in LLCore::HttpHeaders
+	{
+		LLCore::HttpResponse *response = new LLCore::HttpResponse();
+		LLCore::HttpHeaders *headers = new LLCore::HttpHeaders();
+		response->setStatus(503);
+		response->setHeaders(headers);
+		LLSD sd_headers;
+		time(&nowseconds);
+		headers->mHeaders.push_back("retry-after: " + LLDate((F64)nowseconds).asRFC1123());
+		policy.onFailure(response);
+		should_retry = policy.shouldRetry(seconds_to_wait);
+		ensure("header 3",should_retry);
+		ensure_approximately_equals("header 3", seconds_to_wait, 0.0F, 6);
+		response->release();
+	}
+}
+
+}
+
-- 
cgit v1.3


From bb237ce15f0a7bc4a3fbffc45b1e4548fd1d2f81 Mon Sep 17 00:00:00 2001
From: "Brad Payne (Vir Linden)" <vir@lindenlab.com>
Date: Fri, 12 Apr 2013 17:04:48 -0400
Subject: SH_4061 WIP - retry policy org and tests

---
 indra/newview/llhttpretrypolicy.cpp            | 23 +++++++++++++++++-
 indra/newview/llhttpretrypolicy.h              | 11 +--------
 indra/newview/tests/llhttpretrypolicy_test.cpp | 33 +++++++++++++++++++++-----
 3 files changed, 50 insertions(+), 17 deletions(-)

(limited to 'indra/newview/tests')

diff --git a/indra/newview/llhttpretrypolicy.cpp b/indra/newview/llhttpretrypolicy.cpp
index 5c6dabbe99..82f6eab00e 100755
--- a/indra/newview/llhttpretrypolicy.cpp
+++ b/indra/newview/llhttpretrypolicy.cpp
@@ -28,6 +28,17 @@
 
 #include "llhttpretrypolicy.h"
 
+LLAdaptiveRetryPolicy::LLAdaptiveRetryPolicy(F32 min_delay, F32 max_delay, F32 backoff_factor, U32 max_retries):
+	mMinDelay(min_delay),
+	mMaxDelay(max_delay),
+	mBackoffFactor(backoff_factor),
+	mMaxRetries(max_retries),
+	mDelay(min_delay),
+	mRetryCount(0),
+	mShouldRetry(true)
+{
+}
+
 bool LLAdaptiveRetryPolicy::getRetryAfter(const LLSD& headers, F32& retry_header_time)
 {
 	return (headers.has(HTTP_IN_HEADER_RETRY_AFTER)
@@ -77,6 +88,11 @@ void LLAdaptiveRetryPolicy::onFailure(const LLCore::HttpResponse *response)
 
 void LLAdaptiveRetryPolicy::onFailureCommon(S32 status, bool has_retry_header_time, F32 retry_header_time)
 {
+	if (!mShouldRetry)
+	{
+		llinfos << "keep on failing" << llendl;
+		return;
+	}
 	if (mRetryCount > 0)
 	{
 		mDelay = llclamp(mDelay*mBackoffFactor,mMinDelay,mMaxDelay);
@@ -111,7 +127,12 @@ void LLAdaptiveRetryPolicy::onFailureCommon(S32 status, bool has_retry_header_ti
 
 bool LLAdaptiveRetryPolicy::shouldRetry(F32& seconds_to_wait) const
 {
-	llassert(mRetryCount>0); // have to call onFailure() before shouldRetry()
+	if (mRetryCount == 0)
+	{
+		// Called shouldRetry before any failure.
+		seconds_to_wait = F32_MAX;
+		return false;
+	}
 	seconds_to_wait = mShouldRetry ? mRetryTimer.getRemainingTimeF32() : F32_MAX;
 	return mShouldRetry;
 }
diff --git a/indra/newview/llhttpretrypolicy.h b/indra/newview/llhttpretrypolicy.h
index ca37e5f73c..6f63f047de 100755
--- a/indra/newview/llhttpretrypolicy.h
+++ b/indra/newview/llhttpretrypolicy.h
@@ -56,16 +56,7 @@ public:
 class LLAdaptiveRetryPolicy: public LLHTTPRetryPolicy
 {
 public:
-	LLAdaptiveRetryPolicy(F32 min_delay, F32 max_delay, F32 backoff_factor, U32 max_retries):
-		mMinDelay(min_delay),
-		mMaxDelay(max_delay),
-		mBackoffFactor(backoff_factor),
-		mMaxRetries(max_retries),
-		mDelay(min_delay),
-		mRetryCount(0),
-		mShouldRetry(true)
-	{
-	}
+	LLAdaptiveRetryPolicy(F32 min_delay, F32 max_delay, F32 backoff_factor, U32 max_retries);
 
 	// virtual
 	void onFailure(S32 status, const LLSD& headers);
diff --git a/indra/newview/tests/llhttpretrypolicy_test.cpp b/indra/newview/tests/llhttpretrypolicy_test.cpp
index 39bd15d62f..43fc1178cc 100755
--- a/indra/newview/tests/llhttpretrypolicy_test.cpp
+++ b/indra/newview/tests/llhttpretrypolicy_test.cpp
@@ -45,8 +45,12 @@ void RetryPolicyTestObject::test<1>()
 	LLSD headers;
 	F32 wait_seconds;
 	
+	// No retry until we've finished a try.
+	ensure("never retry 0", !never_retry.shouldRetry(wait_seconds));
+
+	// 0 retries max.
 	never_retry.onFailure(500,headers);
-	ensure("never retry", !never_retry.shouldRetry(wait_seconds)); 
+	ensure("never retry 1", !never_retry.shouldRetry(wait_seconds)); 
 }
 
 template<> template<>
@@ -70,6 +74,9 @@ void RetryPolicyTestObject::test<3>()
 	bool should_retry;
 	U32 frac_bits = 6;
 
+	// No retry until we've finished a try.
+	ensure("basic_retry 0", !basic_retry.shouldRetry(wait_seconds));
+
 	// Starting wait 1.0
 	basic_retry.onFailure(500,headers);
 	should_retry = basic_retry.shouldRetry(wait_seconds);
@@ -224,10 +231,13 @@ void RetryPolicyTestObject::test<7>()
 	time_t nowseconds;
 	time(&nowseconds);
 	sd_headers[HTTP_IN_HEADER_RETRY_AFTER] = LLDate((F64)nowseconds).asRFC1123();
-	LLAdaptiveRetryPolicy policy(17.0,644.0,3.0,10);
+	LLAdaptiveRetryPolicy policy(17.0,644.0,3.0,5);
 	F32 seconds_to_wait;
 	bool should_retry;
 
+	// No retry until we've finished a try.
+	ensure("header 0", !policy.shouldRetry(seconds_to_wait));
+	
 	// no retry header, use default.
 	policy.onFailure(500,LLSD());
 	should_retry = policy.shouldRetry(seconds_to_wait);
@@ -246,7 +256,7 @@ void RetryPolicyTestObject::test<7>()
 		LLCore::HttpHeaders *headers = new LLCore::HttpHeaders();
 		response->setStatus(503);
 		response->setHeaders(headers);
-		headers->mHeaders.push_back("retry-after: 600");
+		headers->mHeaders.push_back(HTTP_IN_HEADER_RETRY_AFTER + ": 600");
 		policy.onFailure(response);
 		should_retry = policy.shouldRetry(seconds_to_wait);
 		ensure("header 3",should_retry);
@@ -262,13 +272,24 @@ void RetryPolicyTestObject::test<7>()
 		response->setHeaders(headers);
 		LLSD sd_headers;
 		time(&nowseconds);
-		headers->mHeaders.push_back("retry-after: " + LLDate((F64)nowseconds).asRFC1123());
+		headers->mHeaders.push_back(HTTP_IN_HEADER_RETRY_AFTER + ": " + LLDate((F64)nowseconds).asRFC1123());
 		policy.onFailure(response);
 		should_retry = policy.shouldRetry(seconds_to_wait);
-		ensure("header 3",should_retry);
-		ensure_approximately_equals("header 3", seconds_to_wait, 0.0F, 6);
+		ensure("header 4",should_retry);
+		ensure_approximately_equals("header 4", seconds_to_wait, 0.0F, 6);
 		response->release();
 	}
+
+	// Timeout should be clamped at max.
+	policy.onFailure(500,LLSD());
+	should_retry = policy.shouldRetry(seconds_to_wait);
+	ensure("header 5", should_retry);
+	ensure_approximately_equals("header 5", seconds_to_wait, 644.0F, 6);
+
+	// No more retries.
+	policy.onFailure(500,LLSD());
+	should_retry = policy.shouldRetry(seconds_to_wait);
+	ensure("header 6", !should_retry);
 }
 
 }
-- 
cgit v1.3


From 24b9657597be6d0b7af472d5deda4b4828ead606 Mon Sep 17 00:00:00 2001
From: "Brad Payne (Vir Linden)" <vir@lindenlab.com>
Date: Mon, 15 Apr 2013 20:35:26 -0400
Subject: SH-4061 WIP - improved retry policy test, turned up and fixed a bug
 in getSecondsUntilRetryAfter

---
 indra/llmessage/llhttpconstants.cpp            | 36 +++++++------
 indra/newview/tests/llhttpretrypolicy_test.cpp | 70 +++++++++++++-------------
 2 files changed, 53 insertions(+), 53 deletions(-)
 mode change 100644 => 100755 indra/llmessage/llhttpconstants.cpp

(limited to 'indra/newview/tests')

diff --git a/indra/llmessage/llhttpconstants.cpp b/indra/llmessage/llhttpconstants.cpp
old mode 100644
new mode 100755
index 1995fad1e5..016f1f1970
--- a/indra/llmessage/llhttpconstants.cpp
+++ b/indra/llmessage/llhttpconstants.cpp
@@ -2,31 +2,28 @@
  * @file llhttpconstants.cpp
  * @brief Implementation of the HTTP request / response constant lookups
  *
- * $LicenseInfo:firstyear=2013&license=viewergpl$
+ * $LicenseInfo:firstyear=2013&license=viewerlgpl$
  * 
  * Copyright (c) 2013, Linden Research, Inc.
  * 
  * Second Life Viewer Source Code
- * The source code in this file ("Source Code") is provided by Linden Lab
- * to you under the terms of the GNU General Public License, version 2.0
- * ("GPL"), unless you have obtained a separate licensing agreement
- * ("Other License"), formally executed by you and Linden Lab.  Terms of
- * the GPL can be found in doc/GPL-license.txt in this distribution, or
- * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * Copyright (C) 2013, Linden Research, Inc.
  * 
- * There are special exceptions to the terms and conditions of the GPL as
- * it is applied to this Source Code. View the full text of the exception
- * in the file doc/FLOSS-exception.txt in this software distribution, or
- * online at
- * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
  * 
- * By copying, modifying or distributing this software, you acknowledge
- * that you have read and understood your obligations described above,
- * and agree to abide by those obligations.
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
  * 
- * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
- * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
- * COMPLETENESS OR PERFORMANCE.
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
 
@@ -220,7 +217,8 @@ bool getSecondsUntilRetryAfter(const std::string& retry_after, F32& seconds_to_w
 	time_t date = curl_getdate(retry_after.c_str(), NULL );
 	if (-1 == date) return false;
 
-	seconds_to_wait = (F32)date - (F32)LLTimer::getTotalSeconds();
+	seconds_to_wait = (F64)date - LLTimer::getTotalSeconds();
+
 	return true;
 }
 
diff --git a/indra/newview/tests/llhttpretrypolicy_test.cpp b/indra/newview/tests/llhttpretrypolicy_test.cpp
index 42bb9abe90..6fa3a57364 100755
--- a/indra/newview/tests/llhttpretrypolicy_test.cpp
+++ b/indra/newview/tests/llhttpretrypolicy_test.cpp
@@ -216,21 +216,23 @@ void RetryPolicyTestObject::test<6>()
 
 	time_t nowseconds;
 	time(&nowseconds);
-	std::string str3 = LLDate((F64)nowseconds).asRFC1123();
+	std::string str3 = LLDate((F64)(nowseconds+44)).asRFC1123();
 	seconds_to_wait = F32_MAX;
 	success = getSecondsUntilRetryAfter(str3, seconds_to_wait);
+	std::cerr << " str3 [" << str3 << "]" << std::endl;
 	ensure("parse 3", success);
-	ensure_approximately_equals("parse 3", seconds_to_wait, 0.0F, 6);
+	ensure_approximately_equals("parse 3", seconds_to_wait, 44.0F, 2);
 }
 
 // Test retry-after field in both llmessage and CoreHttp headers.
 template<> template<>
 void RetryPolicyTestObject::test<7>()
 {
+	std::cerr << "7 starts" << std::endl;
+	
 	LLSD sd_headers;
 	time_t nowseconds;
 	time(&nowseconds);
-	sd_headers[HTTP_IN_HEADER_RETRY_AFTER] = LLDate((F64)nowseconds).asRFC1123();
 	LLAdaptiveRetryPolicy policy(17.0,644.0,3.0,5);
 	F32 seconds_to_wait;
 	bool should_retry;
@@ -245,40 +247,40 @@ void RetryPolicyTestObject::test<7>()
 	ensure_approximately_equals("header 1", seconds_to_wait, 17.0F, 6);
 
 	// retry header should override, give delay of 0
+	std::string date_string = LLDate((F64)(nowseconds+7)).asRFC1123();
+	sd_headers[HTTP_IN_HEADER_RETRY_AFTER] = date_string;
 	policy.onFailure(503,sd_headers);
 	should_retry = policy.shouldRetry(seconds_to_wait);
 	ensure("header 2", should_retry);
-	ensure_approximately_equals("header 2", seconds_to_wait, 0.0F, 6);
-
-	// retry header in LLCore::HttpHeaders
-	{
-		LLCore::HttpResponse *response = new LLCore::HttpResponse();
-		LLCore::HttpHeaders *headers = new LLCore::HttpHeaders();
-		response->setStatus(503);
-		response->setHeaders(headers);
-		headers->append(HTTP_IN_HEADER_RETRY_AFTER, std::string("600"));
-		policy.onFailure(response);
-		should_retry = policy.shouldRetry(seconds_to_wait);
-		ensure("header 3",should_retry);
-		ensure_approximately_equals("header 3", seconds_to_wait, 600.0F, 6);
-		response->release();
-	}
-
-	// retry header in LLCore::HttpHeaders
-	{
-		LLCore::HttpResponse *response = new LLCore::HttpResponse();
-		LLCore::HttpHeaders *headers = new LLCore::HttpHeaders();
-		response->setStatus(503);
-		response->setHeaders(headers);
-		LLSD sd_headers;
-		time(&nowseconds);
-		headers->append(HTTP_IN_HEADER_RETRY_AFTER,LLDate((F64)nowseconds).asRFC1123());
-		policy.onFailure(response);
-		should_retry = policy.shouldRetry(seconds_to_wait);
-		ensure("header 4",should_retry);
-		ensure_approximately_equals("header 4", seconds_to_wait, 0.0F, 6);
-		response->release();
-	}
+	ensure_approximately_equals("header 2", seconds_to_wait, 7.0F, 2);
+
+	LLCore::HttpResponse *response;
+	LLCore::HttpHeaders *headers;
+
+	response = new LLCore::HttpResponse();
+	headers = new LLCore::HttpHeaders();
+	response->setStatus(503);
+	response->setHeaders(headers);
+	headers->append(HTTP_IN_HEADER_RETRY_AFTER, std::string("600"));
+	policy.onFailure(response);
+	should_retry = policy.shouldRetry(seconds_to_wait);
+	ensure("header 3",should_retry);
+	ensure_approximately_equals("header 3", seconds_to_wait, 600.0F, 6);
+	response->release();
+
+	response = new LLCore::HttpResponse();
+	headers = new LLCore::HttpHeaders();
+	response->setStatus(503);
+	response->setHeaders(headers);
+	time(&nowseconds);
+	date_string = LLDate((F64)(nowseconds+77)).asRFC1123();
+	std::cerr << "date_string [" << date_string << "]" << std::endl;
+	headers->append(HTTP_IN_HEADER_RETRY_AFTER,date_string);
+	policy.onFailure(response);
+	should_retry = policy.shouldRetry(seconds_to_wait);
+	ensure("header 4",should_retry);
+	ensure_approximately_equals("header 4", seconds_to_wait, 77.0F, 2);
+	response->release();
 
 	// Timeout should be clamped at max.
 	policy.onFailure(500,LLSD());
-- 
cgit v1.3


From e3bad9fb86c3f44ad67488402ce2e46743a2422e Mon Sep 17 00:00:00 2001
From: "Brad Payne (Vir Linden)" <vir@lindenlab.com>
Date: Tue, 16 Apr 2013 20:27:49 -0400
Subject: SH-4061 WIP - fix for build issues on mac, reset the retry policy on
 success.

---
 indra/newview/llhttpretrypolicy.cpp            | 18 ++++++++++---
 indra/newview/llhttpretrypolicy.h              | 16 +++++++++---
 indra/newview/lltexturefetch.cpp               |  4 +++
 indra/newview/tests/llhttpretrypolicy_test.cpp | 35 +++++++++++++++++++++-----
 indra/test/lltut.h                             | 10 ++++++++
 5 files changed, 69 insertions(+), 14 deletions(-)
 mode change 100644 => 100755 indra/test/lltut.h

(limited to 'indra/newview/tests')

diff --git a/indra/newview/llhttpretrypolicy.cpp b/indra/newview/llhttpretrypolicy.cpp
index 10b923be5a..80d97e4362 100755
--- a/indra/newview/llhttpretrypolicy.cpp
+++ b/indra/newview/llhttpretrypolicy.cpp
@@ -32,11 +32,16 @@ LLAdaptiveRetryPolicy::LLAdaptiveRetryPolicy(F32 min_delay, F32 max_delay, F32 b
 	mMinDelay(min_delay),
 	mMaxDelay(max_delay),
 	mBackoffFactor(backoff_factor),
-	mMaxRetries(max_retries),
-	mDelay(min_delay),
-	mRetryCount(0),
-	mShouldRetry(true)
+	mMaxRetries(max_retries)
 {
+	init();
+}
+
+void LLAdaptiveRetryPolicy::init()
+{
+	mDelay = mMinDelay;
+	mRetryCount = 0;
+	mShouldRetry = true;
 }
 
 bool LLAdaptiveRetryPolicy::getRetryAfter(const LLSD& headers, F32& retry_header_time)
@@ -59,6 +64,11 @@ bool LLAdaptiveRetryPolicy::getRetryAfter(const LLCore::HttpHeaders *headers, F3
 	return false;
 }
 
+void LLAdaptiveRetryPolicy::onSuccess()
+{
+	init();
+}
+
 void LLAdaptiveRetryPolicy::onFailure(S32 status, const LLSD& headers)
 {
 	F32 retry_header_time;
diff --git a/indra/newview/llhttpretrypolicy.h b/indra/newview/llhttpretrypolicy.h
index 6f63f047de..1fb0cac03f 100755
--- a/indra/newview/llhttpretrypolicy.h
+++ b/indra/newview/llhttpretrypolicy.h
@@ -42,7 +42,11 @@ class LLHTTPRetryPolicy: public LLThreadSafeRefCount
 {
 public:
 	LLHTTPRetryPolicy() {}
+
 	virtual ~LLHTTPRetryPolicy() {}
+	// Call after a sucess to reset retry state.
+
+	virtual void onSuccess() = 0;
 	// Call once after an HTTP failure to update state.
 	virtual void onFailure(S32 status, const LLSD& headers) = 0;
 
@@ -58,6 +62,9 @@ class LLAdaptiveRetryPolicy: public LLHTTPRetryPolicy
 public:
 	LLAdaptiveRetryPolicy(F32 min_delay, F32 max_delay, F32 backoff_factor, U32 max_retries);
 
+	// virtual
+	void onSuccess();
+	
 	// virtual
 	void onFailure(S32 status, const LLSD& headers);
 	// virtual
@@ -66,16 +73,17 @@ public:
 	bool shouldRetry(F32& seconds_to_wait) const;
 
 protected:
+	void init();
 	bool getRetryAfter(const LLSD& headers, F32& retry_header_time);
 	bool getRetryAfter(const LLCore::HttpHeaders *headers, F32& retry_header_time);
 	void onFailureCommon(S32 status, bool has_retry_header_time, F32 retry_header_time);
 
 private:
 
-	F32 mMinDelay; // delay never less than this value
-	F32 mMaxDelay; // delay never exceeds this value
-	F32 mBackoffFactor; // delay increases by this factor after each retry, up to mMaxDelay.
-	U32 mMaxRetries; // maximum number of times shouldRetry will return true.
+	const F32 mMinDelay; // delay never less than this value
+	const F32 mMaxDelay; // delay never exceeds this value
+	const F32 mBackoffFactor; // delay increases by this factor after each retry, up to mMaxDelay.
+	const U32 mMaxRetries; // maximum number of times shouldRetry will return true.
 	F32 mDelay; // current default delay.
 	U32 mRetryCount; // number of times shouldRetry has been called.
 	LLTimer mRetryTimer; // time until next retry.
diff --git a/indra/newview/lltexturefetch.cpp b/indra/newview/lltexturefetch.cpp
index 1a6a308230..774c925fa1 100755
--- a/indra/newview/lltexturefetch.cpp
+++ b/indra/newview/lltexturefetch.cpp
@@ -1976,6 +1976,10 @@ void LLTextureFetchWorker::onCompleted(LLCore::HttpHandle handle, LLCore::HttpRe
 			llinfos << mID << " will not retry" << llendl;
 		}
 	}
+	else
+	{
+		mFetchRetryPolicy.onSuccess();
+	}
 	
 	LL_DEBUGS("Texture") << "HTTP COMPLETE: " << mID
 						 << " status: " << status.toHex()
diff --git a/indra/newview/tests/llhttpretrypolicy_test.cpp b/indra/newview/tests/llhttpretrypolicy_test.cpp
index 6fa3a57364..ed7f3ba326 100755
--- a/indra/newview/tests/llhttpretrypolicy_test.cpp
+++ b/indra/newview/tests/llhttpretrypolicy_test.cpp
@@ -45,7 +45,7 @@ void RetryPolicyTestObject::test<1>()
 	LLSD headers;
 	F32 wait_seconds;
 	
-	// No retry until we've finished a try.
+	// No retry until we've failed a try.
 	ensure("never retry 0", !never_retry.shouldRetry(wait_seconds));
 
 	// 0 retries max.
@@ -74,7 +74,7 @@ void RetryPolicyTestObject::test<3>()
 	bool should_retry;
 	U32 frac_bits = 6;
 
-	// No retry until we've finished a try.
+	// No retry until we've failed a try.
 	ensure("basic_retry 0", !basic_retry.shouldRetry(wait_seconds));
 
 	// Starting wait 1.0
@@ -105,6 +105,29 @@ void RetryPolicyTestObject::test<3>()
 	basic_retry.onFailure(500,headers);
 	should_retry = basic_retry.shouldRetry(wait_seconds);
 	ensure("basic_retry 5", !should_retry);
+
+	// Max retries, should fail now.
+	basic_retry.onFailure(500,headers);
+	should_retry = basic_retry.shouldRetry(wait_seconds);
+	ensure("basic_retry 5", !should_retry);
+
+	// After a success, should reset to the starting state.
+	basic_retry.onSuccess();
+
+	// No retry until we've failed a try.
+	ensure("basic_retry 6", !basic_retry.shouldRetry(wait_seconds));
+
+	// Starting wait 1.0
+	basic_retry.onFailure(500,headers);
+	should_retry = basic_retry.shouldRetry(wait_seconds);
+	ensure("basic_retry 7", should_retry);
+	ensure_approximately_equals("basic_retry 7", wait_seconds, 1.0F, frac_bits);
+
+	// Double wait to 2.0
+	basic_retry.onFailure(500,headers);
+	should_retry = basic_retry.shouldRetry(wait_seconds);
+	ensure("basic_retry 8", should_retry);
+	ensure_approximately_equals("basic_retry 8", wait_seconds, 2.0F, frac_bits);
 }
 
 // Retries should stop as soon as a non-5xx error is received.
@@ -221,7 +244,7 @@ void RetryPolicyTestObject::test<6>()
 	success = getSecondsUntilRetryAfter(str3, seconds_to_wait);
 	std::cerr << " str3 [" << str3 << "]" << std::endl;
 	ensure("parse 3", success);
-	ensure_approximately_equals("parse 3", seconds_to_wait, 44.0F, 2);
+	ensure_approximately_equals_range("parse 3", seconds_to_wait, 44.0F, 2.0F);
 }
 
 // Test retry-after field in both llmessage and CoreHttp headers.
@@ -237,7 +260,7 @@ void RetryPolicyTestObject::test<7>()
 	F32 seconds_to_wait;
 	bool should_retry;
 
-	// No retry until we've finished a try.
+	// No retry until we've failed a try.
 	ensure("header 0", !policy.shouldRetry(seconds_to_wait));
 	
 	// no retry header, use default.
@@ -252,7 +275,7 @@ void RetryPolicyTestObject::test<7>()
 	policy.onFailure(503,sd_headers);
 	should_retry = policy.shouldRetry(seconds_to_wait);
 	ensure("header 2", should_retry);
-	ensure_approximately_equals("header 2", seconds_to_wait, 7.0F, 2);
+	ensure_approximately_equals_range("header 2", seconds_to_wait, 7.0F, 2.0F);
 
 	LLCore::HttpResponse *response;
 	LLCore::HttpHeaders *headers;
@@ -279,7 +302,7 @@ void RetryPolicyTestObject::test<7>()
 	policy.onFailure(response);
 	should_retry = policy.shouldRetry(seconds_to_wait);
 	ensure("header 4",should_retry);
-	ensure_approximately_equals("header 4", seconds_to_wait, 77.0F, 2);
+	ensure_approximately_equals_range("header 4", seconds_to_wait, 77.0F, 2.0F);
 	response->release();
 
 	// Timeout should be clamped at max.
diff --git a/indra/test/lltut.h b/indra/test/lltut.h
old mode 100644
new mode 100755
index 55d84bcaca..243e869be7
--- a/indra/test/lltut.h
+++ b/indra/test/lltut.h
@@ -65,6 +65,16 @@ namespace tut
 		ensure_approximately_equals(NULL, actual, expected, frac_bits);
 	}
 
+	inline void ensure_approximately_equals_range(const char *msg, F32 actual, F32 expected, F32 delta)
+	{
+		if (fabs(actual-expected)>delta)
+		{
+			std::stringstream ss;
+			ss << (msg?msg:"") << (msg?": ":"") << "not equal actual: " << actual << " expected: " << expected << " tolerance: " << delta;
+			throw tut::failure(ss.str().c_str());
+		}
+	}
+
 	inline void ensure_memory_matches(const char* msg,const void* actual, U32 actual_len, const void* expected,U32 expected_len)
 	{
 		if((expected_len != actual_len) || 
-- 
cgit v1.3


From 96a2173c643e145a6f5d4964282c4d43f0fc0c3e Mon Sep 17 00:00:00 2001
From: "Brad Payne (Vir Linden)" <vir@lindenlab.com>
Date: Fri, 10 May 2013 09:32:30 -0400
Subject: SH-4176 WIP - allow retries on 4xx errors if enabled by flag. So
 enable in the case of appearance requests.

---
 indra/newview/llappearancemgr.cpp              |  3 ++-
 indra/newview/llhttpretrypolicy.cpp            |  7 ++++---
 indra/newview/llhttpretrypolicy.h              |  3 ++-
 indra/newview/tests/llhttpretrypolicy_test.cpp | 15 +++++++++++----
 4 files changed, 19 insertions(+), 9 deletions(-)

(limited to 'indra/newview/tests')

diff --git a/indra/newview/llappearancemgr.cpp b/indra/newview/llappearancemgr.cpp
index 3c141aa37a..84a494186f 100755
--- a/indra/newview/llappearancemgr.cpp
+++ b/indra/newview/llappearancemgr.cpp
@@ -2871,7 +2871,8 @@ class RequestAgentUpdateAppearanceResponder: public LLHTTPClient::Responder
 public:
 	RequestAgentUpdateAppearanceResponder()
 	{
-		mRetryPolicy = new LLAdaptiveRetryPolicy(1.0, 32.0, 2.0, 10);
+		bool retry_on_4xx = true;
+		mRetryPolicy = new LLAdaptiveRetryPolicy(1.0, 32.0, 2.0, 10, retry_on_4xx);
 	}
 
 	virtual ~RequestAgentUpdateAppearanceResponder()
diff --git a/indra/newview/llhttpretrypolicy.cpp b/indra/newview/llhttpretrypolicy.cpp
index 80d97e4362..1512b46103 100755
--- a/indra/newview/llhttpretrypolicy.cpp
+++ b/indra/newview/llhttpretrypolicy.cpp
@@ -28,11 +28,12 @@
 
 #include "llhttpretrypolicy.h"
 
-LLAdaptiveRetryPolicy::LLAdaptiveRetryPolicy(F32 min_delay, F32 max_delay, F32 backoff_factor, U32 max_retries):
+LLAdaptiveRetryPolicy::LLAdaptiveRetryPolicy(F32 min_delay, F32 max_delay, F32 backoff_factor, U32 max_retries, bool retry_on_4xx):
 	mMinDelay(min_delay),
 	mMaxDelay(max_delay),
 	mBackoffFactor(backoff_factor),
-	mMaxRetries(max_retries)
+	mMaxRetries(max_retries),
+	mRetryOn4xx(retry_on_4xx)
 {
 	init();
 }
@@ -108,7 +109,7 @@ void LLAdaptiveRetryPolicy::onFailureCommon(S32 status, bool has_retry_header_ti
 		llinfos << "Too many retries " << mRetryCount << ", will not retry" << llendl;
 		mShouldRetry = false;
 	}
-	if (!isHttpServerErrorStatus(status))
+	if (!mRetryOn4xx && !isHttpServerErrorStatus(status))
 	{
 		llinfos << "Non-server error " << status << ", will not retry" << llendl;
 		mShouldRetry = false;
diff --git a/indra/newview/llhttpretrypolicy.h b/indra/newview/llhttpretrypolicy.h
index 1fb0cac03f..5b1a1d79e0 100755
--- a/indra/newview/llhttpretrypolicy.h
+++ b/indra/newview/llhttpretrypolicy.h
@@ -60,7 +60,7 @@ public:
 class LLAdaptiveRetryPolicy: public LLHTTPRetryPolicy
 {
 public:
-	LLAdaptiveRetryPolicy(F32 min_delay, F32 max_delay, F32 backoff_factor, U32 max_retries);
+	LLAdaptiveRetryPolicy(F32 min_delay, F32 max_delay, F32 backoff_factor, U32 max_retries, bool retry_on_4xx = false);
 
 	// virtual
 	void onSuccess();
@@ -88,6 +88,7 @@ private:
 	U32 mRetryCount; // number of times shouldRetry has been called.
 	LLTimer mRetryTimer; // time until next retry.
 	bool mShouldRetry; // Becomes false after too many retries, or the wrong sort of status received, etc.
+	bool mRetryOn4xx; // Normally only retry on 5xx server errors.
 };
 
 #endif
diff --git a/indra/newview/tests/llhttpretrypolicy_test.cpp b/indra/newview/tests/llhttpretrypolicy_test.cpp
index ed7f3ba326..25e6de46d9 100755
--- a/indra/newview/tests/llhttpretrypolicy_test.cpp
+++ b/indra/newview/tests/llhttpretrypolicy_test.cpp
@@ -56,12 +56,19 @@ void RetryPolicyTestObject::test<1>()
 template<> template<>
 void RetryPolicyTestObject::test<2>()
 {
-	LLAdaptiveRetryPolicy retry404(1.0,2.0,3.0,10);
 	LLSD headers;
 	F32 wait_seconds;
-	
-	retry404.onFailure(404,headers);
-	ensure("no retry on 404", !retry404.shouldRetry(wait_seconds)); 
+
+	// Normally only retry on server error (5xx)
+	LLAdaptiveRetryPolicy noRetry404(1.0,2.0,3.0,10);
+	noRetry404.onFailure(404,headers);
+	ensure("no retry on 404", !noRetry404.shouldRetry(wait_seconds)); 
+
+	// Can retry on 4xx errors if enabled by flag.
+	bool do_retry_4xx = true;
+	LLAdaptiveRetryPolicy doRetry404(1.0,2.0,3.0,10,do_retry_4xx);
+	doRetry404.onFailure(404,headers);
+	ensure("do retry on 404", doRetry404.shouldRetry(wait_seconds)); 
 }
 
 template<> template<>
-- 
cgit v1.3