summaryrefslogtreecommitdiff
path: root/indra/llmessage/llexperiencecache.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'indra/llmessage/llexperiencecache.cpp')
-rw-r--r--indra/llmessage/llexperiencecache.cpp1030
1 files changed, 525 insertions, 505 deletions
diff --git a/indra/llmessage/llexperiencecache.cpp b/indra/llmessage/llexperiencecache.cpp
index 52b60a176e..36a4fc8823 100644
--- a/indra/llmessage/llexperiencecache.cpp
+++ b/indra/llmessage/llexperiencecache.cpp
@@ -26,616 +26,636 @@
#include "llexperiencecache.h"
#include "llavatarname.h"
-#include "llframetimer.h"
#include "llhttpclient.h"
#include "llsdserialize.h"
+#include "llcoros.h"
+#include "lleventcoro.h"
+#include "lleventfilter.h"
+#include "llcoproceduremanager.h"
+#include "lldir.h"
#include <set>
#include <map>
-#include "boost/tokenizer.hpp"
+#include <boost/tokenizer.hpp>
+#include <boost/concept_check.hpp>
-
-namespace LLExperienceCache
+//=========================================================================
+namespace LLExperienceCacheImpl
{
+ void mapKeys(const LLSD& legacyKeys);
+ F64 getErrorRetryDeltaTime(S32 status, LLSD headers);
+ bool maxAgeFromCacheControl(const std::string& cache_control, S32 *max_age);
- typedef std::map<LLUUID, LLUUID> KeyMap;
- KeyMap privateToPublicKeyMap;
-
- void mapKeys(const LLSD& legacyKeys);
+ static const std::string PRIVATE_KEY = "private_id";
+ static const std::string EXPERIENCE_ID = "public_id";
- std::string sLookupURL;
+ static const std::string MAX_AGE("max-age");
+ static const boost::char_separator<char> EQUALS_SEPARATOR("=");
+ static const boost::char_separator<char> COMMA_SEPARATOR(",");
- typedef std::map<LLUUID, std::string> ask_queue_t;
- ask_queue_t sAskQueue;
-
- typedef std::map<LLUUID, F64> pending_queue_t;
- pending_queue_t sPendingQueue;
+ // *TODO$: this seems to be tied to mapKeys which is used by bootstrap.... but I don't think that bootstrap is used.
+ typedef std::map<LLUUID, LLUUID> KeyMap;
+ KeyMap privateToPublicKeyMap;
+}
- cache_t sCache;
- int sMaximumLookups = 10;
+//=========================================================================
+const std::string LLExperienceCache::PRIVATE_KEY = "private_id";
+const std::string LLExperienceCache::MISSING = "DoesNotExist";
+
+const std::string LLExperienceCache::AGENT_ID = "agent_id";
+const std::string LLExperienceCache::GROUP_ID = "group_id";
+const std::string LLExperienceCache::EXPERIENCE_ID = "public_id";
+const std::string LLExperienceCache::NAME = "name";
+const std::string LLExperienceCache::PROPERTIES = "properties";
+const std::string LLExperienceCache::EXPIRES = "expiration";
+const std::string LLExperienceCache::DESCRIPTION = "description";
+const std::string LLExperienceCache::QUOTA = "quota";
+const std::string LLExperienceCache::MATURITY = "maturity";
+const std::string LLExperienceCache::METADATA = "extended_metadata";
+const std::string LLExperienceCache::SLURL = "slurl";
+
+// should be in sync with experience-api/experiences/models.py
+const int LLExperienceCache::PROPERTY_INVALID = 1 << 0;
+const int LLExperienceCache::PROPERTY_PRIVILEGED = 1 << 3;
+const int LLExperienceCache::PROPERTY_GRID = 1 << 4;
+const int LLExperienceCache::PROPERTY_PRIVATE = 1 << 5;
+const int LLExperienceCache::PROPERTY_DISABLED = 1 << 6;
+const int LLExperienceCache::PROPERTY_SUSPENDED = 1 << 7;
+
+// default values
+const F64 LLExperienceCache::DEFAULT_EXPIRATION = 600.0;
+const S32 LLExperienceCache::DEFAULT_QUOTA = 128; // this is megabytes
+
+//=========================================================================
+LLExperienceCache::LLExperienceCache():
+ mShutdown(false)
+{
+}
- LLFrameTimer sRequestTimer;
+LLExperienceCache::~LLExperienceCache()
+{
- // Periodically clean out expired entries from the cache
- LLFrameTimer sEraseExpiredTimer;
+}
- // May have multiple callbacks for a single ID, which are
- // represented as multiple slots bound to the signal.
- // Avoid copying signals via pointers.
- typedef std::map<LLUUID, callback_signal_t*> signal_map_t;
- signal_map_t sSignalMap;
+void LLExperienceCache::initSingleton()
+{
+ mCacheFileName = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, "experience_cache.xml");
+ LL_INFOS("ExperienceCache") << "Loading " << mCacheFileName << LL_ENDL;
+ llifstream cache_stream(mCacheFileName.c_str());
+ if (cache_stream.is_open())
+ {
+ cache_stream >> (*this);
+ }
- bool max_age_from_cache_control(const std::string& cache_control, S32 *max_age);
- void eraseExpired();
+ LLCoros::instance().launch("LLExperienceCache::idleCoro",
+ boost::bind(&LLExperienceCache::idleCoro, this));
- void processExperience( const LLUUID& public_key, const LLSD& experience )
- {
- sCache[public_key]=experience;
- LLSD & row = sCache[public_key];
+}
- if(row.has(EXPIRES))
- {
- row[EXPIRES] = row[EXPIRES].asReal() + LLFrameTimer::getTotalSeconds();
- }
+void LLExperienceCache::cleanup()
+{
+ LL_INFOS("ExperienceCache") << "Saving " << mCacheFileName << LL_ENDL;
+
+ llofstream cache_stream(mCacheFileName.c_str());
+ if (cache_stream.is_open())
+ {
+ cache_stream << (*this);
+ }
+ mShutdown = true;
+}
- if(row.has(EXPERIENCE_ID))
- {
- sPendingQueue.erase(row[EXPERIENCE_ID].asUUID());
- }
+//-------------------------------------------------------------------------
+void LLExperienceCache::importFile(std::istream& istr)
+{
+ LLSD data;
+ S32 parse_count = LLSDSerialize::fromXMLDocument(data, istr);
+ if (parse_count < 1) return;
- //signal
- signal_map_t::iterator sig_it = sSignalMap.find(public_key);
- if (sig_it != sSignalMap.end())
- {
- callback_signal_t* signal = sig_it->second;
- (*signal)(experience);
+ LLSD experiences = data["experiences"];
- sSignalMap.erase(public_key);
+ LLUUID public_key;
+ LLSD::map_const_iterator it = experiences.beginMap();
+ for (; it != experiences.endMap(); ++it)
+ {
+ public_key.set(it->first);
+ mCache[public_key] = it->second;
+ }
- delete signal;
- }
- }
+ LL_DEBUGS("ExperienceCache") << "importFile() loaded " << mCache.size() << LL_ENDL;
+}
- void initClass( )
- {
- }
+void LLExperienceCache::exportFile(std::ostream& ostr) const
+{
+ LLSD experiences;
- const cache_t& getCached()
- {
- return sCache;
- }
+ cache_t::const_iterator it = mCache.begin();
+ for (; it != mCache.end(); ++it)
+ {
+ if (!it->second.has(EXPERIENCE_ID) || it->second[EXPERIENCE_ID].asUUID().isNull() ||
+ it->second.has("DoesNotExist") || (it->second.has(PROPERTIES) && it->second[PROPERTIES].asInteger() & PROPERTY_INVALID))
+ continue;
- void setMaximumLookups( int maximumLookups)
- {
- sMaximumLookups = maximumLookups;
- }
+ experiences[it->first.asString()] = it->second;
+ }
- void bootstrap(const LLSD& legacyKeys, int initialExpiration)
- {
- mapKeys(legacyKeys);
- LLSD::array_const_iterator it = legacyKeys.beginArray();
- for(/**/; it != legacyKeys.endArray(); ++it)
- {
- LLSD experience = *it;
- if(experience.has(EXPERIENCE_ID))
- {
- if(!experience.has(EXPIRES))
- {
- experience[EXPIRES] = initialExpiration;
- }
- processExperience(experience[EXPERIENCE_ID].asUUID(), experience);
- }
- else
- {
- LL_WARNS("ExperienceCache")
- << "Skipping bootstrap entry which is missing " << EXPERIENCE_ID
- << LL_ENDL;
- }
- }
- }
+ LLSD data;
+ data["experiences"] = experiences;
+ LLSDSerialize::toPrettyXML(data, ostr);
+}
+// *TODO$: Rider: This method does not seem to be used... it may be useful in testing.
+void LLExperienceCache::bootstrap(const LLSD& legacyKeys, int initialExpiration)
+{
+ LLExperienceCacheImpl::mapKeys(legacyKeys);
+ LLSD::array_const_iterator it = legacyKeys.beginArray();
+ for (/**/; it != legacyKeys.endArray(); ++it)
+ {
+ LLSD experience = *it;
+ if (experience.has(EXPERIENCE_ID))
+ {
+ if (!experience.has(EXPIRES))
+ {
+ experience[EXPIRES] = initialExpiration;
+ }
+ processExperience(experience[EXPERIENCE_ID].asUUID(), experience);
+ }
+ else
+ {
+ LL_WARNS("ExperienceCache")
+ << "Skipping bootstrap entry which is missing " << EXPERIENCE_ID
+ << LL_ENDL;
+ }
+ }
+}
- bool expirationFromCacheControl(LLSD headers, F64 *expires)
- {
- // Allow the header to override the default
- LLSD cache_control_header = headers["cache-control"];
- if (cache_control_header.isDefined())
- {
- S32 max_age = 0;
- std::string cache_control = cache_control_header.asString();
- if (max_age_from_cache_control(cache_control, &max_age))
- {
- LL_WARNS("ExperienceCache")
- << "got EXPIRES from headers, max_age " << max_age
- << LL_ENDL;
- F64 now = LLFrameTimer::getTotalSeconds();
- *expires = now + (F64)max_age;
- return true;
- }
- }
- return false;
- }
+LLUUID LLExperienceCache::getExperienceId(const LLUUID& private_key, bool null_if_not_found)
+{
+ if (private_key.isNull())
+ return LLUUID::null;
+
+ LLExperienceCacheImpl::KeyMap::const_iterator it = LLExperienceCacheImpl::privateToPublicKeyMap.find(private_key);
+ if (it == LLExperienceCacheImpl::privateToPublicKeyMap.end())
+ {
+ if (null_if_not_found)
+ {
+ return LLUUID::null;
+ }
+ return private_key;
+ }
+ LL_WARNS("LLExperience") << "converted private key " << private_key << " to experience_id " << it->second << LL_ENDL;
+ return it->second;
+}
+//=========================================================================
+void LLExperienceCache::processExperience(const LLUUID& public_key, const LLSD& experience)
+{
+ LL_INFOS("ExperienceCache") << "Processing experience \"" << experience[NAME] << "\" with key " << public_key.asString() << LL_ENDL;
- static const std::string MAX_AGE("max-age");
- static const boost::char_separator<char> EQUALS_SEPARATOR("=");
- static const boost::char_separator<char> COMMA_SEPARATOR(",");
+ mCache[public_key]=experience;
+ LLSD & row = mCache[public_key];
- bool max_age_from_cache_control(const std::string& cache_control, S32 *max_age)
+ if(row.has(EXPIRES))
{
- // Split the string on "," to get a list of directives
- typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
- tokenizer directives(cache_control, COMMA_SEPARATOR);
-
- tokenizer::iterator token_it = directives.begin();
- for ( ; token_it != directives.end(); ++token_it)
- {
- // Tokens may have leading or trailing whitespace
- std::string token = *token_it;
- LLStringUtil::trim(token);
-
- if (token.compare(0, MAX_AGE.size(), MAX_AGE) == 0)
- {
- // ...this token starts with max-age, so let's chop it up by "="
- tokenizer subtokens(token, EQUALS_SEPARATOR);
- tokenizer::iterator subtoken_it = subtokens.begin();
-
- // Must have a token
- if (subtoken_it == subtokens.end()) return false;
- std::string subtoken = *subtoken_it;
-
- // Must exactly equal "max-age"
- LLStringUtil::trim(subtoken);
- if (subtoken != MAX_AGE) return false;
-
- // Must have another token
- ++subtoken_it;
- if (subtoken_it == subtokens.end()) return false;
- subtoken = *subtoken_it;
-
- // Must be a valid integer
- // *NOTE: atoi() returns 0 for invalid values, so we have to
- // check the string first.
- // *TODO: Do servers ever send "0000" for zero? We don't handle it
- LLStringUtil::trim(subtoken);
- if (subtoken == "0")
- {
- *max_age = 0;
- return true;
- }
- S32 val = atoi( subtoken.c_str() );
- if (val > 0 && val < S32_MAX)
- {
- *max_age = val;
- return true;
- }
- return false;
- }
- }
- return false;
+ row[EXPIRES] = row[EXPIRES].asReal() + LLFrameTimer::getTotalSeconds();
}
-
- void importFile(std::istream& istr)
+ if(row.has(EXPERIENCE_ID))
{
- LLSD data;
- S32 parse_count = LLSDSerialize::fromXMLDocument(data, istr);
- if(parse_count < 1) return;
-
- LLSD experiences = data["experiences"];
-
- LLUUID public_key;
- LLSD::map_const_iterator it = experiences.beginMap();
- for(; it != experiences.endMap() ; ++it)
- {
- public_key.set(it->first);
- sCache[public_key]=it->second;
- }
-
- LL_DEBUGS("ExperienceCache") << "importFile() loaded " << sCache.size() << LL_ENDL;
+ mPendingQueue.erase(row[EXPERIENCE_ID].asUUID());
}
- void exportFile(std::ostream& ostr)
+ //signal
+ signal_map_t::iterator sig_it = mSignalMap.find(public_key);
+ if (sig_it != mSignalMap.end())
{
- LLSD experiences;
+ signal_ptr signal = sig_it->second;
+ (*signal)(experience);
- cache_t::const_iterator it =sCache.begin();
- for( ; it != sCache.end() ; ++it)
- {
- if(!it->second.has(EXPERIENCE_ID) || it->second[EXPERIENCE_ID].asUUID().isNull() ||
- it->second.has("DoesNotExist") || (it->second.has(PROPERTIES) && it->second[PROPERTIES].asInteger() & PROPERTY_INVALID))
- continue;
-
- experiences[it->first.asString()] = it->second;
- }
-
- LLSD data;
- data["experiences"] = experiences;
-
- LLSDSerialize::toPrettyXML(data, ostr);
+ mSignalMap.erase(public_key);
}
+}
- class LLExperienceResponder : public LLHTTPClient::Responder
- {
- public:
- LLExperienceResponder(const ask_queue_t& keys)
- :mKeys(keys)
- {
-
- }
-
- /*virtual*/ void httpCompleted()
- {
- LLSD experiences = getContent()["experience_keys"];
- LLSD::array_const_iterator it = experiences.beginArray();
- for( /**/ ; it != experiences.endArray(); ++it)
- {
- const LLSD& row = *it;
- LLUUID public_key = row[EXPERIENCE_ID].asUUID();
-
-
- LL_DEBUGS("ExperienceCache") << "Received result for " << public_key
- << " display '" << row[LLExperienceCache::NAME].asString() << "'" << LL_ENDL ;
-
- processExperience(public_key, row);
- }
-
- LLSD error_ids = getContent()["error_ids"];
- LLSD::array_const_iterator errIt = error_ids.beginArray();
- for( /**/ ; errIt != error_ids.endArray() ; ++errIt )
- {
- LLUUID id = errIt->asUUID();
- LLSD exp;
- exp[EXPIRES]=DEFAULT_EXPIRATION;
- exp[EXPERIENCE_ID] = id;
- exp[PROPERTIES]=PROPERTY_INVALID;
- exp[MISSING]=true;
- exp[QUOTA] = DEFAULT_QUOTA;
-
- processExperience(id, exp);
- LL_WARNS("ExperienceCache") << "LLExperienceResponder::result() error result for " << id << LL_ENDL ;
- }
-
- LL_DEBUGS("ExperienceCache") << sCache.size() << " cached experiences" << LL_ENDL;
- }
+const LLExperienceCache::cache_t& LLExperienceCache::getCached()
+{
+ return mCache;
+}
- /*virtual*/ void httpFailure()
- {
- LL_WARNS("ExperienceCache") << "Request failed "<<getStatus()<<" "<<getReason()<< LL_ENDL;
- // We're going to construct a dummy record and cache it for a while,
- // either briefly for a 503 Service Unavailable, or longer for other
- // errors.
- F64 retry_timestamp = errorRetryTimestamp(getStatus());
-
-
- // Add dummy records for all agent IDs in this request
- ask_queue_t::const_iterator it = mKeys.begin();
- for ( ; it != mKeys.end(); ++it)
- {
+void LLExperienceCache::requestExperiencesCoro(LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t &httpAdapter, std::string url, RequestQueue_t requests)
+{
+ LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest());
+
+ //LL_INFOS("requestExperiencesCoro") << "url: " << url << LL_ENDL;
+
+ LLSD result = httpAdapter->getAndYield(httpRequest, url);
+
+ LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
+ LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
+
+ if (!status)
+ {
+ F64 now = LLFrameTimer::getTotalSeconds();
+
+ LLSD headers = httpResults[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS_HEADERS];
+ // build dummy entries for the failed requests
+ for (RequestQueue_t::const_iterator it = requests.begin(); it != requests.end(); ++it)
+ {
+ LLSD exp = get(*it);
+ //leave the properties alone if we already have a cache entry for this xp
+ if (exp.isUndefined())
+ {
+ exp[PROPERTIES] = PROPERTY_INVALID;
+ }
+ exp[EXPIRES] = now + LLExperienceCacheImpl::getErrorRetryDeltaTime(status, headers);
+ exp[EXPERIENCE_ID] = *it;
+ exp["key_type"] = EXPERIENCE_ID;
+ exp["uuid"] = *it;
+ exp["error"] = (LLSD::Integer)status.getType();
+ exp[QUOTA] = DEFAULT_QUOTA;
+
+ processExperience(*it, exp);
+ }
+ return;
+ }
+
+ LLSD experiences = result["experience_keys"];
+
+ for (LLSD::array_const_iterator it = experiences.beginArray();
+ it != experiences.endArray(); ++it)
+ {
+ const LLSD& row = *it;
+ LLUUID public_key = row[EXPERIENCE_ID].asUUID();
+
+ LL_DEBUGS("ExperienceCache") << "Received result for " << public_key
+ << " display '" << row[LLExperienceCache::NAME].asString() << "'" << LL_ENDL;
+
+ processExperience(public_key, row);
+ }
+
+ LLSD error_ids = result["error_ids"];
+
+ for (LLSD::array_const_iterator errIt = error_ids.beginArray();
+ errIt != error_ids.endArray(); ++errIt)
+ {
+ LLUUID id = errIt->asUUID();
+ LLSD exp;
+ exp[EXPIRES] = DEFAULT_EXPIRATION;
+ exp[EXPERIENCE_ID] = id;
+ exp[PROPERTIES] = PROPERTY_INVALID;
+ exp[MISSING] = true;
+ exp[QUOTA] = DEFAULT_QUOTA;
+
+ processExperience(id, exp);
+ LL_WARNS("ExperienceCache") << "LLExperienceResponder::result() error result for " << id << LL_ENDL;
+ }
- LLSD exp = get(it->first);
- //leave the properties alone if we already have a cache entry for this xp
- if(exp.isUndefined())
- {
- exp[PROPERTIES]=PROPERTY_INVALID;
- }
- exp[EXPIRES]=retry_timestamp;
- exp[EXPERIENCE_ID] = it->first;
- exp["key_type"] = it->second;
- exp["uuid"] = it->first;
- exp["error"] = (LLSD::Integer)getStatus();
- exp[QUOTA] = DEFAULT_QUOTA;
-
- LLExperienceCache::processExperience(it->first, exp);
- }
+}
- }
- // Return time to retry a request that generated an error, based on
- // error type and headers. Return value is seconds-since-epoch.
- F64 errorRetryTimestamp(S32 status)
- {
-
- // Retry-After takes priority
- LLSD retry_after = getResponseHeaders()["retry-after"];
- if (retry_after.isDefined())
- {
- // We only support the delta-seconds type
- S32 delta_seconds = retry_after.asInteger();
- if (delta_seconds > 0)
- {
- // ...valid delta-seconds
- return F64(delta_seconds);
- }
- }
+void LLExperienceCache::requestExperiences()
+{
+ if (mCapability.empty())
+ {
+ LL_WARNS("ExperienceCache") << "Capability query method not set." << LL_ENDL;
+ return;
+ }
+
+ std::string urlBase = mCapability("GetExperienceInfo");
+ if (urlBase.empty())
+ {
+ LL_WARNS("ExperienceCache") << "No Experience capability." << LL_ENDL;
+ return;
+ }
+
+ if (*urlBase.rbegin() != '/')
+ {
+ urlBase += "/";
+ }
+ urlBase += "id/";
+
+
+ F64 now = LLFrameTimer::getTotalSeconds();
+
+ const U32 EXP_URL_SEND_THRESHOLD = 3000;
+ const U32 PAGE_SIZE = EXP_URL_SEND_THRESHOLD / UUID_STR_LENGTH;
+
+ std::ostringstream ostr;
+ ostr << urlBase << "?page_size=" << PAGE_SIZE;
+ RequestQueue_t requests;
+
+ while (!mRequestQueue.empty())
+ {
+ RequestQueue_t::iterator it = mRequestQueue.begin();
+ LLUUID key = (*it);
+ mRequestQueue.erase(it);
+ requests.insert(key);
+
+ ostr << "&" << EXPERIENCE_ID << "=" << key.asString();
+ mPendingQueue[key] = now;
+
+ if (mRequestQueue.empty() || (ostr.tellp() > EXP_URL_SEND_THRESHOLD))
+ { // request is placed in the coprocedure pool for the ExpCache cache. Throttling is done by the pool itself.
+ LLCoprocedureManager::getInstance()->enqueueCoprocedure("ExpCache", "Request",
+ boost::bind(&LLExperienceCache::requestExperiencesCoro, this, _1, ostr.str(), requests) );
+
+ ostr.str(std::string());
+ ostr << urlBase << "?page_size=" << PAGE_SIZE;
+ requests.clear();
+ }
+ }
- // If no Retry-After, look for Cache-Control max-age
- F64 expires = 0.0;
- if (LLExperienceCache::expirationFromCacheControl(getResponseHeaders(), &expires))
- {
- return expires;
- }
+}
- // No information in header, make a guess
- if (status == 503)
- {
- // ...service unavailable, retry soon
- const F64 SERVICE_UNAVAILABLE_DELAY = 600.0; // 10 min
- return SERVICE_UNAVAILABLE_DELAY;
- }
- else if (status == 499)
- {
- // ...we were probably too busy, retry quickly
- const F64 BUSY_DELAY = 10.0; // 10 seconds
- return BUSY_DELAY;
- }
- else
- {
- // ...other unexpected error
- const F64 DEFAULT_DELAY = 3600.0; // 1 hour
- return DEFAULT_DELAY;
- }
- }
+bool LLExperienceCache::isRequestPending(const LLUUID& public_key)
+{
+ bool isPending = false;
+ const F64 PENDING_TIMEOUT_SECS = 5.0 * 60.0;
- private:
- ask_queue_t mKeys;
- };
+ PendingQueue_t::const_iterator it = mPendingQueue.find(public_key);
- void requestExperiences()
+ if(it != mPendingQueue.end())
{
- if(sAskQueue.empty() || sLookupURL.empty())
- return;
-
- F64 now = LLFrameTimer::getTotalSeconds();
-
- const U32 EXP_URL_SEND_THRESHOLD = 3000;
- const U32 PAGE_SIZE = EXP_URL_SEND_THRESHOLD/UUID_STR_LENGTH;
-
- std::ostringstream ostr;
-
- ask_queue_t keys;
-
- ostr << sLookupURL << "?page_size=" << PAGE_SIZE;
+ F64 expire_time = LLFrameTimer::getTotalSeconds() - PENDING_TIMEOUT_SECS;
+ isPending = (it->second > expire_time);
+ }
+ return isPending;
+}
- int request_count = 0;
- while(!sAskQueue.empty() && request_count < sMaximumLookups)
- {
- ask_queue_t::iterator it = sAskQueue.begin();
- const LLUUID& key = it->first;
- const std::string& key_type = it->second;
+void LLExperienceCache::setCapabilityQuery(LLExperienceCache::CapabilityQuery_t queryfn)
+{
+ mCapability = queryfn;
+}
- ostr << '&' << key_type << '=' << key.asString() ;
-
- keys[key]=key_type;
- request_count++;
- sPendingQueue[key] = now;
-
- if(ostr.tellp() > EXP_URL_SEND_THRESHOLD)
- {
- LL_DEBUGS("ExperienceCache") << "requestExperiences() query: " << ostr.str() << LL_ENDL;
- LLHTTPClient::get(ostr.str(), new LLExperienceResponder(keys));
- ostr.clear();
- ostr.str(sLookupURL);
- ostr << "?page_size=" << PAGE_SIZE;
- keys.clear();
- }
- sAskQueue.erase(it);
- }
-
- if(ostr.tellp() > sLookupURL.size())
- {
- LL_DEBUGS("ExperienceCache") << "requestExperiences() query 2: " << ostr.str() << LL_ENDL;
- LLHTTPClient::get(ostr.str(), new LLExperienceResponder(keys));
- }
- }
+void LLExperienceCache::idleCoro()
+{
+ const F32 SECS_BETWEEN_REQUESTS = 0.5f;
+ const F32 ERASE_EXPIRED_TIMEOUT = 60.f; // seconds
- bool isRequestPending(const LLUUID& public_key)
- {
- bool isPending = false;
- const F64 PENDING_TIMEOUT_SECS = 5.0 * 60.0;
+ LL_INFOS("ExperienceCache") << "Launching Experience cache idle coro." << LL_ENDL;
+ LLEventTimeout timeout;
- pending_queue_t::const_iterator it = sPendingQueue.find(public_key);
+ do
+ {
+ timeout.eventAfter(SECS_BETWEEN_REQUESTS, LLSD());
+ llcoro::waitForEventOn(timeout);
- if(it != sPendingQueue.end())
- {
- F64 expire_time = LLFrameTimer::getTotalSeconds() - PENDING_TIMEOUT_SECS;
- isPending = (it->second > expire_time);
- }
+ if (mEraseExpiredTimer.checkExpirationAndReset(ERASE_EXPIRED_TIMEOUT))
+ {
+ eraseExpired();
+ }
- return isPending;
- }
+ if (!mRequestQueue.empty())
+ {
+ requestExperiences();
+ }
+ } while (!mShutdown);
- void setLookupURL( const std::string& lookup_url )
- {
- sLookupURL = lookup_url;
- if(!sLookupURL.empty())
- {
- sLookupURL += "id/";
- }
- }
+ // The coroutine system will likely be shut down by the time we get to this point
+ // (or at least no further cycling will occur on it since the user has decided to quit.)
+}
- bool hasLookupURL()
+void LLExperienceCache::erase(const LLUUID& key)
+{
+ cache_t::iterator it = mCache.find(key);
+
+ if(it != mCache.end())
{
- return !sLookupURL.empty();
+ mCache.erase(it);
}
+}
- void idle()
+void LLExperienceCache::eraseExpired()
+{
+ F64 now = LLFrameTimer::getTotalSeconds();
+ cache_t::iterator it = mCache.begin();
+ while (it != mCache.end())
{
+ cache_t::iterator cur = it;
+ LLSD& exp = cur->second;
+ ++it;
- const F32 SECS_BETWEEN_REQUESTS = 0.1f;
- if (!sRequestTimer.checkExpirationAndReset(SECS_BETWEEN_REQUESTS))
- {
- return;
- }
+ //LL_INFOS("ExperienceCache") << "Testing experience \"" << exp[NAME] << "\" with exp time " << exp[EXPIRES].asReal() << "(now = " << now << ")" << LL_ENDL;
- // Must be large relative to above
- const F32 ERASE_EXPIRED_TIMEOUT = 60.f; // seconds
- if (sEraseExpiredTimer.checkExpirationAndReset(ERASE_EXPIRED_TIMEOUT))
+ if(exp.has(EXPIRES) && exp[EXPIRES].asReal() < now)
{
- eraseExpired();
- }
-
-
- if(!sAskQueue.empty())
- {
- requestExperiences();
- }
- }
-
- void erase( const LLUUID& key )
- {
- cache_t::iterator it = sCache.find(key);
-
- if(it != sCache.end())
- {
- sCache.erase(it);
- }
- }
-
- void eraseExpired()
- {
- F64 now = LLFrameTimer::getTotalSeconds();
- cache_t::iterator it = sCache.begin();
- while (it != sCache.end())
- {
- cache_t::iterator cur = it;
- LLSD& exp = cur->second;
- ++it;
-
- if(exp.has(EXPIRES) && exp[EXPIRES].asReal() < now)
+ if(!exp.has(EXPERIENCE_ID))
{
- if(!exp.has(EXPERIENCE_ID))
+ LL_WARNS("ExperienceCache") << "Removing experience with no id " << LL_ENDL ;
+ mCache.erase(cur);
+ }
+ else
+ {
+ LLUUID id = exp[EXPERIENCE_ID].asUUID();
+ LLUUID private_key = exp.has(LLExperienceCache::PRIVATE_KEY) ? exp[LLExperienceCache::PRIVATE_KEY].asUUID():LLUUID::null;
+ if(private_key.notNull() || !exp.has("DoesNotExist"))
{
- LL_WARNS("ExperienceCache") << "Removing experience with no id " << LL_ENDL ;
- sCache.erase(cur);
- }
- else
- {
- LLUUID id = exp[EXPERIENCE_ID].asUUID();
- LLUUID private_key = exp.has(LLExperienceCache::PRIVATE_KEY) ? exp[LLExperienceCache::PRIVATE_KEY].asUUID():LLUUID::null;
- if(private_key.notNull() || !exp.has("DoesNotExist"))
- {
- fetch(id, true);
- }
- else
- {
- LL_WARNS("ExperienceCache") << "Removing invalid experience " << id << LL_ENDL ;
- sCache.erase(cur);
- }
+ fetch(id, true);
+ }
+ else
+ {
+ LL_WARNS("ExperienceCache") << "Removing invalid experience " << id << LL_ENDL ;
+ mCache.erase(cur);
}
}
}
}
-
+}
- bool fetch( const LLUUID& key, bool refresh/* = true*/ )
+bool LLExperienceCache::fetch(const LLUUID& key, bool refresh/* = true*/)
+{
+ if(!key.isNull() && !isRequestPending(key) && (refresh || mCache.find(key)==mCache.end()))
{
- if(!key.isNull() && !isRequestPending(key) && (refresh || sCache.find(key)==sCache.end()))
- {
- LL_DEBUGS("ExperienceCache") << " queue request for " << EXPERIENCE_ID << " " << key << LL_ENDL ;
- sAskQueue[key]=EXPERIENCE_ID;
+ LL_DEBUGS("ExperienceCache") << " queue request for " << EXPERIENCE_ID << " " << key << LL_ENDL;
- return true;
- }
- return false;
+ mRequestQueue.insert(key);
+ return true;
}
+ return false;
+}
- void insert(const LLSD& experience_data )
+void LLExperienceCache::insert(const LLSD& experience_data)
+{
+ if(experience_data.has(EXPERIENCE_ID))
{
- if(experience_data.has(EXPERIENCE_ID))
- {
- processExperience(experience_data[EXPERIENCE_ID].asUUID(), experience_data);
- }
- else
- {
- LL_WARNS("ExperienceCache") << ": Ignoring cache insert of experience which is missing " << EXPERIENCE_ID << LL_ENDL;
- }
+ processExperience(experience_data[EXPERIENCE_ID].asUUID(), experience_data);
}
- static LLSD empty;
- const LLSD& get(const LLUUID& key)
+ else
{
- if(key.isNull()) return empty;
- cache_t::const_iterator it = sCache.find(key);
-
- if (it != sCache.end())
- {
- return it->second;
- }
-
- fetch(key);
+ LL_WARNS("ExperienceCache") << ": Ignoring cache insert of experience which is missing " << EXPERIENCE_ID << LL_ENDL;
+ }
+}
+const LLSD& LLExperienceCache::get(const LLUUID& key)
+{
+ static const LLSD empty;
+
+ if(key.isNull())
return empty;
- }
- void get( const LLUUID& key, callback_slot_t slot )
- {
- if(key.isNull()) return;
+ cache_t::const_iterator it = mCache.find(key);
- cache_t::const_iterator it = sCache.find(key);
- if (it != sCache.end())
- {
- // ...name already exists in cache, fire callback now
- callback_signal_t signal;
- signal.connect(slot);
-
- signal(it->second);
- return;
- }
+ if (it != mCache.end())
+ {
+ return it->second;
+ }
+ fetch(key);
- fetch(key);
+ return empty;
+}
+void LLExperienceCache::get(const LLUUID& key, LLExperienceCache::Callback_t slot)
+{
+ if(key.isNull())
+ return;
- // always store additional callback, even if request is pending
- signal_map_t::iterator sig_it = sSignalMap.find(key);
- if (sig_it == sSignalMap.end())
- {
- // ...new callback for this id
- callback_signal_t* signal = new callback_signal_t();
- signal->connect(slot);
- sSignalMap[key] = signal;
- }
- else
- {
- // ...existing callback, bind additional slot
- callback_signal_t* signal = sig_it->second;
- signal->connect(slot);
- }
+ cache_t::const_iterator it = mCache.find(key);
+ if (it != mCache.end())
+ {
+ // ...name already exists in cache, fire callback now
+ callback_signal_t signal;
+ signal.connect(slot);
+
+ signal(it->second);
+ return;
}
-}
+ fetch(key);
+ signal_ptr signal = signal_ptr(new callback_signal_t());
+
+ std::pair<signal_map_t::iterator, bool> result = mSignalMap.insert(signal_map_t::value_type(key, signal));
+ if (!result.second)
+ signal = (*result.first).second;
+ signal->connect(slot);
+}
-void LLExperienceCache::mapKeys( const LLSD& legacyKeys )
+//=========================================================================
+void LLExperienceCacheImpl::mapKeys(const LLSD& legacyKeys)
{
LLSD::array_const_iterator exp = legacyKeys.beginArray();
- for(/**/ ; exp != legacyKeys.endArray() ; ++exp)
+ for (/**/; exp != legacyKeys.endArray(); ++exp)
{
- if(exp->has(LLExperienceCache::EXPERIENCE_ID) && exp->has(LLExperienceCache::PRIVATE_KEY))
+ if (exp->has(LLExperienceCacheImpl::EXPERIENCE_ID) && exp->has(LLExperienceCacheImpl::PRIVATE_KEY))
{
- privateToPublicKeyMap[(*exp)[LLExperienceCache::PRIVATE_KEY].asUUID()]=(*exp)[LLExperienceCache::EXPERIENCE_ID].asUUID();
+ LLExperienceCacheImpl::privateToPublicKeyMap[(*exp)[LLExperienceCacheImpl::PRIVATE_KEY].asUUID()] =
+ (*exp)[LLExperienceCacheImpl::EXPERIENCE_ID].asUUID();
}
}
}
-
-LLUUID LLExperienceCache::getExperienceId(const LLUUID& private_key, bool null_if_not_found)
+// Return time to retry a request that generated an error, based on
+// error type and headers. Return value is seconds-since-epoch.
+F64 LLExperienceCacheImpl::getErrorRetryDeltaTime(S32 status, LLSD headers)
{
- if (private_key.isNull())
- return LLUUID::null;
- KeyMap::const_iterator it=privateToPublicKeyMap.find(private_key);
- if(it == privateToPublicKeyMap.end())
+ // Retry-After takes priority
+ LLSD retry_after = headers["retry-after"];
+ if (retry_after.isDefined())
+ {
+ // We only support the delta-seconds type
+ S32 delta_seconds = retry_after.asInteger();
+ if (delta_seconds > 0)
+ {
+ // ...valid delta-seconds
+ return F64(delta_seconds);
+ }
+ }
+
+ // If no Retry-After, look for Cache-Control max-age
+ // Allow the header to override the default
+ LLSD cache_control_header = headers["cache-control"];
+ if (cache_control_header.isDefined())
+ {
+ S32 max_age = 0;
+ std::string cache_control = cache_control_header.asString();
+ if (LLExperienceCacheImpl::maxAgeFromCacheControl(cache_control, &max_age))
+ {
+ LL_WARNS("ExperienceCache")
+ << "got EXPIRES from headers, max_age " << max_age
+ << LL_ENDL;
+ return (F64)max_age;
+ }
+ }
+
+ // No information in header, make a guess
+ if (status == 503)
+ {
+ // ...service unavailable, retry soon
+ const F64 SERVICE_UNAVAILABLE_DELAY = 600.0; // 10 min
+ return SERVICE_UNAVAILABLE_DELAY;
+ }
+ else if (status == 499)
+ {
+ // ...we were probably too busy, retry quickly
+ const F64 BUSY_DELAY = 10.0; // 10 seconds
+ return BUSY_DELAY;
+
+ }
+ else
+ {
+ // ...other unexpected error
+ const F64 DEFAULT_DELAY = 3600.0; // 1 hour
+ return DEFAULT_DELAY;
+ }
+}
+
+bool LLExperienceCacheImpl::maxAgeFromCacheControl(const std::string& cache_control, S32 *max_age)
+{
+ // Split the string on "," to get a list of directives
+ typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
+ tokenizer directives(cache_control, COMMA_SEPARATOR);
+
+ tokenizer::iterator token_it = directives.begin();
+ for ( ; token_it != directives.end(); ++token_it)
{
- if(null_if_not_found)
+ // Tokens may have leading or trailing whitespace
+ std::string token = *token_it;
+ LLStringUtil::trim(token);
+
+ if (token.compare(0, MAX_AGE.size(), MAX_AGE) == 0)
{
- return LLUUID::null;
+ // ...this token starts with max-age, so let's chop it up by "="
+ tokenizer subtokens(token, EQUALS_SEPARATOR);
+ tokenizer::iterator subtoken_it = subtokens.begin();
+
+ // Must have a token
+ if (subtoken_it == subtokens.end()) return false;
+ std::string subtoken = *subtoken_it;
+
+ // Must exactly equal "max-age"
+ LLStringUtil::trim(subtoken);
+ if (subtoken != MAX_AGE) return false;
+
+ // Must have another token
+ ++subtoken_it;
+ if (subtoken_it == subtokens.end()) return false;
+ subtoken = *subtoken_it;
+
+ // Must be a valid integer
+ // *NOTE: atoi() returns 0 for invalid values, so we have to
+ // check the string first.
+ // *TODO: Do servers ever send "0000" for zero? We don't handle it
+ LLStringUtil::trim(subtoken);
+ if (subtoken == "0")
+ {
+ *max_age = 0;
+ return true;
+ }
+ S32 val = atoi( subtoken.c_str() );
+ if (val > 0 && val < S32_MAX)
+ {
+ *max_age = val;
+ return true;
+ }
+ return false;
}
- return private_key;
}
- LL_WARNS("LLExperience") << "converted private key " << private_key << " to experience_id " << it->second << LL_ENDL;
- return it->second;
+ return false;
}
+
+
+
+
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-01 04:09:13 +0000