329 lines
12 KiB
C++
329 lines
12 KiB
C++
/**
|
|
* @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;
|
|
|
|
// No retry until we've failed a try.
|
|
ensure("never retry 0", !never_retry.shouldRetry(wait_seconds));
|
|
|
|
// 0 retries max.
|
|
never_retry.onFailure(500,headers);
|
|
ensure("never retry 1", !never_retry.shouldRetry(wait_seconds));
|
|
}
|
|
|
|
template<> template<>
|
|
void RetryPolicyTestObject::test<2>()
|
|
{
|
|
LLSD headers;
|
|
F32 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<>
|
|
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;
|
|
|
|
// No retry until we've failed 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);
|
|
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);
|
|
|
|
// 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.
|
|
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 = LLAdaptiveRetryPolicy::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 = LLAdaptiveRetryPolicy::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+44)).asRFC1123();
|
|
seconds_to_wait = F32_MAX;
|
|
success = LLAdaptiveRetryPolicy::getSecondsUntilRetryAfter(str3, seconds_to_wait);
|
|
std::cerr << " str3 [" << str3 << "]" << std::endl;
|
|
ensure("parse 3", success);
|
|
ensure_approximately_equals_range("parse 3", seconds_to_wait, 44.0F, 2.0F);
|
|
}
|
|
|
|
// 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);
|
|
LLAdaptiveRetryPolicy policy(17.0,644.0,3.0,5);
|
|
F32 seconds_to_wait;
|
|
bool should_retry;
|
|
|
|
// No retry until we've failed 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);
|
|
ensure("header 1", should_retry);
|
|
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_range("header 2", seconds_to_wait, 7.0F, 2.0F);
|
|
|
|
LLCore::HttpResponse *response;
|
|
LLCore::HttpHeaders::ptr_t headers;
|
|
|
|
response = new LLCore::HttpResponse();
|
|
headers = LLCore::HttpHeaders::ptr_t(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 = LLCore::HttpHeaders::ptr_t(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_range("header 4", seconds_to_wait, 77.0F, 2.0F);
|
|
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);
|
|
}
|
|
|
|
}
|
|
|