1051 lines
35 KiB
C++
1051 lines
35 KiB
C++
/**
|
|
* @file llexperiencecache.cpp
|
|
* @brief llexperiencecache and related class definitions
|
|
*
|
|
* $LicenseInfo:firstyear=2012&license=viewerlgpl$
|
|
* Second Life Viewer Source Code
|
|
* Copyright (C) 2012, 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 "llexperiencecache.h"
|
|
|
|
#include "llavatarname.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/concept_check.hpp>
|
|
#include "../newview/llviewernetwork.h" // <FS:Ansariel> Log getting spammed with experience requests from other grids; Yes, it IS ugly!
|
|
|
|
//=========================================================================
|
|
namespace LLExperienceCacheImpl
|
|
{
|
|
void mapKeys(const LLSD& legacyKeys);
|
|
F64 getErrorRetryDeltaTime(S32 status, LLSD headers);
|
|
bool maxAgeFromCacheControl(const std::string& cache_control, S32 *max_age);
|
|
|
|
static const std::string PRIVATE_KEY = "private_id";
|
|
static const std::string EXPERIENCE_ID = "public_id";
|
|
|
|
static const std::string MAX_AGE("max-age");
|
|
static const boost::char_separator<char> EQUALS_SEPARATOR("=");
|
|
static const boost::char_separator<char> COMMA_SEPARATOR(",");
|
|
|
|
// *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;
|
|
}
|
|
|
|
//=========================================================================
|
|
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
|
|
const int LLExperienceCache::SEARCH_PAGE_SIZE = 30;
|
|
|
|
bool LLExperienceCache::sShutdown = false;
|
|
|
|
//=========================================================================
|
|
LLExperienceCache::LLExperienceCache()
|
|
{
|
|
}
|
|
|
|
LLExperienceCache::~LLExperienceCache()
|
|
{
|
|
// can exit without cleanup()
|
|
sShutdown = true;
|
|
}
|
|
|
|
void LLExperienceCache::initSingleton()
|
|
{
|
|
// <FS:Ansariel> Log getting spammed with experience requests from other grids
|
|
//mCacheFileName = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, "experience_cache.xml");
|
|
const std::string grid_id_str = LLDir::getScrubbedFileName(LLGridManager::getInstance()->getGridId());
|
|
const std::string& grid_id_lower = utf8str_tolower(grid_id_str);
|
|
mCacheFileName = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, "experience_cache." + grid_id_lower + ".xml");
|
|
// </FS:Ansariel>
|
|
|
|
LL_INFOS("ExperienceCache") << "Loading " << mCacheFileName << LL_ENDL;
|
|
llifstream cache_stream(mCacheFileName.c_str());
|
|
|
|
if (cache_stream.is_open())
|
|
{
|
|
cache_stream >> (*this);
|
|
}
|
|
|
|
constexpr size_t CORO_QUEUE_SIZE = 2048;
|
|
LLCoprocedureManager::instance().initializePool("ExpCache", CORO_QUEUE_SIZE);
|
|
|
|
LLCoros::instance().launch("LLExperienceCache::idleCoro",
|
|
boost::bind(&LLExperienceCache::idleCoro, this));
|
|
|
|
}
|
|
|
|
void LLExperienceCache::cleanup()
|
|
{
|
|
LL_INFOS("ExperienceCache") << "Saving " << mCacheFileName << LL_ENDL;
|
|
|
|
llofstream cache_stream(mCacheFileName.c_str());
|
|
if (cache_stream.is_open())
|
|
{
|
|
cache_stream << (*this);
|
|
}
|
|
sShutdown = true;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
void LLExperienceCache::importFile(std::istream& istr)
|
|
{
|
|
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);
|
|
mCache[public_key] = it->second;
|
|
}
|
|
|
|
LL_DEBUGS("ExperienceCache") << "importFile() loaded " << mCache.size() << LL_ENDL;
|
|
}
|
|
|
|
void LLExperienceCache::exportFile(std::ostream& ostr) const
|
|
{
|
|
LLSD experiences;
|
|
|
|
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;
|
|
|
|
experiences[it->first.asString()] = it->second;
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
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;
|
|
|
|
mCache[public_key]=experience;
|
|
LLSD & row = mCache[public_key];
|
|
|
|
if(row.has(EXPIRES))
|
|
{
|
|
row[EXPIRES] = row[EXPIRES].asReal() + LLFrameTimer::getTotalSeconds();
|
|
}
|
|
|
|
if(row.has(EXPERIENCE_ID))
|
|
{
|
|
mPendingQueue.erase(row[EXPERIENCE_ID].asUUID());
|
|
}
|
|
|
|
//signal
|
|
signal_map_t::iterator sig_it = mSignalMap.find(public_key);
|
|
if (sig_it != mSignalMap.end())
|
|
{
|
|
signal_ptr signal = sig_it->second;
|
|
(*signal)(experience);
|
|
|
|
mSignalMap.erase(public_key);
|
|
}
|
|
}
|
|
|
|
const LLExperienceCache::cache_t& LLExperienceCache::getCached()
|
|
{
|
|
return mCache;
|
|
}
|
|
|
|
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->getAndSuspend(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;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
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())
|
|
{
|
|
// <FS:Beq> FIRE-33046 reduce logging of warning in OS grids with no experiences capability
|
|
#ifdef OPENSIM
|
|
if( LLGridManager::instance().isInOpenSim() )
|
|
{
|
|
// In Opensim this can occur if the grid does not have experiences capability. make it a debug
|
|
LL_DEBUGS("ExperienceCache") << "No Experience capability." << LL_ENDL;
|
|
}
|
|
else
|
|
// Danger: Dangling 'else'
|
|
// In SL, this is a sign of a problem as everything should have experience capability so flag it as a warning still.
|
|
#endif
|
|
// </FS:Beq>
|
|
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_SIZE1 = EXP_URL_SEND_THRESHOLD / UUID_STR_LENGTH;
|
|
|
|
std::ostringstream ostr;
|
|
ostr << urlBase << "?page_size=" << PAGE_SIZE1;
|
|
RequestQueue_t requests;
|
|
|
|
while (!mRequestQueue.empty() && !sShutdown)
|
|
{
|
|
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::instance().enqueueCoprocedure("ExpCache", "RequestExperiences",
|
|
boost::bind(&LLExperienceCache::requestExperiencesCoro, this, _1, ostr.str(), requests) );
|
|
|
|
ostr.str(std::string());
|
|
ostr << urlBase << "?page_size=" << PAGE_SIZE1;
|
|
requests.clear();
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
bool LLExperienceCache::isRequestPending(const LLUUID& public_key)
|
|
{
|
|
bool isPending = false;
|
|
const F64 PENDING_TIMEOUT_SECS = 5.0 * 60.0;
|
|
|
|
PendingQueue_t::const_iterator it = mPendingQueue.find(public_key);
|
|
|
|
if(it != mPendingQueue.end())
|
|
{
|
|
F64 expire_time = LLFrameTimer::getTotalSeconds() - PENDING_TIMEOUT_SECS;
|
|
isPending = (it->second > expire_time);
|
|
}
|
|
|
|
return isPending;
|
|
}
|
|
|
|
void LLExperienceCache::setCapabilityQuery(LLExperienceCache::CapabilityQuery_t queryfn)
|
|
{
|
|
mCapability = queryfn;
|
|
}
|
|
|
|
|
|
void LLExperienceCache::idleCoro()
|
|
{
|
|
const F32 SECS_BETWEEN_REQUESTS = 0.5f;
|
|
const F32 ERASE_EXPIRED_TIMEOUT = 60.f; // seconds
|
|
|
|
LL_INFOS("ExperienceCache") << "Launching Experience cache idle coro." << LL_ENDL;
|
|
do
|
|
{
|
|
if (mEraseExpiredTimer.checkExpirationAndReset(ERASE_EXPIRED_TIMEOUT))
|
|
{
|
|
eraseExpired();
|
|
}
|
|
|
|
if (!mRequestQueue.empty())
|
|
{
|
|
requestExperiences();
|
|
}
|
|
|
|
llcoro::suspendUntilTimeout(SECS_BETWEEN_REQUESTS);
|
|
|
|
} while (!sShutdown);
|
|
|
|
// 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.)
|
|
}
|
|
|
|
void LLExperienceCache::erase(const LLUUID& key)
|
|
{
|
|
cache_t::iterator it = mCache.find(key);
|
|
|
|
if(it != mCache.end())
|
|
{
|
|
mCache.erase(it);
|
|
}
|
|
}
|
|
|
|
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;
|
|
|
|
//LL_INFOS("ExperienceCache") << "Testing experience \"" << exp[NAME] << "\" with exp time " << exp[EXPIRES].asReal() << "(now = " << now << ")" << LL_ENDL;
|
|
|
|
if(exp.has(EXPIRES) && exp[EXPIRES].asReal() < now)
|
|
{
|
|
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"))
|
|
{
|
|
fetch(id, true);
|
|
}
|
|
else
|
|
{
|
|
LL_WARNS("ExperienceCache") << "Removing invalid experience " << id << LL_ENDL ;
|
|
mCache.erase(cur);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool LLExperienceCache::fetch(const LLUUID& key, bool refresh/* = true*/)
|
|
{
|
|
if(!key.isNull() && !isRequestPending(key) && (refresh || mCache.find(key)==mCache.end()))
|
|
{
|
|
LL_DEBUGS("ExperienceCache") << " queue request for " << EXPERIENCE_ID << " " << key << LL_ENDL;
|
|
|
|
mRequestQueue.insert(key);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void LLExperienceCache::insert(const LLSD& experience_data)
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
|
|
const LLSD& LLExperienceCache::get(const LLUUID& key)
|
|
{
|
|
static const LLSD empty;
|
|
|
|
if(key.isNull())
|
|
return empty;
|
|
cache_t::const_iterator it = mCache.find(key);
|
|
|
|
if (it != mCache.end())
|
|
{
|
|
return it->second;
|
|
}
|
|
fetch(key);
|
|
|
|
return empty;
|
|
}
|
|
|
|
void LLExperienceCache::get(const LLUUID& key, LLExperienceCache::ExperienceGetFn_t slot)
|
|
{
|
|
if(key.isNull())
|
|
return;
|
|
|
|
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::fetchAssociatedExperience(const LLUUID& objectId, const LLUUID& itemId, ExperienceGetFn_t fn)
|
|
{
|
|
if (mCapability.empty())
|
|
{
|
|
LL_WARNS("ExperienceCache") << "Capability query method not set." << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
LLCoprocedureManager::instance().enqueueCoprocedure("ExpCache", "Fetch Associated",
|
|
boost::bind(&LLExperienceCache::fetchAssociatedExperienceCoro, this, _1, objectId, itemId, std::string(), fn));
|
|
}
|
|
|
|
void LLExperienceCache::fetchAssociatedExperience(const LLUUID& objectId, const LLUUID& itemId, std::string url, ExperienceGetFn_t fn)
|
|
{
|
|
if (mCapability.empty())
|
|
{
|
|
LL_WARNS("ExperienceCache") << "Capability query method not set." << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
LLCoprocedureManager::instance().enqueueCoprocedure("ExpCache", "Fetch Associated",
|
|
boost::bind(&LLExperienceCache::fetchAssociatedExperienceCoro, this, _1, objectId, itemId, url, fn));
|
|
}
|
|
|
|
void LLExperienceCache::fetchAssociatedExperienceCoro(LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t &httpAdapter, LLUUID objectId, LLUUID itemId, std::string url, ExperienceGetFn_t fn)
|
|
{
|
|
LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest());
|
|
|
|
if (url.empty())
|
|
{
|
|
url = mCapability("GetMetadata");
|
|
|
|
if (url.empty())
|
|
{
|
|
LL_WARNS("ExperienceCache") << "No Metadata capability." << LL_ENDL;
|
|
return;
|
|
}
|
|
}
|
|
|
|
LLSD fields;
|
|
fields.append("experience");
|
|
LLSD data;
|
|
data["object-id"] = objectId;
|
|
data["item-id"] = itemId;
|
|
data["fields"] = fields;
|
|
|
|
LLSD result = httpAdapter->postAndSuspend(httpRequest, url, data);
|
|
|
|
LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
|
|
LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
|
|
|
|
if ((!status) || (!result.has("experience")))
|
|
{
|
|
LLSD failure;
|
|
if (!status)
|
|
{
|
|
failure["error"] = (LLSD::Integer)status.getType();
|
|
failure["message"] = status.getMessage();
|
|
}
|
|
else
|
|
{
|
|
failure["error"] = -1;
|
|
failure["message"] = "no experience";
|
|
}
|
|
if (fn && !fn.empty())
|
|
fn(failure);
|
|
return;
|
|
}
|
|
|
|
LLUUID expId = result["experience"].asUUID();
|
|
get(expId, fn);
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
void LLExperienceCache::findExperienceByName(const std::string text, int page, ExperienceGetFn_t fn)
|
|
{
|
|
if (mCapability.empty())
|
|
{
|
|
LL_WARNS("ExperienceCache") << "Capability query method not set." << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
LLCoprocedureManager::instance().enqueueCoprocedure("ExpCache", "Search Name",
|
|
boost::bind(&LLExperienceCache::findExperienceByNameCoro, this, _1, text, page, fn));
|
|
}
|
|
|
|
void LLExperienceCache::findExperienceByNameCoro(LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t &httpAdapter, std::string text, int page, ExperienceGetFn_t fn)
|
|
{
|
|
LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest());
|
|
std::ostringstream url;
|
|
|
|
|
|
url << mCapability("FindExperienceByName") << "?page=" << page << "&page_size=" << SEARCH_PAGE_SIZE << "&query=" << LLURI::escape(text);
|
|
|
|
LLSD result = httpAdapter->getAndSuspend(httpRequest, url.str());
|
|
|
|
LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
|
|
LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
|
|
|
|
if (!status)
|
|
{
|
|
fn(LLSD());
|
|
return;
|
|
}
|
|
|
|
result.erase(LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS);
|
|
|
|
const LLSD& experiences = result["experience_keys"];
|
|
for (LLSD::array_const_iterator it = experiences.beginArray(); it != experiences.endArray(); ++it)
|
|
{
|
|
insert(*it);
|
|
}
|
|
|
|
fn(result);
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
void LLExperienceCache::getGroupExperiences(const LLUUID &groupId, ExperienceGetFn_t fn)
|
|
{
|
|
if (mCapability.empty())
|
|
{
|
|
LL_WARNS("ExperienceCache") << "Capability query method not set." << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
LLCoprocedureManager::instance().enqueueCoprocedure("ExpCache", "Group Experiences",
|
|
boost::bind(&LLExperienceCache::getGroupExperiencesCoro, this, _1, groupId, fn));
|
|
}
|
|
|
|
void LLExperienceCache::getGroupExperiencesCoro(LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t &httpAdapter, LLUUID groupId, ExperienceGetFn_t fn)
|
|
{
|
|
LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest());
|
|
|
|
// search for experiences owned by the current group
|
|
std::string url = mCapability("GroupExperiences");
|
|
if (url.empty())
|
|
{
|
|
LL_WARNS("ExperienceCache") << "No Group Experiences capability" << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
url += "?" + groupId.asString();
|
|
|
|
LLSD result = httpAdapter->getAndSuspend(httpRequest, url);
|
|
|
|
LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
|
|
LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
|
|
|
|
if (!status)
|
|
{
|
|
fn(LLSD());
|
|
return;
|
|
}
|
|
|
|
const LLSD& experienceIds = result["experience_ids"];
|
|
fn(experienceIds);
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
void LLExperienceCache::getRegionExperiences(CapabilityQuery_t regioncaps, ExperienceGetFn_t fn)
|
|
{
|
|
LLCoprocedureManager::instance().enqueueCoprocedure("ExpCache", "Region Experiences",
|
|
boost::bind(&LLExperienceCache::regionExperiencesCoro, this, _1, regioncaps, false, LLSD(), fn));
|
|
}
|
|
|
|
void LLExperienceCache::setRegionExperiences(CapabilityQuery_t regioncaps, const LLSD &experiences, ExperienceGetFn_t fn)
|
|
{
|
|
LLCoprocedureManager::instance().enqueueCoprocedure("ExpCache", "Region Experiences",
|
|
boost::bind(&LLExperienceCache::regionExperiencesCoro, this, _1, regioncaps, true, experiences, fn));
|
|
}
|
|
|
|
void LLExperienceCache::regionExperiencesCoro(LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t &httpAdapter,
|
|
CapabilityQuery_t regioncaps, bool update, LLSD experiences, ExperienceGetFn_t fn)
|
|
{
|
|
LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest());
|
|
|
|
// search for experiences owned by the current group
|
|
std::string url = regioncaps("RegionExperiences");
|
|
if (url.empty())
|
|
{
|
|
LL_WARNS("ExperienceCache") << "No Region Experiences capability" << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
LLSD result;
|
|
if (update)
|
|
result = httpAdapter->postAndSuspend(httpRequest, url, experiences);
|
|
else
|
|
result = httpAdapter->getAndSuspend(httpRequest, url);
|
|
|
|
LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
|
|
LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
|
|
|
|
if (!status)
|
|
{
|
|
// fn(LLSD());
|
|
return;
|
|
}
|
|
|
|
result.erase(LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS);
|
|
fn(result);
|
|
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
void LLExperienceCache::getExperiencePermission(const LLUUID &experienceId, ExperienceGetFn_t fn)
|
|
{
|
|
if (mCapability.empty())
|
|
{
|
|
LL_WARNS("ExperienceCache") << "Capability query method not set." << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
std::string url = mCapability("ExperiencePreferences") + "?" + experienceId.asString();
|
|
|
|
permissionInvoker_fn invoker(boost::bind(
|
|
// Humans ignore next line. It is just a cast to specify which LLCoreHttpUtil::HttpCoroutineAdapter routine overload.
|
|
static_cast<LLSD(LLCoreHttpUtil::HttpCoroutineAdapter::*)(LLCore::HttpRequest::ptr_t, const std::string &, LLCore::HttpOptions::ptr_t, LLCore::HttpHeaders::ptr_t)>
|
|
//----
|
|
// _1 -> httpAdapter
|
|
// _2 -> httpRequest
|
|
// _3 -> url
|
|
(&LLCoreHttpUtil::HttpCoroutineAdapter::getAndSuspend), _1, _2, _3, LLCore::HttpOptions::ptr_t(), LLCore::HttpHeaders::ptr_t()));
|
|
|
|
|
|
LLCoprocedureManager::instance().enqueueCoprocedure("ExpCache", "Preferences Set",
|
|
boost::bind(&LLExperienceCache::experiencePermissionCoro, this, _1, invoker, url, fn));
|
|
}
|
|
|
|
void LLExperienceCache::setExperiencePermission(const LLUUID &experienceId, const std::string &permission, ExperienceGetFn_t fn)
|
|
{
|
|
if (mCapability.empty())
|
|
{
|
|
LL_WARNS("ExperienceCache") << "Capability query method not set." << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
std::string url = mCapability("ExperiencePreferences");
|
|
if (url.empty())
|
|
return;
|
|
LLSD permData;
|
|
LLSD data;
|
|
permData["permission"] = permission;
|
|
data[experienceId.asString()] = permData;
|
|
|
|
permissionInvoker_fn invoker(boost::bind(
|
|
// Humans ignore next line. It is just a cast to specify which LLCoreHttpUtil::HttpCoroutineAdapter routine overload.
|
|
static_cast<LLSD(LLCoreHttpUtil::HttpCoroutineAdapter::*)(LLCore::HttpRequest::ptr_t, const std::string &, const LLSD &, LLCore::HttpOptions::ptr_t, LLCore::HttpHeaders::ptr_t)>
|
|
//----
|
|
// _1 -> httpAdapter
|
|
// _2 -> httpRequest
|
|
// _3 -> url
|
|
(&LLCoreHttpUtil::HttpCoroutineAdapter::putAndSuspend), _1, _2, _3, data, LLCore::HttpOptions::ptr_t(), LLCore::HttpHeaders::ptr_t()));
|
|
|
|
|
|
LLCoprocedureManager::instance().enqueueCoprocedure("ExpCache", "Preferences Set",
|
|
boost::bind(&LLExperienceCache::experiencePermissionCoro, this, _1, invoker, url, fn));
|
|
}
|
|
|
|
void LLExperienceCache::forgetExperiencePermission(const LLUUID &experienceId, ExperienceGetFn_t fn)
|
|
{
|
|
if (mCapability.empty())
|
|
{
|
|
LL_WARNS("ExperienceCache") << "Capability query method not set." << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
std::string url = mCapability("ExperiencePreferences") + "?" + experienceId.asString();
|
|
|
|
|
|
permissionInvoker_fn invoker(boost::bind(
|
|
// Humans ignore next line. It is just a cast to specify which LLCoreHttpUtil::HttpCoroutineAdapter routine overload.
|
|
static_cast<LLSD(LLCoreHttpUtil::HttpCoroutineAdapter::*)(LLCore::HttpRequest::ptr_t, const std::string &, LLCore::HttpOptions::ptr_t, LLCore::HttpHeaders::ptr_t)>
|
|
//----
|
|
// _1 -> httpAdapter
|
|
// _2 -> httpRequest
|
|
// _3 -> url
|
|
(&LLCoreHttpUtil::HttpCoroutineAdapter::deleteAndSuspend), _1, _2, _3, LLCore::HttpOptions::ptr_t(), LLCore::HttpHeaders::ptr_t()));
|
|
|
|
|
|
LLCoprocedureManager::instance().enqueueCoprocedure("ExpCache", "Preferences Set",
|
|
boost::bind(&LLExperienceCache::experiencePermissionCoro, this, _1, invoker, url, fn));
|
|
}
|
|
|
|
void LLExperienceCache::experiencePermissionCoro(LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t &httpAdapter, permissionInvoker_fn invokerfn, std::string url, ExperienceGetFn_t fn)
|
|
{
|
|
LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest());
|
|
|
|
// search for experiences owned by the current group
|
|
|
|
LLSD result = invokerfn(httpAdapter, httpRequest, url);
|
|
|
|
LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
|
|
LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
|
|
result.erase(LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS);
|
|
|
|
if (status)
|
|
{
|
|
fn(result);
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
void LLExperienceCache::getExperienceAdmin(const LLUUID &experienceId, ExperienceGetFn_t fn)
|
|
{
|
|
if (mCapability.empty())
|
|
{
|
|
LL_WARNS("ExperienceCache") << "Capability query method not set." << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
LLCoprocedureManager::instance().enqueueCoprocedure("ExpCache", "IsAdmin",
|
|
boost::bind(&LLExperienceCache::getExperienceAdminCoro, this, _1, experienceId, fn));
|
|
}
|
|
|
|
void LLExperienceCache::getExperienceAdminCoro(LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t &httpAdapter, LLUUID experienceId, ExperienceGetFn_t fn)
|
|
{
|
|
LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest());
|
|
|
|
std::string url = mCapability("IsExperienceAdmin");
|
|
if (url.empty())
|
|
{
|
|
LL_WARNS("ExperienceCache") << "No Region Experiences capability" << LL_ENDL;
|
|
return;
|
|
}
|
|
url += "?experience_id=" + experienceId.asString();
|
|
|
|
LLSD result = httpAdapter->getAndSuspend(httpRequest, url);
|
|
// LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
|
|
// LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
|
|
|
|
fn(result);
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
void LLExperienceCache::updateExperience(LLSD updateData, ExperienceGetFn_t fn)
|
|
{
|
|
if (mCapability.empty())
|
|
{
|
|
LL_WARNS("ExperienceCache") << "Capability query method not set." << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
LLCoprocedureManager::instance().enqueueCoprocedure("ExpCache", "IsAdmin",
|
|
boost::bind(&LLExperienceCache::updateExperienceCoro, this, _1, updateData, fn));
|
|
}
|
|
|
|
void LLExperienceCache::updateExperienceCoro(LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t &httpAdapter, LLSD updateData, ExperienceGetFn_t fn)
|
|
{
|
|
LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest());
|
|
|
|
std::string url = mCapability("UpdateExperience");
|
|
if (url.empty())
|
|
{
|
|
LL_WARNS("ExperienceCache") << "No Region Experiences capability" << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
updateData.erase(LLExperienceCache::QUOTA);
|
|
updateData.erase(LLExperienceCache::EXPIRES);
|
|
updateData.erase(LLExperienceCache::AGENT_ID);
|
|
|
|
LLSD result = httpAdapter->postAndSuspend(httpRequest, url, updateData);
|
|
|
|
fn(result);
|
|
}
|
|
|
|
//=========================================================================
|
|
void LLExperienceCacheImpl::mapKeys(const LLSD& legacyKeys)
|
|
{
|
|
LLSD::array_const_iterator exp = legacyKeys.beginArray();
|
|
for (/**/; exp != legacyKeys.endArray(); ++exp)
|
|
{
|
|
if (exp->has(LLExperienceCacheImpl::EXPERIENCE_ID) && exp->has(LLExperienceCacheImpl::PRIVATE_KEY))
|
|
{
|
|
LLExperienceCacheImpl::privateToPublicKeyMap[(*exp)[LLExperienceCacheImpl::PRIVATE_KEY].asUUID()] =
|
|
(*exp)[LLExperienceCacheImpl::EXPERIENCE_ID].asUUID();
|
|
}
|
|
}
|
|
}
|
|
|
|
// 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)
|
|
{
|
|
|
|
// 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)
|
|
{
|
|
// 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;
|
|
}
|
|
|
|
|
|
|
|
|