/** * @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" // 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 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 (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(); } } } 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? gInventory.notifyObservers(); } 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); if (ALEXANDRIA_LINDEN_ID == cat->getOwnerID()) { folder_request_body_lib["folders"].append(folder_sd); } else { folder_request_body["folders"].append(folder_sd); } folder_count++; } } else { // 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); } } } 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(); } } 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(); } } } 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(); } } } 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