1825 lines
67 KiB
C++
1825 lines
67 KiB
C++
/**
|
|
* @file llinventorymodelbackgroundfetch.cpp
|
|
* @brief Implementation of background fetching of inventory.
|
|
*
|
|
* $LicenseInfo:firstyear=2002&license=viewerlgpl$
|
|
* Second Life Viewer Source Code
|
|
* Copyright (C) 2014, 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 "llinventorymodelbackgroundfetch.h"
|
|
|
|
#include "llaisapi.h"
|
|
#include "llagent.h"
|
|
#include "llappviewer.h"
|
|
#include "llcallbacklist.h"
|
|
#include "llinventorymodel.h"
|
|
#include "llinventorypanel.h"
|
|
#include "llnotificationsutil.h"
|
|
#include "llstartup.h"
|
|
#include "llviewercontrol.h"
|
|
#include "llviewerinventory.h"
|
|
#include "llviewermessage.h"
|
|
#include "llviewerregion.h"
|
|
#include "llviewerwindow.h"
|
|
#include "llhttpconstants.h"
|
|
#include "bufferarray.h"
|
|
#include "bufferstream.h"
|
|
#include "llcorehttputil.h"
|
|
#include "llviewermenu.h"
|
|
#include "llviewernetwork.h"
|
|
|
|
// History (may be apocryphal)
|
|
//
|
|
// Around V2, an HTTP inventory download mechanism was added
|
|
// along with inventory LINK items referencing other inventory
|
|
// items. As part of this, at login, the entire inventory
|
|
// structure is downloaded 'in the background' using the
|
|
// backgroundFetch()/bulkFetch() methods. The UDP path can
|
|
// still be used and is found in the 'DEPRECATED OLD CODE'
|
|
// section.
|
|
//
|
|
// The old UDP path implemented a throttle that adapted
|
|
// itself during running. The mechanism survived info HTTP
|
|
// somewhat but was pinned to poll the HTTP plumbing at
|
|
// 0.5S intervals. The reasons for this particular value
|
|
// have been lost. It's possible to switch between UDP
|
|
// and HTTP while this is happening but there may be
|
|
// surprises in what happens in that case.
|
|
//
|
|
// Conversion to llcorehttp reduced the number of connections
|
|
// used but batches more data and queues more requests (but
|
|
// doesn't due pipelining due to libcurl restrictions). The
|
|
// poll interval above was re-examined and reduced to get
|
|
// inventory into the viewer more quickly.
|
|
//
|
|
// Possible future work:
|
|
//
|
|
// * Don't download the entire heirarchy in one go (which
|
|
// might have been how V1 worked). Implications for
|
|
// links (which may not have a valid target) and search
|
|
// which would then be missing data.
|
|
//
|
|
// * Review the download rate throttling. Slow then fast?
|
|
// Detect bandwidth usage and speed up when it drops?
|
|
//
|
|
// * An error on a fetch could be due to one item in the batch.
|
|
// If the batch were broken up, perhaps more of the inventory
|
|
// would download. (Handwave here, not certain this is an
|
|
// issue in practice.)
|
|
//
|
|
// * Conversion to AISv3.
|
|
//
|
|
|
|
|
|
namespace
|
|
{
|
|
|
|
///----------------------------------------------------------------------------
|
|
/// Class <anonymous>::BGItemHttpHandler
|
|
///----------------------------------------------------------------------------
|
|
|
|
//
|
|
// Http request handler class for single inventory item requests.
|
|
//
|
|
// We'll use a handler-per-request pattern here rather than
|
|
// a shared handler. Mainly convenient as this was converted
|
|
// from a Responder class model.
|
|
//
|
|
// Derives from and is identical to the normal FetchItemHttpHandler
|
|
// except that: 1) it uses the background request object which is
|
|
// updated more slowly than the foreground and 2) keeps a count of
|
|
// active requests on the LLInventoryModelBackgroundFetch object
|
|
// to indicate outstanding operations are in-flight.
|
|
//
|
|
class BGItemHttpHandler : public LLInventoryModel::FetchItemHttpHandler
|
|
{
|
|
LOG_CLASS(BGItemHttpHandler);
|
|
|
|
public:
|
|
BGItemHttpHandler(const LLSD& request_sd)
|
|
: LLInventoryModel::FetchItemHttpHandler(request_sd)
|
|
{
|
|
LLInventoryModelBackgroundFetch::instance().incrFetchCount(1);
|
|
}
|
|
|
|
virtual ~BGItemHttpHandler()
|
|
{
|
|
LLInventoryModelBackgroundFetch::instance().incrFetchCount(-1);
|
|
}
|
|
|
|
protected:
|
|
BGItemHttpHandler(const BGItemHttpHandler&); // Not defined
|
|
void operator=(const BGItemHttpHandler&); // Not defined
|
|
};
|
|
|
|
|
|
///----------------------------------------------------------------------------
|
|
/// Class <anonymous>::BGFolderHttpHandler
|
|
///----------------------------------------------------------------------------
|
|
|
|
// Http request handler class for folders.
|
|
//
|
|
// Handler for FetchInventoryDescendents2 and FetchLibDescendents2
|
|
// caps requests for folders.
|
|
//
|
|
class BGFolderHttpHandler : public LLCore::HttpHandler
|
|
{
|
|
LOG_CLASS(BGFolderHttpHandler);
|
|
|
|
public:
|
|
BGFolderHttpHandler(const LLSD& request_sd, const uuid_vec_t& recursive_cats)
|
|
: LLCore::HttpHandler(),
|
|
mRequestSD(request_sd),
|
|
mRecursiveCatUUIDs(recursive_cats)
|
|
{
|
|
LLInventoryModelBackgroundFetch::instance().incrFetchCount(1);
|
|
}
|
|
|
|
virtual ~BGFolderHttpHandler()
|
|
{
|
|
LLInventoryModelBackgroundFetch::instance().incrFetchCount(-1);
|
|
}
|
|
|
|
protected:
|
|
BGFolderHttpHandler(const BGFolderHttpHandler&); // Not defined
|
|
void operator=(const BGFolderHttpHandler&); // Not defined
|
|
|
|
public:
|
|
virtual void onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse* response);
|
|
|
|
bool getIsRecursive(const LLUUID& cat_id) const;
|
|
|
|
private:
|
|
void processData(LLSD& body, LLCore::HttpResponse* response);
|
|
void processFailure(LLCore::HttpStatus status, LLCore::HttpResponse* response);
|
|
void processFailure(const char* const reason, LLCore::HttpResponse* response);
|
|
|
|
private:
|
|
LLSD mRequestSD;
|
|
const uuid_vec_t mRecursiveCatUUIDs; // hack for storing away which cat fetches are recursive
|
|
};
|
|
|
|
|
|
const S32 MAX_FETCH_RETRIES = 10; // <FS:ND/> For legacy inventory
|
|
|
|
const char* const LOG_INV("Inventory");
|
|
|
|
} // end of namespace anonymous
|
|
|
|
|
|
///----------------------------------------------------------------------------
|
|
/// Class LLInventoryModelBackgroundFetch
|
|
///----------------------------------------------------------------------------
|
|
|
|
LLInventoryModelBackgroundFetch::LLInventoryModelBackgroundFetch():
|
|
mBackgroundFetchActive(false),
|
|
mFolderFetchActive(false),
|
|
mFetchCount(0),
|
|
mLastFetchCount(0),
|
|
mFetchFolderCount(0),
|
|
mAllRecursiveFoldersFetched(false),
|
|
mRecursiveInventoryFetchStarted(false),
|
|
mRecursiveLibraryFetchStarted(false),
|
|
mRecursiveMarketplaceFetchStarted(false),
|
|
mMinTimeBetweenFetches(0.3f)
|
|
{}
|
|
|
|
LLInventoryModelBackgroundFetch::~LLInventoryModelBackgroundFetch()
|
|
{
|
|
gIdleCallbacks.deleteFunction(&LLInventoryModelBackgroundFetch::backgroundFetchCB, nullptr);
|
|
}
|
|
|
|
bool LLInventoryModelBackgroundFetch::isBulkFetchProcessingComplete() const
|
|
{
|
|
return mFetchFolderQueue.empty() && mFetchItemQueue.empty() && mFetchCount <= 0;
|
|
}
|
|
|
|
bool LLInventoryModelBackgroundFetch::isFolderFetchProcessingComplete() const
|
|
{
|
|
return mFetchFolderQueue.empty() && mFetchFolderCount <= 0;
|
|
}
|
|
|
|
bool LLInventoryModelBackgroundFetch::libraryFetchStarted() const
|
|
{
|
|
return mRecursiveLibraryFetchStarted;
|
|
}
|
|
|
|
bool LLInventoryModelBackgroundFetch::libraryFetchCompleted() const
|
|
{
|
|
return libraryFetchStarted() && fetchQueueContainsNoDescendentsOf(gInventory.getLibraryRootFolderID());
|
|
}
|
|
|
|
bool LLInventoryModelBackgroundFetch::libraryFetchInProgress() const
|
|
{
|
|
return libraryFetchStarted() && !libraryFetchCompleted();
|
|
}
|
|
|
|
bool LLInventoryModelBackgroundFetch::inventoryFetchStarted() const
|
|
{
|
|
return mRecursiveInventoryFetchStarted;
|
|
}
|
|
|
|
bool LLInventoryModelBackgroundFetch::inventoryFetchCompleted() const
|
|
{
|
|
return inventoryFetchStarted() && fetchQueueContainsNoDescendentsOf(gInventory.getRootFolderID());
|
|
}
|
|
|
|
bool LLInventoryModelBackgroundFetch::inventoryFetchInProgress() const
|
|
{
|
|
return inventoryFetchStarted() && !inventoryFetchCompleted();
|
|
}
|
|
|
|
bool LLInventoryModelBackgroundFetch::isEverythingFetched() const
|
|
{
|
|
return mAllRecursiveFoldersFetched;
|
|
}
|
|
|
|
bool LLInventoryModelBackgroundFetch::folderFetchActive() const
|
|
{
|
|
return mFolderFetchActive;
|
|
}
|
|
|
|
void LLInventoryModelBackgroundFetch::addRequestAtFront(const LLUUID& id, bool recursive, bool is_category)
|
|
{
|
|
EFetchType recursion_type = recursive ? FT_RECURSIVE : FT_DEFAULT;
|
|
if (is_category)
|
|
{
|
|
mFetchFolderQueue.emplace_front(id, recursion_type, is_category);
|
|
}
|
|
else
|
|
{
|
|
mFetchItemQueue.emplace_front(id, recursion_type, is_category);
|
|
}
|
|
}
|
|
|
|
void LLInventoryModelBackgroundFetch::addRequestAtBack(const LLUUID& id, bool recursive, bool is_category)
|
|
{
|
|
EFetchType recursion_type = recursive ? FT_RECURSIVE : FT_DEFAULT;
|
|
if (is_category)
|
|
{
|
|
mFetchFolderQueue.emplace_back(id, recursion_type, is_category);
|
|
}
|
|
else
|
|
{
|
|
mFetchItemQueue.emplace_back(id, recursion_type, is_category);
|
|
}
|
|
}
|
|
|
|
void LLInventoryModelBackgroundFetch::start(const LLUUID& id, bool recursive)
|
|
{
|
|
LLViewerInventoryCategory* cat(gInventory.getCategory(id));
|
|
|
|
if (cat || (id.isNull() && ! isEverythingFetched()))
|
|
{
|
|
// it's a folder, do a bulk fetch
|
|
LL_DEBUGS(LOG_INV) << "Start fetching category: " << id << ", recursive: " << recursive << LL_ENDL;
|
|
|
|
mBackgroundFetchActive = true;
|
|
mFolderFetchActive = true;
|
|
EFetchType recursion_type = recursive ? FT_RECURSIVE : FT_DEFAULT;
|
|
if (id.isNull())
|
|
{
|
|
if (!mRecursiveInventoryFetchStarted)
|
|
{
|
|
mRecursiveInventoryFetchStarted |= recursive;
|
|
if (recursive && AISAPI::isAvailable())
|
|
{
|
|
// Not only root folder can be massive, but
|
|
// most system folders will be requested independently
|
|
// so request root folder and content separately
|
|
mFetchFolderQueue.emplace_front(gInventory.getRootFolderID(), FT_FOLDER_AND_CONTENT);
|
|
}
|
|
else
|
|
{
|
|
mFetchFolderQueue.emplace_back(gInventory.getRootFolderID(), recursion_type);
|
|
}
|
|
gIdleCallbacks.addFunction(&LLInventoryModelBackgroundFetch::backgroundFetchCB, nullptr);
|
|
}
|
|
if (!mRecursiveLibraryFetchStarted)
|
|
{
|
|
mRecursiveLibraryFetchStarted |= recursive;
|
|
mFetchFolderQueue.emplace_back(gInventory.getLibraryRootFolderID(), recursion_type);
|
|
gIdleCallbacks.addFunction(&LLInventoryModelBackgroundFetch::backgroundFetchCB, nullptr);
|
|
}
|
|
}
|
|
else if (recursive && cat && cat->getPreferredType() == LLFolderType::FT_MARKETPLACE_LISTINGS)
|
|
{
|
|
if (mFetchFolderQueue.empty() || mFetchFolderQueue.back().mUUID != id)
|
|
{
|
|
if (recursive && AISAPI::isAvailable())
|
|
{
|
|
// Request marketplace folder and content separately
|
|
mFetchFolderQueue.emplace_front(id, FT_FOLDER_AND_CONTENT);
|
|
}
|
|
else
|
|
{
|
|
mFetchFolderQueue.emplace_front(id, recursion_type);
|
|
}
|
|
gIdleCallbacks.addFunction(&LLInventoryModelBackgroundFetch::backgroundFetchCB, nullptr);
|
|
mRecursiveMarketplaceFetchStarted = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (AISAPI::isAvailable())
|
|
{
|
|
if (mFetchFolderQueue.empty() || mFetchFolderQueue.back().mUUID != id)
|
|
{
|
|
// On AIS make sure root goes to the top and follow up recursive
|
|
// fetches, not individual requests
|
|
mFetchFolderQueue.emplace_back(id, recursion_type);
|
|
gIdleCallbacks.addFunction(&LLInventoryModelBackgroundFetch::backgroundFetchCB, nullptr);
|
|
}
|
|
}
|
|
else if (mFetchFolderQueue.empty() || mFetchFolderQueue.front().mUUID != id)
|
|
{
|
|
// Specific folder requests go to front of queue.
|
|
mFetchFolderQueue.emplace_front(id, recursion_type);
|
|
gIdleCallbacks.addFunction(&LLInventoryModelBackgroundFetch::backgroundFetchCB, nullptr);
|
|
}
|
|
|
|
if (id == gInventory.getLibraryRootFolderID())
|
|
{
|
|
mRecursiveLibraryFetchStarted |= recursive;
|
|
}
|
|
if (id == gInventory.getRootFolderID())
|
|
{
|
|
mRecursiveInventoryFetchStarted |= recursive;
|
|
}
|
|
}
|
|
}
|
|
else if (LLViewerInventoryItem* itemp = gInventory.getItem(id))
|
|
{
|
|
if (!itemp->mIsComplete)
|
|
{
|
|
scheduleItemFetch(id);
|
|
}
|
|
}
|
|
}
|
|
|
|
void LLInventoryModelBackgroundFetch::scheduleFolderFetch(const LLUUID& cat_id, bool forced)
|
|
{
|
|
if (mFetchFolderQueue.empty() || mFetchFolderQueue.front().mUUID != cat_id)
|
|
{
|
|
mBackgroundFetchActive = true;
|
|
mFolderFetchActive = true;
|
|
|
|
if (forced)
|
|
{
|
|
// check if already requested
|
|
if (mForceFetchSet.find(cat_id) == mForceFetchSet.end())
|
|
{
|
|
mForceFetchSet.emplace(cat_id);
|
|
mFetchFolderQueue.emplace_front(cat_id, FT_FORCED);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Specific folder requests go to front of queue.
|
|
// version presence acts as duplicate prevention for normal fetches
|
|
mFetchFolderQueue.emplace_front(cat_id, FT_DEFAULT);
|
|
}
|
|
|
|
gIdleCallbacks.addFunction(&LLInventoryModelBackgroundFetch::backgroundFetchCB, nullptr);
|
|
}
|
|
}
|
|
|
|
void LLInventoryModelBackgroundFetch::scheduleItemFetch(const LLUUID& item_id, bool forced)
|
|
{
|
|
if (mFetchItemQueue.empty() || mFetchItemQueue.front().mUUID != item_id)
|
|
{
|
|
mBackgroundFetchActive = true;
|
|
if (forced)
|
|
{
|
|
// check if already requested
|
|
if (mForceFetchSet.find(item_id) == mForceFetchSet.end())
|
|
{
|
|
mForceFetchSet.emplace(item_id);
|
|
mFetchItemQueue.emplace_front(item_id, FT_FORCED, false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// 'isFinished' being set acts as duplicate prevention for normal fetches
|
|
mFetchItemQueue.emplace_front(item_id, FT_DEFAULT, false);
|
|
}
|
|
|
|
gIdleCallbacks.addFunction(&LLInventoryModelBackgroundFetch::backgroundFetchCB, nullptr);
|
|
}
|
|
}
|
|
|
|
void LLInventoryModelBackgroundFetch::fetchFolderAndLinks(const LLUUID& cat_id, nullary_func_t callback)
|
|
{
|
|
LLViewerInventoryCategory* cat = gInventory.getCategory(cat_id);
|
|
if (cat)
|
|
{
|
|
// Mark folder (update timer) so that background fetch won't request it
|
|
cat->setFetching(LLViewerInventoryCategory::FETCH_RECURSIVE);
|
|
}
|
|
incrFetchFolderCount(1);
|
|
mExpectedFolderIds.emplace_back(cat_id);
|
|
|
|
// Assume that we have no relevant cache. Fetch folder, and items folder's links point to.
|
|
AISAPI::FetchCategoryLinks(cat_id,
|
|
[callback, cat_id](const LLUUID& id)
|
|
{
|
|
callback();
|
|
if (id.isNull())
|
|
{
|
|
LL_WARNS() << "Failed to fetch category links " << cat_id << LL_ENDL;
|
|
}
|
|
LLInventoryModelBackgroundFetch::getInstance()->onAISFolderCalback(cat_id, id, FT_DEFAULT);
|
|
});
|
|
|
|
// start idle loop to track completion
|
|
mBackgroundFetchActive = true;
|
|
mFolderFetchActive = true;
|
|
gIdleCallbacks.addFunction(&LLInventoryModelBackgroundFetch::backgroundFetchCB, nullptr);
|
|
}
|
|
|
|
void LLInventoryModelBackgroundFetch::fetchCOF(nullary_func_t callback)
|
|
{
|
|
LLUUID cat_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_CURRENT_OUTFIT);
|
|
LLViewerInventoryCategory* cat = gInventory.getCategory(cat_id);
|
|
if (cat)
|
|
{
|
|
// Mark cof (update timer) so that background fetch won't request it
|
|
cat->setFetching(LLViewerInventoryCategory::FETCH_RECURSIVE);
|
|
}
|
|
incrFetchFolderCount(1);
|
|
mExpectedFolderIds.emplace_back(cat_id);
|
|
// For reliability assume that we have no relevant cache, so
|
|
// fetch cof along with items cof's links point to.
|
|
AISAPI::FetchCOF([callback](const LLUUID& id)
|
|
{
|
|
callback();
|
|
LLUUID cat_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_CURRENT_OUTFIT);
|
|
LLInventoryModelBackgroundFetch::getInstance()->onAISFolderCalback(cat_id, id, FT_DEFAULT);
|
|
});
|
|
|
|
// start idle loop to track completion
|
|
mBackgroundFetchActive = true;
|
|
mFolderFetchActive = true;
|
|
gIdleCallbacks.addFunction(&LLInventoryModelBackgroundFetch::backgroundFetchCB, nullptr);
|
|
}
|
|
|
|
void LLInventoryModelBackgroundFetch::findLostItems()
|
|
{
|
|
mBackgroundFetchActive = true;
|
|
mFolderFetchActive = true;
|
|
mFetchFolderQueue.emplace_back(LLUUID::null, FT_RECURSIVE);
|
|
gIdleCallbacks.addFunction(&LLInventoryModelBackgroundFetch::backgroundFetchCB, nullptr);
|
|
}
|
|
|
|
void LLInventoryModelBackgroundFetch::setAllFoldersFetched()
|
|
{
|
|
if (mRecursiveInventoryFetchStarted &&
|
|
mRecursiveLibraryFetchStarted)
|
|
{
|
|
mAllRecursiveFoldersFetched = true;
|
|
//LL_INFOS(LOG_INV) << "All folders fetched, validating" << LL_ENDL;
|
|
//gInventory.validate();
|
|
}
|
|
|
|
mFolderFetchActive = false;
|
|
if (isBulkFetchProcessingComplete())
|
|
{
|
|
mBackgroundFetchActive = false;
|
|
}
|
|
|
|
// For now only informs about initial fetch being done
|
|
mFoldersFetchedSignal();
|
|
|
|
LL_INFOS(LOG_INV) << "Inventory background fetch completed" << LL_ENDL;
|
|
}
|
|
|
|
boost::signals2::connection LLInventoryModelBackgroundFetch::setFetchCompletionCallback(folders_fetched_callback_t cb)
|
|
{
|
|
return mFoldersFetchedSignal.connect(cb);
|
|
}
|
|
|
|
void LLInventoryModelBackgroundFetch::backgroundFetchCB(void*)
|
|
{
|
|
LLInventoryModelBackgroundFetch::instance().backgroundFetch();
|
|
}
|
|
|
|
void LLInventoryModelBackgroundFetch::backgroundFetch()
|
|
{
|
|
if (mBackgroundFetchActive)
|
|
{
|
|
// If we'll be using the capability, we'll be sending batches and the background thing isn't as important.
|
|
// <FS:Ansariel> Force HTTP features on SL
|
|
//if (gSavedSettings.getBOOL("UseHTTPInventory"))
|
|
if (use_http_inventory())
|
|
// </FS:Ansariel>
|
|
{
|
|
if (AISAPI::isAvailable())
|
|
{
|
|
bulkFetchViaAis();
|
|
}
|
|
else if (gAgent.getRegion() && gAgent.getRegion()->capabilitiesReceived())
|
|
{
|
|
// If we'll be using the capability, we'll be sending batches and the background thing isn't as important.
|
|
bulkFetch();
|
|
}
|
|
return;
|
|
}
|
|
|
|
#ifdef OPENSIM // Only OpenSim still might support old UDP fetch
|
|
//--------------------------------------------------------------------------------
|
|
// DEPRECATED OLD CODE
|
|
//
|
|
|
|
// No more categories to fetch, stop fetch process.
|
|
if (mFetchFolderQueue.empty())
|
|
{
|
|
setAllFoldersFetched();
|
|
return;
|
|
}
|
|
|
|
F32 fast_fetch_time = lerp(mMinTimeBetweenFetches, mMaxTimeBetweenFetches, 0.1f);
|
|
F32 slow_fetch_time = lerp(mMinTimeBetweenFetches, mMaxTimeBetweenFetches, 0.5f);
|
|
if (mTimelyFetchPending && mFetchTimer.getElapsedTimeF32() > slow_fetch_time)
|
|
{
|
|
// Double timeouts on failure.
|
|
mMinTimeBetweenFetches = llmin(mMinTimeBetweenFetches * 2.f, 10.f);
|
|
mMaxTimeBetweenFetches = llmin(mMaxTimeBetweenFetches * 2.f, 120.f);
|
|
LL_DEBUGS(LOG_INV) << "Inventory fetch times grown to (" << mMinTimeBetweenFetches << ", " << mMaxTimeBetweenFetches << ")" << LL_ENDL;
|
|
// fetch is no longer considered "timely" although we will wait for full time-out.
|
|
mTimelyFetchPending = false;
|
|
}
|
|
|
|
while(1)
|
|
{
|
|
if (mFetchFolderQueue.empty())
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (gDisconnected)
|
|
{
|
|
// Just bail if we are disconnected.
|
|
break;
|
|
}
|
|
|
|
const FetchQueueInfo info = mFetchFolderQueue.front();
|
|
|
|
if (info.mIsCategory)
|
|
{
|
|
|
|
LLViewerInventoryCategory* cat = gInventory.getCategory(info.mUUID);
|
|
|
|
// Category has been deleted, remove from queue.
|
|
if (!cat)
|
|
{
|
|
mFetchFolderQueue.pop_front();
|
|
continue;
|
|
}
|
|
|
|
if (mFetchTimer.getElapsedTimeF32() > mMinTimeBetweenFetches &&
|
|
LLViewerInventoryCategory::VERSION_UNKNOWN == cat->getVersion())
|
|
{
|
|
// Category exists but has no children yet, fetch the descendants
|
|
// for now, just request every time and rely on retry timer to throttle.
|
|
if (cat->fetch())
|
|
{
|
|
mFetchTimer.reset();
|
|
mTimelyFetchPending = true;
|
|
}
|
|
else
|
|
{
|
|
// The catagory also tracks if it has expired and here it says it hasn't
|
|
// yet. Get out of here because nothing is going to happen until we
|
|
// update the timers.
|
|
break;
|
|
}
|
|
}
|
|
// Do I have all my children?
|
|
else if (gInventory.isCategoryComplete(info.mUUID))
|
|
{
|
|
// Finished with this category, remove from queue.
|
|
mFetchFolderQueue.pop_front();
|
|
|
|
// Add all children to queue.
|
|
LLInventoryModel::cat_array_t* categories;
|
|
LLInventoryModel::item_array_t* items;
|
|
gInventory.getDirectDescendentsOf(cat->getUUID(), categories, items);
|
|
for (LLInventoryModel::cat_array_t::const_iterator it = categories->begin();
|
|
it != categories->end();
|
|
++it)
|
|
{
|
|
mFetchFolderQueue.push_back(FetchQueueInfo((*it)->getUUID(),info.mFetchType));
|
|
}
|
|
|
|
// We received a response in less than the fast time.
|
|
if (mTimelyFetchPending && mFetchTimer.getElapsedTimeF32() < fast_fetch_time)
|
|
{
|
|
// Shrink timeouts based on success.
|
|
mMinTimeBetweenFetches = llmax(mMinTimeBetweenFetches * 0.8f, 0.3f);
|
|
mMaxTimeBetweenFetches = llmax(mMaxTimeBetweenFetches * 0.8f, 10.f);
|
|
LL_DEBUGS(LOG_INV) << "Inventory fetch times shrunk to (" << mMinTimeBetweenFetches << ", " << mMaxTimeBetweenFetches << ")" << LL_ENDL;
|
|
}
|
|
|
|
mTimelyFetchPending = false;
|
|
continue;
|
|
}
|
|
else if (mFetchTimer.getElapsedTimeF32() > mMaxTimeBetweenFetches)
|
|
{
|
|
// Received first packet, but our num descendants does not match db's num descendants
|
|
// so try again later.
|
|
mFetchFolderQueue.pop_front();
|
|
|
|
if (mNumFetchRetries++ < MAX_FETCH_RETRIES)
|
|
{
|
|
// push on back of queue
|
|
mFetchFolderQueue.push_back(info);
|
|
}
|
|
mTimelyFetchPending = false;
|
|
mFetchTimer.reset();
|
|
break;
|
|
}
|
|
|
|
// Not enough time has elapsed to do a new fetch
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
LLViewerInventoryItem* itemp = gInventory.getItem(info.mUUID);
|
|
|
|
mFetchFolderQueue.pop_front();
|
|
if (!itemp)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (mFetchTimer.getElapsedTimeF32() > mMinTimeBetweenFetches)
|
|
{
|
|
itemp->fetchFromServer();
|
|
mFetchTimer.reset();
|
|
mTimelyFetchPending = true;
|
|
}
|
|
else if (itemp->mIsComplete)
|
|
{
|
|
mTimelyFetchPending = false;
|
|
}
|
|
else if (mFetchTimer.getElapsedTimeF32() > mMaxTimeBetweenFetches)
|
|
{
|
|
mFetchFolderQueue.push_back(info);
|
|
mFetchTimer.reset();
|
|
mTimelyFetchPending = false;
|
|
}
|
|
// Not enough time has elapsed to do a new fetch
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// DEPRECATED OLD CODE
|
|
//--------------------------------------------------------------------------------
|
|
#endif
|
|
}
|
|
}
|
|
|
|
void LLInventoryModelBackgroundFetch::incrFetchCount(S32 fetching)
|
|
{
|
|
mFetchCount += fetching;
|
|
if (mFetchCount < 0)
|
|
{
|
|
LL_WARNS_ONCE(LOG_INV) << "Inventory fetch count fell below zero (0)." << LL_ENDL;
|
|
mFetchCount = 0;
|
|
}
|
|
}
|
|
void LLInventoryModelBackgroundFetch::incrFetchFolderCount(S32 fetching)
|
|
{
|
|
incrFetchCount(fetching);
|
|
mFetchFolderCount += fetching;
|
|
if (mFetchCount < 0)
|
|
{
|
|
LL_WARNS_ONCE(LOG_INV) << "Inventory fetch count fell below zero (0)." << LL_ENDL;
|
|
mFetchFolderCount = 0;
|
|
}
|
|
}
|
|
|
|
void ais_simple_item_callback(const LLUUID& inv_id)
|
|
{
|
|
LL_DEBUGS(LOG_INV , "AIS3") << "Response for " << inv_id << LL_ENDL;
|
|
LLInventoryModelBackgroundFetch::instance().incrFetchCount(-1);
|
|
}
|
|
|
|
void LLInventoryModelBackgroundFetch::onAISContentCalback(
|
|
const LLUUID& request_id,
|
|
const uuid_vec_t& content_ids,
|
|
const LLUUID& response_id,
|
|
EFetchType fetch_type)
|
|
{
|
|
// Don't emplace_front on failure - there is a chance it was fired from inside bulkFetchViaAis
|
|
incrFetchFolderCount(-1);
|
|
|
|
uuid_vec_t::const_iterator folder_iter = content_ids.begin();
|
|
uuid_vec_t::const_iterator folder_end = content_ids.end();
|
|
while (folder_iter != folder_end)
|
|
{
|
|
std::list<LLUUID>::const_iterator found = std::find(mExpectedFolderIds.begin(), mExpectedFolderIds.end(), *folder_iter);
|
|
if (found != mExpectedFolderIds.end())
|
|
{
|
|
mExpectedFolderIds.erase(found);
|
|
}
|
|
|
|
LLViewerInventoryCategory* cat(gInventory.getCategory(*folder_iter));
|
|
if (cat)
|
|
{
|
|
cat->setFetching(LLViewerInventoryCategory::FETCH_NONE);
|
|
}
|
|
if (response_id.isNull())
|
|
{
|
|
// Failed to fetch, get it individually
|
|
mFetchFolderQueue.emplace_back(*folder_iter, FT_RECURSIVE);
|
|
}
|
|
else
|
|
{
|
|
// push descendant back to verify they are fetched fully (ex: didn't encounter depth limit)
|
|
LLInventoryModel::cat_array_t* categories(NULL);
|
|
LLInventoryModel::item_array_t* items(NULL);
|
|
gInventory.getDirectDescendentsOf(*folder_iter, categories, items);
|
|
if (categories)
|
|
{
|
|
for (LLInventoryModel::cat_array_t::const_iterator it = categories->begin();
|
|
it != categories->end();
|
|
++it)
|
|
{
|
|
mFetchFolderQueue.emplace_back((*it)->getUUID(), FT_RECURSIVE);
|
|
}
|
|
}
|
|
}
|
|
|
|
folder_iter++;
|
|
}
|
|
|
|
if (!mFetchFolderQueue.empty())
|
|
{
|
|
mBackgroundFetchActive = true;
|
|
mFolderFetchActive = true;
|
|
gIdleCallbacks.addFunction(&LLInventoryModelBackgroundFetch::backgroundFetchCB, nullptr);
|
|
}
|
|
}
|
|
void LLInventoryModelBackgroundFetch::onAISFolderCalback(const LLUUID& request_id, const LLUUID& response_id, EFetchType fetch_type)
|
|
{
|
|
// Don't emplace_front on failure - there is a chance it was fired from inside bulkFetchViaAis
|
|
incrFetchFolderCount(-1);
|
|
std::list<LLUUID>::const_iterator found = std::find(mExpectedFolderIds.begin(), mExpectedFolderIds.end(), request_id);
|
|
if (found != mExpectedFolderIds.end())
|
|
{
|
|
mExpectedFolderIds.erase(found);
|
|
}
|
|
else
|
|
{
|
|
// ais shouldn't respond twice
|
|
llassert(false);
|
|
LL_WARNS() << "Unexpected folder response for " << request_id << LL_ENDL;
|
|
}
|
|
|
|
if (request_id.isNull())
|
|
{
|
|
// orphans, no other actions needed
|
|
return;
|
|
}
|
|
|
|
LLViewerInventoryCategory::EFetchType new_state = LLViewerInventoryCategory::FETCH_NONE;
|
|
bool request_descendants = false;
|
|
if (response_id.isNull()) // Failure
|
|
{
|
|
LL_DEBUGS(LOG_INV , "AIS3") << "Failure response for folder " << request_id << LL_ENDL;
|
|
if (fetch_type == FT_RECURSIVE)
|
|
{
|
|
// A full recursive request failed.
|
|
// Try requesting folder and nested content separately
|
|
mFetchFolderQueue.emplace_back(request_id, FT_FOLDER_AND_CONTENT);
|
|
}
|
|
else if (fetch_type == FT_FOLDER_AND_CONTENT)
|
|
{
|
|
LL_WARNS() << "Failed to download folder: " << request_id << " Requesting known content separately" << LL_ENDL;
|
|
mFetchFolderQueue.emplace_back(request_id, FT_CONTENT_RECURSIVE);
|
|
|
|
// set folder's version to prevent viewer from trying to request folder indefinetely
|
|
LLViewerInventoryCategory* cat(gInventory.getCategory(request_id));
|
|
if (cat && cat->getVersion() == LLViewerInventoryCategory::VERSION_UNKNOWN)
|
|
{
|
|
cat->setVersion(0);
|
|
}
|
|
// back off for a bit in case something tries to force-request immediately
|
|
new_state = LLViewerInventoryCategory::FETCH_FAILED;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (fetch_type == FT_RECURSIVE)
|
|
{
|
|
// Got the folder and content, now verify content
|
|
// Request content even for FT_RECURSIVE in case of changes, failures
|
|
// or if depth limit gets implemented.
|
|
// This shouldn't redownload folders if they already have version
|
|
request_descendants = true;
|
|
LL_DEBUGS(LOG_INV, "AIS3") << "Got folder " << request_id << ". Requesting content" << LL_ENDL;
|
|
}
|
|
else if (fetch_type == FT_FOLDER_AND_CONTENT)
|
|
{
|
|
// read folder for content request
|
|
mFetchFolderQueue.emplace_front(request_id, FT_CONTENT_RECURSIVE);
|
|
}
|
|
else
|
|
{
|
|
LL_DEBUGS(LOG_INV, "AIS3") << "Got folder " << request_id << "." << LL_ENDL;
|
|
}
|
|
|
|
}
|
|
|
|
if (request_descendants)
|
|
{
|
|
LLInventoryModel::cat_array_t* categories(NULL);
|
|
LLInventoryModel::item_array_t* items(NULL);
|
|
gInventory.getDirectDescendentsOf(request_id, categories, items);
|
|
if (categories)
|
|
{
|
|
for (LLInventoryModel::cat_array_t::const_iterator it = categories->begin();
|
|
it != categories->end();
|
|
++it)
|
|
{
|
|
mFetchFolderQueue.emplace_back((*it)->getUUID(), FT_RECURSIVE);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!mFetchFolderQueue.empty())
|
|
{
|
|
mBackgroundFetchActive = true;
|
|
mFolderFetchActive = true;
|
|
gIdleCallbacks.addFunction(&LLInventoryModelBackgroundFetch::backgroundFetchCB, nullptr);
|
|
}
|
|
|
|
// done
|
|
LLViewerInventoryCategory* cat(gInventory.getCategory(request_id));
|
|
if (cat)
|
|
{
|
|
cat->setFetching(new_state);
|
|
}
|
|
}
|
|
|
|
static LLTrace::BlockTimerStatHandle FTM_BULK_FETCH("Bulk Fetch");
|
|
|
|
void LLInventoryModelBackgroundFetch::bulkFetchViaAis()
|
|
{
|
|
LL_RECORD_BLOCK_TIME(FTM_BULK_FETCH);
|
|
//Background fetch is called from gIdleCallbacks in a loop until background fetch is stopped.
|
|
if (gDisconnected)
|
|
{
|
|
return;
|
|
}
|
|
|
|
static LLCachedControl<U32> ais_pool(gSavedSettings, "PoolSizeAIS", 20);
|
|
// Don't have too many requests at once, AIS throttles
|
|
// Reserve one request for actions outside of fetch (like renames)
|
|
const U32 max_concurrent_fetches = llclamp(ais_pool - 1, 1, 50);
|
|
|
|
if ((U32)mFetchCount >= max_concurrent_fetches)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Don't loop for too long (in case of large, fully loaded inventory)
|
|
F64 curent_time = LLTimer::getTotalSeconds();
|
|
const F64 max_time = LLStartUp::getStartupState() > STATE_WEARABLES_WAIT
|
|
? 0.006f // 6 ms
|
|
: 1.f;
|
|
const F64 end_time = curent_time + max_time;
|
|
S32 last_fetch_count = mFetchCount;
|
|
|
|
while (!mFetchFolderQueue.empty() && (U32)mFetchCount < max_concurrent_fetches && curent_time < end_time)
|
|
{
|
|
const FetchQueueInfo& fetch_info(mFetchFolderQueue.front());
|
|
bulkFetchViaAis(fetch_info);
|
|
mFetchFolderQueue.pop_front();
|
|
curent_time = LLTimer::getTotalSeconds();
|
|
}
|
|
|
|
// Ideally we shouldn't fetch items if recursive fetch isn't done,
|
|
// but there is a chance some request will start timeouting and recursive
|
|
// fetch will get stuck on a single folder, don't block item fetch in such case
|
|
while (!mFetchItemQueue.empty() && (U32)mFetchCount < max_concurrent_fetches && curent_time < end_time)
|
|
{
|
|
const FetchQueueInfo& fetch_info(mFetchItemQueue.front());
|
|
bulkFetchViaAis(fetch_info);
|
|
mFetchItemQueue.pop_front();
|
|
curent_time = LLTimer::getTotalSeconds();
|
|
}
|
|
|
|
if (last_fetch_count != mFetchCount // if anything was added
|
|
|| mLastFetchCount != mFetchCount) // if anything was substracted
|
|
{
|
|
LL_DEBUGS(LOG_INV , "AIS3") << "Total active fetches: " << mLastFetchCount << "->" << last_fetch_count << "->" << mFetchCount
|
|
<< ", scheduled folder fetches: " << (S32)mFetchFolderQueue.size()
|
|
<< ", scheduled item fetches: " << (S32)mFetchItemQueue.size()
|
|
<< LL_ENDL;
|
|
mLastFetchCount = mFetchCount;
|
|
|
|
if (!mExpectedFolderIds.empty())
|
|
{
|
|
// A folder seem to be stack fetching on QA account, print oldest folder out
|
|
LL_DEBUGS(LOG_INV , "AIS3") << "Oldest expected folder: ";
|
|
std::list<LLUUID>::const_iterator iter = mExpectedFolderIds.begin();
|
|
LL_CONT << *iter;
|
|
if ((*iter).notNull())
|
|
{
|
|
LLViewerInventoryCategory* cat(gInventory.getCategory(*iter));
|
|
if (cat)
|
|
{
|
|
LL_CONT << " Folder name: " << cat->getName() << " Parent: " << cat->getParentUUID();
|
|
}
|
|
else
|
|
{
|
|
LL_CONT << " This folder doesn't exist";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LL_CONT << " Orphans request";
|
|
}
|
|
LL_CONT << LL_ENDL;
|
|
}
|
|
}
|
|
|
|
if (isFolderFetchProcessingComplete() && mFolderFetchActive)
|
|
{
|
|
if (!mRecursiveInventoryFetchStarted || mRecursiveMarketplaceFetchStarted)
|
|
{
|
|
setAllFoldersFetched();
|
|
}
|
|
else
|
|
{
|
|
// Intent is for marketplace request to happen after
|
|
// main inventory is done, unless requested by floater
|
|
mRecursiveMarketplaceFetchStarted = true;
|
|
const LLUUID& marketplacelistings_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_MARKETPLACE_LISTINGS);
|
|
if (marketplacelistings_id.notNull())
|
|
{
|
|
mFetchFolderQueue.emplace_front(marketplacelistings_id, FT_FOLDER_AND_CONTENT);
|
|
}
|
|
else
|
|
{
|
|
setAllFoldersFetched();
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
if (isBulkFetchProcessingComplete())
|
|
{
|
|
mBackgroundFetchActive = false;
|
|
}
|
|
}
|
|
|
|
void LLInventoryModelBackgroundFetch::bulkFetchViaAis(const FetchQueueInfo& fetch_info)
|
|
{
|
|
if (fetch_info.mIsCategory)
|
|
{
|
|
const LLUUID& cat_id(fetch_info.mUUID);
|
|
if (cat_id.isNull())
|
|
{
|
|
incrFetchFolderCount(1);
|
|
mExpectedFolderIds.emplace_back(cat_id);
|
|
// Lost and found
|
|
// Should it actually be recursive?
|
|
AISAPI::FetchOrphans([](const LLUUID& response_id)
|
|
{
|
|
LLInventoryModelBackgroundFetch::instance().onAISFolderCalback(LLUUID::null,
|
|
response_id,
|
|
FT_DEFAULT);
|
|
});
|
|
}
|
|
else
|
|
{
|
|
LLViewerInventoryCategory* cat(gInventory.getCategory(cat_id));
|
|
if (cat)
|
|
{
|
|
if (fetch_info.mFetchType == FT_CONTENT_RECURSIVE)
|
|
{
|
|
// fetch content only, ignore cat itself
|
|
uuid_vec_t children;
|
|
LLInventoryModel::cat_array_t* categories(NULL);
|
|
LLInventoryModel::item_array_t* items(NULL);
|
|
gInventory.getDirectDescendentsOf(cat_id, categories, items);
|
|
|
|
LLViewerInventoryCategory::EFetchType target_state = LLViewerInventoryCategory::FETCH_RECURSIVE;
|
|
bool content_done = true;
|
|
|
|
// Top limit is 'as many as you can put into url'
|
|
static LLCachedControl<S32> ais_batch(gSavedSettings, "BatchSizeAIS3", 20);
|
|
S32 batch_limit = llclamp(ais_batch(), 1, 40);
|
|
|
|
for (LLInventoryModel::cat_array_t::iterator it = categories->begin();
|
|
it != categories->end();
|
|
++it)
|
|
{
|
|
LLViewerInventoryCategory* child_cat = (*it);
|
|
if (LLViewerInventoryCategory::VERSION_UNKNOWN != child_cat->getVersion()
|
|
|| child_cat->getFetching() >= target_state)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (child_cat->getPreferredType() == LLFolderType::FT_MARKETPLACE_LISTINGS)
|
|
{
|
|
// special case, marketplace will fetch that as needed
|
|
continue;
|
|
}
|
|
|
|
children.emplace_back(child_cat->getUUID());
|
|
mExpectedFolderIds.emplace_back(child_cat->getUUID());
|
|
child_cat->setFetching(target_state);
|
|
|
|
if (children.size() >= batch_limit)
|
|
{
|
|
content_done = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!children.empty())
|
|
{
|
|
// increment before call in case of immediate callback
|
|
incrFetchFolderCount(1);
|
|
|
|
EFetchType type = fetch_info.mFetchType;
|
|
LLUUID cat_id = cat->getUUID(); // need a copy for lambda
|
|
AISAPI::completion_t cb = [cat_id, children, type](const LLUUID& response_id)
|
|
{
|
|
LLInventoryModelBackgroundFetch::instance().onAISContentCalback(cat_id, children, response_id, type);
|
|
};
|
|
|
|
AISAPI::ITEM_TYPE item_type = AISAPI::INVENTORY;
|
|
if (ALEXANDRIA_LINDEN_ID == cat->getOwnerID())
|
|
{
|
|
item_type = AISAPI::LIBRARY;
|
|
}
|
|
|
|
AISAPI::FetchCategorySubset(cat_id, children, item_type, true, cb, 0);
|
|
}
|
|
|
|
if (content_done)
|
|
{
|
|
// This will have a bit of overlap with onAISContentCalback,
|
|
// but something else might have downloaded folders, so verify
|
|
// every child that is complete has it's children done as well
|
|
for (LLInventoryModel::cat_array_t::iterator it = categories->begin();
|
|
it != categories->end();
|
|
++it)
|
|
{
|
|
LLViewerInventoryCategory* child_cat = (*it);
|
|
if (LLViewerInventoryCategory::VERSION_UNKNOWN != child_cat->getVersion())
|
|
{
|
|
mFetchFolderQueue.emplace_back(child_cat->getUUID(), FT_RECURSIVE);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// send it back to get the rest
|
|
mFetchFolderQueue.emplace_back(cat_id, FT_CONTENT_RECURSIVE);
|
|
}
|
|
}
|
|
else if (LLViewerInventoryCategory::VERSION_UNKNOWN == cat->getVersion()
|
|
|| fetch_info.mFetchType == FT_FORCED)
|
|
{
|
|
LLViewerInventoryCategory::EFetchType target_state =
|
|
fetch_info.mFetchType > FT_CONTENT_RECURSIVE
|
|
? LLViewerInventoryCategory::FETCH_RECURSIVE
|
|
: LLViewerInventoryCategory::FETCH_NORMAL;
|
|
// start again if we did a non-recursive fetch before
|
|
// to get all children in a single request
|
|
if (cat->getFetching() < target_state)
|
|
{
|
|
// increment before call in case of immediate callback
|
|
incrFetchFolderCount(1);
|
|
cat->setFetching(target_state);
|
|
mExpectedFolderIds.emplace_back(cat_id);
|
|
|
|
EFetchType type = fetch_info.mFetchType;
|
|
LLUUID cat_cb_id = cat_id;
|
|
AISAPI::completion_t cb = [cat_cb_id, type](const LLUUID& response_id)
|
|
{
|
|
LLInventoryModelBackgroundFetch::instance().onAISFolderCalback(cat_cb_id, response_id , type);
|
|
};
|
|
|
|
AISAPI::ITEM_TYPE item_type = AISAPI::INVENTORY;
|
|
if (ALEXANDRIA_LINDEN_ID == cat->getOwnerID())
|
|
{
|
|
item_type = AISAPI::LIBRARY;
|
|
}
|
|
|
|
AISAPI::FetchCategoryChildren(cat_id , item_type , type == FT_RECURSIVE , cb, 0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Already fetched, check if anything inside needs fetching
|
|
if (fetch_info.mFetchType == FT_RECURSIVE
|
|
|| fetch_info.mFetchType == FT_FOLDER_AND_CONTENT)
|
|
{
|
|
LLInventoryModel::cat_array_t* categories(NULL);
|
|
LLInventoryModel::item_array_t* items(NULL);
|
|
gInventory.getDirectDescendentsOf(cat_id, categories, items);
|
|
for (LLInventoryModel::cat_array_t::const_iterator it = categories->begin();
|
|
it != categories->end();
|
|
++it)
|
|
{
|
|
// not emplace_front to not cause an infinite loop
|
|
mFetchFolderQueue.emplace_back((*it)->getUUID(), FT_RECURSIVE);
|
|
}
|
|
}
|
|
}
|
|
} // else try to fetch folder either way?
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LLViewerInventoryItem* itemp(gInventory.getItem(fetch_info.mUUID));
|
|
|
|
if (itemp)
|
|
{
|
|
if (!itemp->isFinished() || fetch_info.mFetchType == FT_FORCED)
|
|
{
|
|
mFetchCount++;
|
|
if (itemp->getPermissions().getOwner() == gAgent.getID())
|
|
{
|
|
AISAPI::FetchItem(fetch_info.mUUID, AISAPI::INVENTORY, ais_simple_item_callback);
|
|
}
|
|
else
|
|
{
|
|
AISAPI::FetchItem(fetch_info.mUUID, AISAPI::LIBRARY, ais_simple_item_callback);
|
|
}
|
|
}
|
|
}
|
|
else // We don't know it, assume incomplete
|
|
{
|
|
// Assume agent's inventory, library wouldn't have gotten here
|
|
mFetchCount++;
|
|
AISAPI::FetchItem(fetch_info.mUUID, AISAPI::INVENTORY, ais_simple_item_callback);
|
|
}
|
|
}
|
|
|
|
if (fetch_info.mFetchType == FT_FORCED)
|
|
{
|
|
mForceFetchSet.erase(fetch_info.mUUID);
|
|
}
|
|
}
|
|
|
|
// Bundle up a bunch of requests to send all at once.
|
|
void LLInventoryModelBackgroundFetch::bulkFetch()
|
|
{
|
|
LL_RECORD_BLOCK_TIME(FTM_BULK_FETCH);
|
|
//Background fetch is called from gIdleCallbacks in a loop until background fetch is stopped.
|
|
//If there are items in mFetchQueue, we want to check the time since the last bulkFetch was
|
|
//sent. If it exceeds our retry time, go ahead and fire off another batch.
|
|
LLViewerRegion* region(gAgent.getRegion());
|
|
if (! region || gDisconnected || LLApp::isExiting())
|
|
{
|
|
return;
|
|
}
|
|
|
|
// *TODO: These values could be tweaked at runtime to effect
|
|
// a fast/slow fetch throttle. Once login is complete and the scene
|
|
// is mostly loaded, we could turn up the throttle and fill missing
|
|
// inventory more quickly.
|
|
static const U32 max_batch_size(10);
|
|
static const S32 max_concurrent_fetches(12); // Outstanding requests, not connections
|
|
|
|
if (mFetchCount)
|
|
{
|
|
// Process completed background HTTP requests
|
|
gInventory.handleResponses(false);
|
|
// Just processed a bunch of items.
|
|
// Note: do we really need notifyObservers() here?
|
|
// OnIdle it will be called anyway due to Add flag for processed item.
|
|
// It seems like in some cases we are updating on fail (no flag),
|
|
// but is there anything to update?
|
|
// <FS:Ansariel> FIRE-21376: Inventory not loading properly on OpenSim
|
|
//gInventory.notifyObservers();
|
|
if (LLGridManager::getInstance()->isInSecondLife())
|
|
{
|
|
gInventory.notifyObservers();
|
|
}
|
|
// </FS:Ansariel>
|
|
}
|
|
|
|
if (mFetchCount > max_concurrent_fetches)
|
|
{
|
|
return;
|
|
}
|
|
|
|
U32 item_count(0);
|
|
U32 folder_count(0);
|
|
|
|
const U32 sort_order(gSavedSettings.getU32(LLInventoryPanel::DEFAULT_SORT_ORDER) & 0x1);
|
|
|
|
// *TODO: Think I'd like to get a shared pointer to this and share it
|
|
// among all the folder requests.
|
|
uuid_vec_t recursive_cats;
|
|
uuid_vec_t all_cats; // duplicate avoidance
|
|
|
|
LLSD folder_request_body;
|
|
LLSD folder_request_body_lib;
|
|
LLSD item_request_body;
|
|
LLSD item_request_body_lib;
|
|
|
|
while (! mFetchFolderQueue.empty()
|
|
&& (item_count + folder_count) < max_batch_size)
|
|
{
|
|
const FetchQueueInfo& fetch_info(mFetchFolderQueue.front());
|
|
if (fetch_info.mIsCategory)
|
|
{
|
|
const LLUUID& cat_id(fetch_info.mUUID);
|
|
if (cat_id.isNull()) //DEV-17797 Lost and found
|
|
{
|
|
LLSD folder_sd;
|
|
folder_sd["folder_id"] = LLUUID::null.asString();
|
|
folder_sd["owner_id"] = gAgent.getID();
|
|
folder_sd["sort_order"] = LLSD::Integer(sort_order);
|
|
folder_sd["fetch_folders"] = LLSD::Boolean(false);
|
|
folder_sd["fetch_items"] = LLSD::Boolean(true);
|
|
folder_request_body["folders"].append(folder_sd);
|
|
folder_count++;
|
|
}
|
|
else
|
|
{
|
|
const LLViewerInventoryCategory* cat(gInventory.getCategory(cat_id));
|
|
if (cat)
|
|
{
|
|
if (LLViewerInventoryCategory::VERSION_UNKNOWN == cat->getVersion())
|
|
{
|
|
if (std::find(all_cats.begin(), all_cats.end(), cat_id) == all_cats.end())
|
|
{
|
|
LLSD folder_sd;
|
|
folder_sd["folder_id"] = cat->getUUID();
|
|
folder_sd["owner_id"] = cat->getOwnerID();
|
|
folder_sd["sort_order"] = LLSD::Integer(sort_order);
|
|
folder_sd["fetch_folders"] = LLSD::Boolean(true); //(LLSD::Boolean)sFullFetchStarted;
|
|
folder_sd["fetch_items"] = LLSD::Boolean(true);
|
|
|
|
// <FS:Beq> correct library owner for OpenSim (Rye)
|
|
//if (ALEXANDRIA_LINDEN_ID == cat->getOwnerID())
|
|
if (gInventory.getLibraryOwnerID() == cat->getOwnerID())
|
|
// </FS:Beq>
|
|
{
|
|
folder_request_body_lib["folders"].append(folder_sd);
|
|
}
|
|
else
|
|
{
|
|
folder_request_body["folders"].append(folder_sd);
|
|
}
|
|
folder_count++;
|
|
}
|
|
}
|
|
#ifdef OPENSIM
|
|
if (LLViewerInventoryCategory::VERSION_UNKNOWN != cat->getVersion() || !LLGridManager::getInstance()->isInSecondLife())
|
|
#else
|
|
else
|
|
#endif
|
|
{
|
|
// May already have this folder, but append child folders to list.
|
|
if (fetch_info.mFetchType >= FT_CONTENT_RECURSIVE)
|
|
{
|
|
LLInventoryModel::cat_array_t* categories(NULL);
|
|
LLInventoryModel::item_array_t* items(NULL);
|
|
gInventory.getDirectDescendentsOf(cat_id, categories, items);
|
|
for (LLInventoryModel::cat_array_t::const_iterator it = categories->begin();
|
|
it != categories->end();
|
|
++it)
|
|
{
|
|
mFetchFolderQueue.emplace_back((*it)->getUUID(), fetch_info.mFetchType);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (fetch_info.mFetchType >= FT_CONTENT_RECURSIVE)
|
|
{
|
|
recursive_cats.emplace_back(cat_id);
|
|
}
|
|
all_cats.emplace_back(cat_id);
|
|
}
|
|
|
|
mFetchFolderQueue.pop_front();
|
|
}
|
|
|
|
|
|
while (!mFetchItemQueue.empty()
|
|
&& (item_count + folder_count) < max_batch_size)
|
|
{
|
|
const FetchQueueInfo& fetch_info(mFetchItemQueue.front());
|
|
|
|
LLViewerInventoryItem* itemp(gInventory.getItem(fetch_info.mUUID));
|
|
|
|
if (itemp)
|
|
{
|
|
LLSD item_sd;
|
|
item_sd["owner_id"] = itemp->getPermissions().getOwner();
|
|
item_sd["item_id"] = itemp->getUUID();
|
|
if (itemp->getPermissions().getOwner() == gAgent.getID())
|
|
{
|
|
item_request_body.append(item_sd);
|
|
}
|
|
else
|
|
{
|
|
item_request_body_lib.append(item_sd);
|
|
}
|
|
//itemp->fetchFromServer();
|
|
item_count++;
|
|
}
|
|
|
|
mFetchItemQueue.pop_front();
|
|
}
|
|
|
|
// Issue HTTP POST requests to fetch folders and items
|
|
|
|
if (item_count + folder_count > 0)
|
|
{
|
|
if (folder_count)
|
|
{
|
|
if (folder_request_body["folders"].size())
|
|
{
|
|
const std::string url(region->getCapability("FetchInventoryDescendents2"));
|
|
|
|
if (! url.empty())
|
|
{
|
|
LLCore::HttpHandler::ptr_t handler(new BGFolderHttpHandler(folder_request_body, recursive_cats));
|
|
gInventory.requestPost(false, url, folder_request_body, handler, "Inventory Folder");
|
|
}
|
|
}
|
|
|
|
if (folder_request_body_lib["folders"].size())
|
|
{
|
|
const std::string url(region->getCapability("FetchLibDescendents2"));
|
|
|
|
if (! url.empty())
|
|
{
|
|
LLCore::HttpHandler::ptr_t handler(new BGFolderHttpHandler(folder_request_body_lib, recursive_cats));
|
|
gInventory.requestPost(false, url, folder_request_body_lib, handler, "Library Folder");
|
|
}
|
|
}
|
|
} // if (folder_count)
|
|
|
|
if (item_count)
|
|
{
|
|
if (item_request_body.size())
|
|
{
|
|
const std::string url(region->getCapability("FetchInventory2"));
|
|
|
|
if (! url.empty())
|
|
{
|
|
LLSD body;
|
|
body["items"] = item_request_body;
|
|
LLCore::HttpHandler::ptr_t handler(new BGItemHttpHandler(body));
|
|
gInventory.requestPost(false, url, body, handler, "Inventory Item");
|
|
}
|
|
}
|
|
|
|
if (item_request_body_lib.size())
|
|
{
|
|
const std::string url(region->getCapability("FetchLib2"));
|
|
|
|
if (! url.empty())
|
|
{
|
|
LLSD body;
|
|
body["items"] = item_request_body_lib;
|
|
LLCore::HttpHandler::ptr_t handler(new BGItemHttpHandler(body));
|
|
gInventory.requestPost(false, url, body, handler, "Library Item");
|
|
}
|
|
}
|
|
} // if (item_count)
|
|
|
|
mFetchTimer.reset();
|
|
}
|
|
else if (isBulkFetchProcessingComplete())
|
|
{
|
|
setAllFoldersFetched();
|
|
}
|
|
}
|
|
|
|
bool LLInventoryModelBackgroundFetch::fetchQueueContainsNoDescendentsOf(const LLUUID& cat_id) const
|
|
{
|
|
for (fetch_queue_t::const_iterator it = mFetchFolderQueue.begin();
|
|
it != mFetchFolderQueue.end();
|
|
++it)
|
|
{
|
|
const LLUUID& fetch_id = (*it).mUUID;
|
|
if (gInventory.isObjectDescendentOf(fetch_id, cat_id))
|
|
return false;
|
|
}
|
|
for (fetch_queue_t::const_iterator it = mFetchItemQueue.begin();
|
|
it != mFetchItemQueue.end();
|
|
++it)
|
|
{
|
|
const LLUUID& fetch_id = (*it).mUUID;
|
|
if (gInventory.isObjectDescendentOf(fetch_id, cat_id))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
namespace
|
|
{
|
|
|
|
///----------------------------------------------------------------------------
|
|
/// Class <anonymous>::BGFolderHttpHandler
|
|
///----------------------------------------------------------------------------
|
|
|
|
void BGFolderHttpHandler::onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse* response)
|
|
{
|
|
do // Single-pass do-while used for common exit handling
|
|
{
|
|
LLCore::HttpStatus status(response->getStatus());
|
|
// status = LLCore::HttpStatus(404); // Dev tool to force error handling
|
|
if (! status)
|
|
{
|
|
processFailure(status, response);
|
|
break; // Goto common exit
|
|
}
|
|
|
|
// Response body should be present.
|
|
LLCore::BufferArray* body(response->getBody());
|
|
// body = NULL; // Dev tool to force error handling
|
|
if (! body || ! body->size())
|
|
{
|
|
LL_WARNS(LOG_INV) << "Missing data in inventory folder query." << LL_ENDL;
|
|
processFailure("HTTP response missing expected body", response);
|
|
break; // Goto common exit
|
|
}
|
|
|
|
// Could test 'Content-Type' header but probably unreliable.
|
|
|
|
// Convert response to LLSD
|
|
// body->write(0, "Garbage Response", 16); // Dev tool to force error handling
|
|
LLSD body_llsd;
|
|
if (! LLCoreHttpUtil::responseToLLSD(response, true, body_llsd))
|
|
{
|
|
// INFOS-level logging will occur on the parsed failure
|
|
processFailure("HTTP response contained malformed LLSD", response);
|
|
break; // goto common exit
|
|
}
|
|
|
|
// Expect top-level structure to be a map
|
|
// body_llsd = LLSD::emptyArray(); // Dev tool to force error handling
|
|
if (! body_llsd.isMap())
|
|
{
|
|
processFailure("LLSD response not a map", response);
|
|
break; // goto common exit
|
|
}
|
|
|
|
// Check for 200-with-error failures
|
|
//
|
|
// See comments in llinventorymodel.cpp about this mode of error.
|
|
//
|
|
// body_llsd["error"] = LLSD::emptyMap(); // Dev tool to force error handling
|
|
// body_llsd["error"]["identifier"] = "Development";
|
|
// body_llsd["error"]["message"] = "You left development code in the viewer";
|
|
if (body_llsd.has("error"))
|
|
{
|
|
processFailure("Inventory application error (200-with-error)", response);
|
|
break; // goto common exit
|
|
}
|
|
|
|
// Okay, process data if possible
|
|
processData(body_llsd, response);
|
|
}
|
|
while (false);
|
|
}
|
|
|
|
|
|
void BGFolderHttpHandler::processData(LLSD& content, LLCore::HttpResponse* response)
|
|
{
|
|
LLInventoryModelBackgroundFetch* fetcher(LLInventoryModelBackgroundFetch::getInstance());
|
|
|
|
// API V2 and earlier should probably be testing for "error" map
|
|
// in response as an application-level error.
|
|
|
|
// Instead, we assume success and attempt to extract information.
|
|
if (content.has("folders"))
|
|
{
|
|
LLSD folders(content["folders"]);
|
|
|
|
for (LLSD::array_const_iterator folder_it = folders.beginArray();
|
|
folder_it != folders.endArray();
|
|
++folder_it)
|
|
{
|
|
LLSD folder_sd(*folder_it);
|
|
|
|
//LLUUID agent_id = folder_sd["agent_id"];
|
|
|
|
//if (agent_id != gAgent.getID()) //This should never happen.
|
|
//{
|
|
// LL_WARNS(LOG_INV) << "Got a UpdateInventoryItem for the wrong agent."
|
|
// << LL_ENDL;
|
|
// break;
|
|
//}
|
|
|
|
LLUUID parent_id(folder_sd["folder_id"].asUUID());
|
|
LLUUID owner_id(folder_sd["owner_id"].asUUID());
|
|
S32 version(folder_sd["version"].asInteger());
|
|
S32 descendents(folder_sd["descendents"].asInteger());
|
|
LLPointer<LLViewerInventoryCategory> tcategory = new LLViewerInventoryCategory(owner_id);
|
|
|
|
if (parent_id.isNull())
|
|
{
|
|
LLSD items(folder_sd["items"]);
|
|
LLPointer<LLViewerInventoryItem> titem = new LLViewerInventoryItem;
|
|
|
|
for (LLSD::array_const_iterator item_it = items.beginArray();
|
|
item_it != items.endArray();
|
|
++item_it)
|
|
{
|
|
const LLUUID lost_uuid(gInventory.findCategoryUUIDForType(LLFolderType::FT_LOST_AND_FOUND));
|
|
|
|
if (lost_uuid.notNull())
|
|
{
|
|
LLSD item(*item_it);
|
|
|
|
titem->unpackMessage(item);
|
|
|
|
LLInventoryModel::update_list_t update;
|
|
LLInventoryModel::LLCategoryUpdate new_folder(lost_uuid, 1);
|
|
update.emplace_back(new_folder);
|
|
gInventory.accountForUpdate(update);
|
|
|
|
titem->setParent(lost_uuid);
|
|
titem->updateParentOnServer(false);
|
|
gInventory.updateItem(titem);
|
|
// <FS:Ansariel> FIRE-21376: Inventory not loading properly on OpenSim
|
|
if (!LLGridManager::getInstance()->isInSecondLife())
|
|
{
|
|
gInventory.notifyObservers();
|
|
}
|
|
// </FS:Ansariel>
|
|
}
|
|
}
|
|
}
|
|
|
|
LLViewerInventoryCategory* pcat(gInventory.getCategory(parent_id));
|
|
if (! pcat)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
LLSD categories(folder_sd["categories"]);
|
|
for (LLSD::array_const_iterator category_it = categories.beginArray();
|
|
category_it != categories.endArray();
|
|
++category_it)
|
|
{
|
|
LLSD category(*category_it);
|
|
tcategory->fromLLSD(category);
|
|
|
|
const bool recursive(getIsRecursive(tcategory->getUUID()));
|
|
if (recursive)
|
|
{
|
|
fetcher->addRequestAtBack(tcategory->getUUID(), recursive, true);
|
|
}
|
|
else if (! gInventory.isCategoryComplete(tcategory->getUUID()))
|
|
{
|
|
gInventory.updateCategory(tcategory);
|
|
}
|
|
}
|
|
|
|
LLSD items(folder_sd["items"]);
|
|
LLPointer<LLViewerInventoryItem> titem = new LLViewerInventoryItem;
|
|
for (LLSD::array_const_iterator item_it = items.beginArray();
|
|
item_it != items.endArray();
|
|
++item_it)
|
|
{
|
|
LLSD item(*item_it);
|
|
titem->unpackMessage(item);
|
|
|
|
gInventory.updateItem(titem);
|
|
}
|
|
|
|
// Set version and descendentcount according to message.
|
|
LLViewerInventoryCategory* cat(gInventory.getCategory(parent_id));
|
|
if (cat)
|
|
{
|
|
cat->setVersion(version);
|
|
cat->setDescendentCount(descendents);
|
|
cat->determineFolderType();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (content.has("bad_folders"))
|
|
{
|
|
LLSD bad_folders(content["bad_folders"]);
|
|
for (LLSD::array_const_iterator folder_it = bad_folders.beginArray();
|
|
folder_it != bad_folders.endArray();
|
|
++folder_it)
|
|
{
|
|
// *TODO: Stop copying data [ed: this isn't copying data]
|
|
LLSD folder_sd(*folder_it);
|
|
|
|
// These folders failed on the dataserver. We probably don't want to retry them.
|
|
LL_WARNS(LOG_INV) << "Folder " << folder_sd["folder_id"].asString()
|
|
<< "Error: " << folder_sd["error"].asString() << LL_ENDL;
|
|
}
|
|
}
|
|
|
|
if (fetcher->isBulkFetchProcessingComplete())
|
|
{
|
|
fetcher->setAllFoldersFetched();
|
|
}
|
|
|
|
// <FS:Ansariel> FIRE-21376: Inventory not loading properly on OpenSim
|
|
if (!LLGridManager::getInstance()->isInSecondLife())
|
|
{
|
|
gInventory.notifyObservers();
|
|
}
|
|
// </FS:Ansariel>
|
|
}
|
|
|
|
|
|
void BGFolderHttpHandler::processFailure(LLCore::HttpStatus status, LLCore::HttpResponse* response)
|
|
{
|
|
const std::string& ct(response->getContentType());
|
|
LL_WARNS(LOG_INV) << "Inventory folder fetch failure\n"
|
|
<< "[Status: " << status.toTerseString() << "]\n"
|
|
<< "[Reason: " << status.toString() << "]\n"
|
|
<< "[Content-type: " << ct << "]\n"
|
|
<< "[Content (abridged): "
|
|
<< LLCoreHttpUtil::responseToString(response) << "]" << LL_ENDL;
|
|
|
|
// Could use a 404 test here to try to detect revoked caps...
|
|
|
|
if (status == LLCore::HttpStatus(HTTP_FORBIDDEN))
|
|
{
|
|
// Too large, split into two if possible
|
|
if (gDisconnected || LLApp::isExiting())
|
|
{
|
|
return;
|
|
}
|
|
|
|
const std::string url(gAgent.getRegionCapability("FetchInventoryDescendents2"));
|
|
if (url.empty())
|
|
{
|
|
LL_WARNS(LOG_INV) << "Failed to get AIS2 cap" << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
auto size = mRequestSD["folders"].size();
|
|
|
|
if (size > 1)
|
|
{
|
|
// Can split, assume that this isn't the library
|
|
LLSD folders;
|
|
uuid_vec_t recursive_cats;
|
|
LLSD::array_iterator iter = mRequestSD["folders"].beginArray();
|
|
LLSD::array_iterator end = mRequestSD["folders"].endArray();
|
|
while (iter != end)
|
|
{
|
|
folders.append(*iter);
|
|
LLUUID folder_id = iter->get("folder_id").asUUID();
|
|
if (std::find(mRecursiveCatUUIDs.begin(), mRecursiveCatUUIDs.end(), folder_id) != mRecursiveCatUUIDs.end())
|
|
{
|
|
recursive_cats.emplace_back(folder_id);
|
|
}
|
|
if (folders.size() == (size / 2))
|
|
{
|
|
LLSD request_body;
|
|
request_body["folders"] = folders;
|
|
LLCore::HttpHandler::ptr_t handler(new BGFolderHttpHandler(request_body, recursive_cats));
|
|
gInventory.requestPost(false, url, request_body, handler, "Inventory Folder");
|
|
recursive_cats.clear();
|
|
folders.clear();
|
|
}
|
|
iter++;
|
|
}
|
|
|
|
LLSD request_body;
|
|
request_body["folders"] = folders;
|
|
LLCore::HttpHandler::ptr_t handler(new BGFolderHttpHandler(request_body, recursive_cats));
|
|
gInventory.requestPost(false, url, request_body, handler, "Inventory Folder");
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
// Can't split
|
|
LLNotificationsUtil::add("InventoryLimitReachedAIS");
|
|
}
|
|
}
|
|
|
|
// This was originally the request retry logic for the inventory
|
|
// request which tested on HTTP_INTERNAL_ERROR status. This
|
|
// retry logic was unbounded and lacked discrimination as to the
|
|
// cause of the retry. The new http library should be doing
|
|
// adequately on retries but I want to keep the structure of a
|
|
// retry for reference.
|
|
LLInventoryModelBackgroundFetch* fetcher = LLInventoryModelBackgroundFetch::getInstance();
|
|
if (false)
|
|
{
|
|
// timed out or curl failure
|
|
for (LLSD::array_const_iterator folder_it = mRequestSD["folders"].beginArray();
|
|
folder_it != mRequestSD["folders"].endArray();
|
|
++folder_it)
|
|
{
|
|
LLSD folder_sd(*folder_it);
|
|
LLUUID folder_id(folder_sd["folder_id"].asUUID());
|
|
const bool recursive = getIsRecursive(folder_id);
|
|
fetcher->addRequestAtFront(folder_id, recursive, true);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (fetcher->isBulkFetchProcessingComplete())
|
|
{
|
|
fetcher->setAllFoldersFetched();
|
|
}
|
|
}
|
|
|
|
// <FS:Ansariel> FIRE-21376: Inventory not loading properly on OpenSim
|
|
if (!LLGridManager::getInstance()->isInSecondLife())
|
|
{
|
|
gInventory.notifyObservers();
|
|
}
|
|
// </FS:Ansariel>
|
|
}
|
|
|
|
|
|
void BGFolderHttpHandler::processFailure(const char* const reason, LLCore::HttpResponse* response)
|
|
{
|
|
LL_WARNS(LOG_INV) << "Inventory folder fetch failure\n"
|
|
<< "[Status: internal error]\n"
|
|
<< "[Reason: " << reason << "]\n"
|
|
<< "[Content (abridged): "
|
|
<< LLCoreHttpUtil::responseToString(response) << "]" << LL_ENDL;
|
|
|
|
// Reverse of previous processFailure() method, this is invoked
|
|
// when response structure is found to be invalid. Original
|
|
// always re-issued the request (without limit). This does
|
|
// the same but be aware that this may be a source of problems.
|
|
// Philosophy is that inventory folders are so essential to
|
|
// operation that this is a reasonable action.
|
|
LLInventoryModelBackgroundFetch* fetcher = LLInventoryModelBackgroundFetch::getInstance();
|
|
if (true)
|
|
{
|
|
for (LLSD::array_const_iterator folder_it = mRequestSD["folders"].beginArray();
|
|
folder_it != mRequestSD["folders"].endArray();
|
|
++folder_it)
|
|
{
|
|
LLSD folder_sd(*folder_it);
|
|
LLUUID folder_id(folder_sd["folder_id"].asUUID());
|
|
const bool recursive = getIsRecursive(folder_id);
|
|
fetcher->addRequestAtFront(folder_id, recursive, true);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (fetcher->isBulkFetchProcessingComplete())
|
|
{
|
|
fetcher->setAllFoldersFetched();
|
|
}
|
|
}
|
|
|
|
// <FS:Ansariel> FIRE-21376: Inventory not loading properly on OpenSim
|
|
if (!LLGridManager::getInstance()->isInSecondLife())
|
|
{
|
|
gInventory.notifyObservers();
|
|
}
|
|
// </FS:Ansariel>
|
|
}
|
|
|
|
|
|
bool BGFolderHttpHandler::getIsRecursive(const LLUUID& cat_id) const
|
|
{
|
|
return std::find(mRecursiveCatUUIDs.begin(), mRecursiveCatUUIDs.end(), cat_id) != mRecursiveCatUUIDs.end();
|
|
}
|
|
|
|
///----------------------------------------------------------------------------
|
|
/// Class <anonymous>::BGItemHttpHandler
|
|
///----------------------------------------------------------------------------
|
|
|
|
// Nothing to implement here. All ctor/dtor changes.
|
|
|
|
} // end namespace anonymous
|