Mirrors/overte-AleziaKurdis
3
0
Fork 0
mirror of https://github.com/AleziaKurdis/overte.git synced 2025-04-08 02:32:43 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Pass in backup name to handler

Browse source
This commit is contained in:
Atlante45 2018-02-16 15:49:10 -08:00
parent acc68d65c2
commit c61aa4bf95
9 changed files with 76 additions and 78 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

57
domain-server/src/AssetsBackupHandler.cpp
View file

@ -112,9 +112,9 @@ void AssetsBackupHandler::checkForAssetsToDelete() {
}
std::pair<bool, float> AssetsBackupHandler::isAvailable(QString filePath) {
const auto it = find_if(begin(_backups), end(_backups), [&](const AssetServerBackup& value) {
return value.filePath == filePath;
std::pair<bool, float> AssetsBackupHandler::isAvailable(const QString& backupName) {
const auto it = find_if(begin(_backups), end(_backups), [&](const AssetServerBackup& backup) {
return backup.name == backupName;
});
if (it == end(_backups)) {
return { true, 1.0f };
@ -154,10 +154,10 @@ std::pair<bool, float> AssetsBackupHandler::getRecoveryStatus() {
return { true, progress };
}
void AssetsBackupHandler::loadBackup(QuaZip& zip) {
void AssetsBackupHandler::loadBackup(const QString& backupName, QuaZip& zip) {
Q_ASSERT(QThread::currentThread() == thread());
_backups.push_back({ zip.getZipName(), {}, false });
_backups.emplace_back(backupName, AssetUtils::Mappings(), false);
auto& backup = _backups.back();
if (!zip.setCurrentFile(MAPPINGS_FILE)) {
@ -170,7 +170,7 @@ void AssetsBackupHandler::loadBackup(QuaZip& zip) {
QuaZipFile zipFile { &zip };
if (!zipFile.open(QFile::ReadOnly)) {
qCCritical(asset_backup) << "Could not unzip backup file for load:" << zip.getZipName();
qCCritical(asset_backup) << "Could not unzip backup file for load:" << backupName;
qCCritical(asset_backup) << " Error:" << zip.getZipError();
backup.corruptedBackup = true;
_allBackupsLoadedSuccessfully = false;
@ -180,7 +180,7 @@ void AssetsBackupHandler::loadBackup(QuaZip& zip) {
QJsonParseError error;
auto document = QJsonDocument::fromJson(zipFile.readAll(), &error);
if (document.isNull() || !document.isObject()) {
qCCritical(asset_backup) << "Could not parse backup file to JSON object for load:" << zip.getZipName();
qCCritical(asset_backup) << "Could not parse backup file to JSON object for load:" << backupName;
qCCritical(asset_backup) << " Error:" << error.errorString();
backup.corruptedBackup = true;
_allBackupsLoadedSuccessfully = false;
@ -193,7 +193,7 @@ void AssetsBackupHandler::loadBackup(QuaZip& zip) {
const auto& assetHash = it.value().toString();
if (!AssetUtils::isValidHash(assetHash)) {
qCCritical(asset_backup) << "Corrupted mapping in loading backup file" << zip.getZipName() << ":" << it.key();
qCCritical(asset_backup) << "Corrupted mapping in loading backup file" << backupName << ":" << it.key();
backup.corruptedBackup = true;
_allBackupsLoadedSuccessfully = false;
continue;
@ -208,7 +208,7 @@ void AssetsBackupHandler::loadBackup(QuaZip& zip) {
return;
}
void AssetsBackupHandler::createBackup(QuaZip& zip) {
void AssetsBackupHandler::createBackup(const QString& backupName, QuaZip& zip) {
Q_ASSERT(QThread::currentThread() == thread());
if (operationInProgress()) {
@ -226,12 +226,11 @@ void AssetsBackupHandler::createBackup(QuaZip& zip) {
qCWarning(asset_backup) << "Backing up asset mappings that might be stale.";
}
AssetServerBackup backup;
backup.filePath = zip.getZipName();
AssetUtils::Mappings mappings;
QJsonObject jsonObject;
for (const auto& mapping : _currentMappings) {
backup.mappings[mapping.first] = mapping.second;
mappings[mapping.first] = mapping.second;
_assetsInBackups.insert(mapping.second);
jsonObject.insert(mapping.first, mapping.second);
}
@ -248,10 +247,11 @@ void AssetsBackupHandler::createBackup(QuaZip& zip) {
qCDebug(asset_backup) << "Could not close zip file: " << zipFile.getZipError();
return;
}
_backups.push_back(backup);
_backups.emplace_back(backupName, mappings, false);
qDebug() << "Created asset backup:" << backupName;
}
void AssetsBackupHandler::recoverBackup(QuaZip& zip) {
void AssetsBackupHandler::recoverBackup(const QString& backupName, QuaZip& zip) {
Q_ASSERT(QThread::currentThread() == thread());
if (operationInProgress()) {
@ -269,13 +269,11 @@ void AssetsBackupHandler::recoverBackup(QuaZip& zip) {
qCWarning(asset_backup) << "Current asset mappings that might be stale.";
}
const auto it = find_if(begin(_backups), end(_backups), [&](const AssetServerBackup& value) {
return value.filePath == zip.getZipName();
const auto it = find_if(begin(_backups), end(_backups), [&](const AssetServerBackup& backup) {
return backup.name == backupName;
});
if (it == end(_backups)) {
qCDebug(asset_backup) << "Could not find backup" << zip.getZipName() << "to restore.";
loadBackup(zip);
loadBackup(backupName, zip);
QuaZipDir zipDir { &zip, ZIP_ASSETS_FOLDER };
@ -306,7 +304,7 @@ void AssetsBackupHandler::recoverBackup(QuaZip& zip) {
restoreAllAssets();
}
void AssetsBackupHandler::deleteBackup(const QString& absoluteFilePath) {
void AssetsBackupHandler::deleteBackup(const QString& backupName) {
Q_ASSERT(QThread::currentThread() == thread());
if (operationInProgress()) {
@ -314,33 +312,32 @@ void AssetsBackupHandler::deleteBackup(const QString& absoluteFilePath) {
return;
}
const auto it = find_if(begin(_backups), end(_backups), [&](const AssetServerBackup& value) {
return value.filePath == absoluteFilePath;
const auto it = find_if(begin(_backups), end(_backups), [&](const AssetServerBackup& backup) {
return backup.name == backupName;
});
if (it == end(_backups)) {
qCDebug(asset_backup) << "Could not find backup" << absoluteFilePath << "to delete.";
qCDebug(asset_backup) << "Could not find backup" << backupName << "to delete.";
return;
}
refreshAssetsInBackups();
checkForAssetsToDelete();
qDebug() << "Deleted asset backup:" << backupName;
}
void AssetsBackupHandler::consolidateBackup(QuaZip& zip) {
void AssetsBackupHandler::consolidateBackup(const QString& backupName, QuaZip& zip) {
Q_ASSERT(QThread::currentThread() == thread());
if (operationInProgress()) {
qCWarning(asset_backup) << "There is a backup/restore in progress.";
return;
}
QFileInfo zipInfo(zip.getZipName());
const auto it = find_if(begin(_backups), end(_backups), [&](const AssetServerBackup& value) {
QFileInfo info(value.filePath);
return info.fileName() == zipInfo.fileName();
const auto it = find_if(begin(_backups), end(_backups), [&](const AssetServerBackup& backup) {
return backup.name == backupName;
});
if (it == end(_backups)) {
qCDebug(asset_backup) << "Could not find backup" << zip.getZipName() << "to consolidate.";
qCDebug(asset_backup) << "Could not find backup" << backupName << "to consolidate.";
return;
}
@ -465,7 +462,7 @@ bool AssetsBackupHandler::writeAssetFile(const AssetUtils::AssetHash& hash, cons
}
void AssetsBackupHandler::computeServerStateDifference(const AssetUtils::Mappings& currentMappings,
const AssetUtils::Mappings& newMappings) {
const AssetUtils::Mappings& newMappings) {
_mappingsLeftToSet.reserve((int)newMappings.size());
_assetsLeftToUpload.reserve((int)newMappings.size());
_mappingsLeftToDelete.reserve((int)currentMappings.size());

17
domain-server/src/AssetsBackupHandler.h
View file

@ -31,14 +31,14 @@ class AssetsBackupHandler : public QObject, public BackupHandlerInterface {
public:
AssetsBackupHandler(const QString& backupDirectory);
std::pair<bool, float> isAvailable(QString filePath) override;
std::pair<bool, float> isAvailable(const QString& backupName) override;
std::pair<bool, float> getRecoveryStatus() override;
void loadBackup(QuaZip& zip) override;
void createBackup(QuaZip& zip) override;
void recoverBackup(QuaZip& zip) override;
void deleteBackup(const QString& absoluteFilePath) override;
void consolidateBackup(QuaZip& zip) override;
void loadBackup(const QString& backupName, QuaZip& zip) override;
void createBackup(const QString& backupName, QuaZip& zip) override;
void recoverBackup(const QString& backupName, QuaZip& zip) override;
void deleteBackup(const QString& backupName) override;
void consolidateBackup(const QString& backupName, QuaZip& zip) override;
bool operationInProgress() { return getRecoveryStatus().first; }
@ -68,7 +68,10 @@ private:
AssetUtils::Mappings _currentMappings;
struct AssetServerBackup {
QString filePath;
AssetServerBackup(const QString& pName, AssetUtils::Mappings pMappings, bool pCorruptedBackup) :
name(pName), mappings(pMappings), corruptedBackup(pCorruptedBackup) {}
QString name;
AssetUtils::Mappings mappings;
bool corruptedBackup;
};

12
domain-server/src/BackupHandler.h
View file

@ -22,16 +22,16 @@ class BackupHandlerInterface {
public:
virtual ~BackupHandlerInterface() = default;
virtual std::pair<bool, float> isAvailable(QString filePath) = 0;
virtual std::pair<bool, float> isAvailable(const QString& backupName) = 0;
// Returns whether a recovery is ongoing and a progress between 0 and 1 if one is.
virtual std::pair<bool, float> getRecoveryStatus() = 0;
virtual void loadBackup(QuaZip& zip) = 0;
virtual void createBackup(QuaZip& zip) = 0;
virtual void recoverBackup(QuaZip& zip) = 0;
virtual void deleteBackup(const QString& absoluteFilePath) = 0;
virtual void consolidateBackup(QuaZip& zip) = 0;
virtual void loadBackup(const QString& backupName, QuaZip& zip) = 0;
virtual void createBackup(const QString& backupName, QuaZip& zip) = 0;
virtual void recoverBackup(const QString& backupName, QuaZip& zip) = 0;
virtual void deleteBackup(const QString& backupName) = 0;
virtual void consolidateBackup(const QString& backupName, QuaZip& zip) = 0;
};
using BackupHandlerPointer = std::unique_ptr<BackupHandlerInterface>;

5
domain-server/src/ContentSettingsBackupHandler.cpp
View file

@ -17,12 +17,11 @@
ContentSettingsBackupHandler::ContentSettingsBackupHandler(DomainServerSettingsManager& domainServerSettingsManager) :
_settingsManager(domainServerSettingsManager)
{
}
static const QString CONTENT_SETTINGS_BACKUP_FILENAME = "content-settings.json";
void ContentSettingsBackupHandler::createBackup(QuaZip& zip) {
void ContentSettingsBackupHandler::createBackup(const QString& backupName, QuaZip& zip) {
// grab the content settings as JSON,excluding default values and values hidden from backup
QJsonObject contentSettingsJSON = _settingsManager.settingsResponseObjectForType("", true, false, true, false, true);
@ -41,7 +40,7 @@ void ContentSettingsBackupHandler::createBackup(QuaZip& zip) {
}
}
void ContentSettingsBackupHandler::recoverBackup(QuaZip& zip) {
void ContentSettingsBackupHandler::recoverBackup(const QString& backupName, QuaZip& zip) {
if (!zip.setCurrentFile(CONTENT_SETTINGS_BACKUP_FILENAME)) {
qWarning() << "Failed to find" << CONTENT_SETTINGS_BACKUP_FILENAME << "while recovering backup";
return;

12
domain-server/src/ContentSettingsBackupHandler.h
View file

@ -19,18 +19,18 @@ class ContentSettingsBackupHandler : public BackupHandlerInterface {
public:
ContentSettingsBackupHandler(DomainServerSettingsManager& domainServerSettingsManager);
std::pair<bool, float> isAvailable(QString filePath) override { return { true, 1.0f }; }
std::pair<bool, float> isAvailable(const QString& backupName) override { return { true, 1.0f }; }
std::pair<bool, float> getRecoveryStatus() override { return { false, 1.0f }; }
void loadBackup(QuaZip& zip) override {}
void loadBackup(const QString& backupName, QuaZip& zip) override {}
void createBackup(QuaZip& zip) override;
void createBackup(const QString& backupName, QuaZip& zip) override;
void recoverBackup(QuaZip& zip) override;
void recoverBackup(const QString& backupName, QuaZip& zip) override;
void deleteBackup(const QString& absoluteFilePath) override {}
void deleteBackup(const QString& backupName) override {}
void consolidateBackup(QuaZip& zip) override {}
void consolidateBackup(const QString& backupName, QuaZip& zip) override {}
private:
DomainServerSettingsManager& _settingsManager;
};

33
domain-server/src/DomainContentBackupManager.cpp
View file

@ -135,8 +135,7 @@ bool DomainContentBackupManager::process() {
if (sinceLastSave > intervalToCheck) {
_lastCheck = now;
if (_isRecovering) {
using Value = std::vector<BackupHandlerPointer>::value_type;
bool isStillRecovering = std::any_of(begin(_backupHandlers), end(_backupHandlers), [](const Value& handler) {
bool isStillRecovering = any_of(begin(_backupHandlers), end(_backupHandlers), [](const BackupHandlerPointer& handler) {
return handler->getRecoveryStatus().first;
});
@ -223,14 +222,13 @@ void DomainContentBackupManager::deleteBackup(MiniPromise::Promise promise, cons
}
QDir backupDir { _backupDirectory };
auto absoluteFilePath { backupDir.filePath(backupName) };
QFile backupFile { absoluteFilePath };
QFile backupFile { backupDir.filePath(backupName) };
auto success = backupFile.remove();
refreshBackupRules();
for (auto& handler : _backupHandlers) {
handler->deleteBackup(absoluteFilePath);
handler->deleteBackup(backupName);
}
promise->resolve({
@ -238,18 +236,18 @@ void DomainContentBackupManager::deleteBackup(MiniPromise::Promise promise, cons
});
}
bool DomainContentBackupManager::recoverFromBackupZip(QuaZip& zip, const QString& backupName) {
bool DomainContentBackupManager::recoverFromBackupZip(const QString& backupName, QuaZip& zip) {
if (!zip.open(QuaZip::Mode::mdUnzip)) {
qWarning() << "Failed to unzip file: " << zip.getZipName();
qWarning() << "Failed to unzip file: " << backupName;
return false;
} else {
_isRecovering = true;
for (auto& handler : _backupHandlers) {
handler->recoverBackup(zip);
handler->recoverBackup(backupName, zip);
}
qDebug() << "Successfully started recovering from " << zip.getZipName();
qDebug() << "Successfully started recovering from " << backupName;
return true;
}
}
@ -276,7 +274,7 @@ void DomainContentBackupManager::recoverFromBackup(MiniPromise::Promise promise,
if (backupFile.open(QIODevice::ReadOnly)) {
QuaZip zip { &backupFile };
success = recoverFromBackupZip(zip, backupName);
success = recoverFromBackupZip(backupName, zip);
backupFile.close();
} else {
@ -303,7 +301,8 @@ void DomainContentBackupManager::recoverFromUploadedBackup(MiniPromise::Promise
QBuffer uploadedBackupBuffer { &uploadedBackup };
QuaZip uploadedZip { &uploadedBackupBuffer };
bool success = recoverFromBackupZip(uploadedZip, MANUAL_BACKUP_PREFIX + "uploaded.zip");
QString backupName = MANUAL_BACKUP_PREFIX + "uploaded.zip";
bool success = recoverFromBackupZip(backupName, uploadedZip);
promise->resolve({
{ "success", success }
@ -339,7 +338,7 @@ std::vector<BackupItemInfo> DomainContentBackupManager::getAllBackups() {
for (auto& handler : _backupHandlers) {
bool handlerIsAvailable { true };
float progress { 0.0f };
std::tie(handlerIsAvailable, progress) = handler->isAvailable(fileInfo.absoluteFilePath());
std::tie(handlerIsAvailable, progress) = handler->isAvailable(fileName);
isAvailable &= handlerIsAvailable;
availabilityProgress += progress / _backupHandlers.size();
}
@ -377,7 +376,7 @@ void DomainContentBackupManager::getAllBackupsAndStatus(MiniPromise::Promise pro
for (auto& handler : _backupHandlers) {
bool handlerIsAvailable { true };
float progress { 0.0f };
std::tie(handlerIsAvailable, progress) = handler->isAvailable(backup.absolutePath);
std::tie(handlerIsAvailable, progress) = handler->isAvailable(backup.name);
isAvailable &= handlerIsAvailable;
availabilityProgress += progress / _backupHandlers.size();
}
@ -463,7 +462,7 @@ void DomainContentBackupManager::load() {
}
for (auto& handler : _backupHandlers) {
handler->loadBackup(zip);
handler->loadBackup(backup.name, zip);
}
zip.close();
@ -507,7 +506,7 @@ void DomainContentBackupManager::backup() {
void DomainContentBackupManager::consolidateBackup(MiniPromise::Promise promise, QString fileName) {
if (QThread::currentThread() != thread()) {
QMetaObject::invokeMethod(this, "consolidateBackup", Q_ARG(MiniPromise::Promise, promise),
Q_ARG(const QString&, fileName));
Q_ARG(QString, fileName));
return;
}
@ -543,7 +542,7 @@ void DomainContentBackupManager::consolidateBackup(MiniPromise::Promise promise,
}
for (auto& handler : _backupHandlers) {
handler->consolidateBackup(zip);
handler->consolidateBackup(fileName, zip);
}
zip.close();
@ -588,7 +587,7 @@ std::pair<bool, QString> DomainContentBackupManager::createBackup(const QString&
}
for (auto& handler : _backupHandlers) {
handler->createBackup(zip);
handler->createBackup(fileName, zip);
}
zip.close();

2
domain-server/src/DomainContentBackupManager.h
View file

@ -86,7 +86,7 @@ protected:
std::pair<bool, QString> createBackup(const QString& prefix, const QString& name);
bool recoverFromBackupZip(QuaZip& backupZip, const QString& backupName);
bool recoverFromBackupZip(const QString& backupName, QuaZip& backupZip);
private:
const QString _backupDirectory;

4
domain-server/src/EntitiesBackupHandler.cpp
View file

@ -26,7 +26,7 @@ EntitiesBackupHandler::EntitiesBackupHandler(QString entitiesFilePath, QString e
static const QString ENTITIES_BACKUP_FILENAME = "models.json.gz";
void EntitiesBackupHandler::createBackup(QuaZip& zip) {
void EntitiesBackupHandler::createBackup(const QString& backupName, QuaZip& zip) {
QFile entitiesFile { _entitiesFilePath };
if (entitiesFile.open(QIODevice::ReadOnly)) {
@ -40,7 +40,7 @@ void EntitiesBackupHandler::createBackup(QuaZip& zip) {
}
}
void EntitiesBackupHandler::recoverBackup(QuaZip& zip) {
void EntitiesBackupHandler::recoverBackup(const QString& backupName, QuaZip& zip) {
if (!zip.setCurrentFile(ENTITIES_BACKUP_FILENAME)) {
qWarning() << "Failed to find" << ENTITIES_BACKUP_FILENAME << "while recovering backup";
return;

12
domain-server/src/EntitiesBackupHandler.h
View file

@ -18,22 +18,22 @@ class EntitiesBackupHandler : public BackupHandlerInterface {
public:
EntitiesBackupHandler(QString entitiesFilePath, QString entitiesReplacementFilePath);
std::pair<bool, float> isAvailable(QString filePath) override { return { true, 1.0f }; }
std::pair<bool, float> isAvailable(const QString& backupName) override { return { true, 1.0f }; }
std::pair<bool, float> getRecoveryStatus() override { return { false, 1.0f }; }
void loadBackup(QuaZip& zip) override {}
void loadBackup(const QString& backupName, QuaZip& zip) override {}
// Create a skeleton backup
void createBackup(QuaZip& zip) override;
void createBackup(const QString& backupName, QuaZip& zip) override;
// Recover from a full backup
void recoverBackup(QuaZip& zip) override;
void recoverBackup(const QString& backupName, QuaZip& zip) override;
// Delete a skeleton backup
void deleteBackup(const QString& absoluteFilePath) override {}
void deleteBackup(const QString& backupName) override {}
// Create a full backup
void consolidateBackup(QuaZip& zip) override {}
void consolidateBackup(const QString& backupName, QuaZip& zip) override {}
private:
QString _entitiesFilePath;