void run() {
// RARELY shoud be once/128x
for (int i=0; i<150; i++) {
insert();
updateSucceed();
}
DBDirectClient client;
int count = (int) client.count(cappedNs(), BSONObj());
verify(count > 1);
// Just to be sure, no _id index, right?
Client::Context ctx(cappedNs());
NamespaceDetails *nsd = nsdetails(cappedNs().c_str());
verify(nsd->findIdIndex() == -1);
}
void AssetsManagerEx::onDownloadUnitsFinished()
{
// Finished with error check
if (_failedUnits.size() > 0)
{
// Save current download manifest information for resuming
_tempManifest->saveToFile(_tempManifestPath);
_updateState = State::FAIL_TO_UPDATE;
dispatchUpdateEvent(EventAssetsManagerEx::EventCode::UPDATE_FAILED);
}
else if (_updateState == State::UPDATING)
{
updateSucceed();
}
}
void run() {
OperationContextImpl txn;
// RARELY shoud be once/128x
for (int i=0; i<150; i++) {
insert(&txn);
updateSucceed();
}
DBDirectClient client(&txn);
int count = (int) client.count(cappedNs(), BSONObj());
verify(count > 1);
// check _id index created
Client::Context ctx(cappedNs());
Collection* collection = ctx.db()->getCollection( &txn, cappedNs() );
verify(collection->getIndexCatalog()->findIdIndex());
}
void ModuleMgr::updateAssets(const ModuleDownloader::DownloadUnits& assets)
{
if (_updateState != State::UPDATING && _remoteManifest->isLoaded())
{
int size = (int)(assets.size());
if (size > 0)
{
_updateState = State::UPDATING;
_downloadUnits.clear();
_downloadUnits = assets;
_downloader->batchDownloadAsync(_downloadUnits, BATCH_UPDATE_ID);
}
else if (size == 0 && _totalWaitToDownload == 0)
{
updateSucceed();
}
}
}
void ModuleMgr::onSuccess(const std::string &srcUrl, const std::string &storagePath, const std::string &customId)
{
CCLOG("ModuleMgr::onSuccess: %s %s", customId.c_str(), storagePath.c_str());
if (customId == MANIFEST_ID)
{
_updateState = State::MANIFEST_LOADED;
parseManifest();
}
else if (customId == BATCH_UPDATE_ID)
{
// Finished with error check
if (_failedUnits.size() > 0 || _totalWaitToDownload > 0)
{
// Save current download manifest information for resuming
//_tempManifest->saveToFile(_tempManifestPath);
decompressDownloadedZip();
_updateState = State::FAIL_TO_UPDATE;
dispatchUpdateEvent(ModuleMgrEvent::EventCode::UPDATE_FAILED);
}
else
{
updateSucceed();
}
}
else
{
auto assets = _remoteManifest->getAssets();
auto assetIt = assets.find(customId);
if (assetIt != assets.end())
{
// Set download state to SUCCESSED
_remoteManifest->setAssetDownloadState(customId, ModuleManifest::DownloadState::SUCCESSED);
// Add file to need decompress list
if (assetIt->second.compressed) {
_compressedFiles.push_back(storagePath);
}
}
auto unitIt = _downloadUnits.find(customId);
if (unitIt != _downloadUnits.end())
{
// Reduce count only when unit found in _downloadUnits
_totalWaitToDownload--;
_percentByFile = 100 * (float)(_totalToDownload - _totalWaitToDownload) / _totalToDownload;
// Notify progression event
dispatchUpdateEvent(ModuleMgrEvent::EventCode::UPDATE_PROGRESSION, "");
}
// Notify asset updated event
dispatchUpdateEvent(ModuleMgrEvent::EventCode::ASSET_UPDATED, customId);
unitIt = _failedUnits.find(customId);
// Found unit and delete it
if (unitIt != _failedUnits.end())
{
// Remove from failed units list
_failedUnits.erase(unitIt);
}
}
}
void AssetsManagerEx::startUpdate()
{
if (_updateState != State::NEED_UPDATE)
return;
_updateState = State::UPDATING;
// Clean up before update
_failedUnits.clear();
_downloadUnits.clear();
_totalWaitToDownload = _totalToDownload = 0;
_nextSavePoint = 0;
_percent = _percentByFile = _sizeCollected = _totalSize = 0;
_downloadedSize.clear();
_totalEnabled = false;
// Temporary manifest exists, resuming previous download
if (_tempManifest && _tempManifest->isLoaded() && _tempManifest->versionEquals(_remoteManifest))
{
_tempManifest->saveToFile(_tempManifestPath);
_tempManifest->genResumeAssetsList(&_downloadUnits);
_totalWaitToDownload = _totalToDownload = (int)_downloadUnits.size();
this->batchDownload();
std::string msg = StringUtils::format("Resuming from previous unfinished update, %d files remains to be finished.", _totalToDownload);
dispatchUpdateEvent(EventAssetsManagerEx::EventCode::UPDATE_PROGRESSION, "", msg);
}
else
{
// Temporary manifest exists, but can't be parsed or version doesn't equals remote manifest (out of date)
if (_tempManifest)
{
// Remove all temp files
_fileUtils->removeDirectory(_tempStoragePath);
CC_SAFE_RELEASE(_tempManifest);
// Recreate temp storage path and save remote manifest
_fileUtils->createDirectory(_tempStoragePath);
_remoteManifest->saveToFile(_tempManifestPath);
}
// Temporary manifest will be used to register the download states of each asset,
// in this case, it equals remote manifest.
_tempManifest = _remoteManifest;
// Check difference between local manifest and remote manifest
std::unordered_map<std::string, Manifest::AssetDiff> diff_map = _localManifest->genDiff(_remoteManifest);
if (diff_map.size() == 0)
{
updateSucceed();
}
else
{
// Generate download units for all assets that need to be updated or added
std::string packageUrl = _remoteManifest->getPackageUrl();
// Save current download manifest information for resuming
_tempManifest->saveToFile(_tempManifestPath);
// Preprocessing local files in previous version and creating download folders
for (auto it = diff_map.begin(); it != diff_map.end(); ++it)
{
Manifest::AssetDiff diff = it->second;
if (diff.type != Manifest::DiffType::DELETED)
{
std::string path = diff.asset.path;
DownloadUnit unit;
unit.customId = it->first;
unit.srcUrl = packageUrl + path;
unit.storagePath = _tempStoragePath + path;
unit.size = diff.asset.size;
_downloadUnits.emplace(unit.customId, unit);
_tempManifest->setAssetDownloadState(it->first, Manifest::DownloadState::UNSTARTED);
}
}
_totalWaitToDownload = _totalToDownload = (int)_downloadUnits.size();
this->batchDownload();
std::string msg = StringUtils::format("Start to update %d files from remote package.", _totalToDownload);
dispatchUpdateEvent(EventAssetsManagerEx::EventCode::UPDATE_PROGRESSION, "", msg);
}
}
}
