Page MenuHomePhabricator
Differential D4641

[keyserver] Use mysqldump from MariaDB 10.8 instead of MySQL 8
ClosedPublic
Actions

Authored by ashoat on Jul 26 2022, 4:38 AM.
Tags
None
Referenced Files
Unknown Object (File)
Sun, Mar 30, 9:32 AM
Unknown Object (File)
Fri, Mar 21, 7:12 PM
Unknown Object (File)
Wed, Mar 12, 11:48 AM
Unknown Object (File)
Thu, Mar 6, 7:05 AM
Unknown Object (File)
Thu, Mar 6, 7:05 AM
Unknown Object (File)
Thu, Mar 6, 7:05 AM
Unknown Object (File)
Thu, Mar 6, 7:05 AM
Unknown Object (File)
Wed, Mar 5, 7:47 AM
View All Files
Subscribers
• abosh
• adrian

Details

Reviewers
atul
tomek
Commits
rCOMMbe312b4bca10: [keyserver] Use mysqldump from MariaDB 10.8 instead of MySQL 8
Summary

In D4183 we decided to use mysqldump from MySQL 8 instead of MySQL 5.7 because it was too challenging to get the right one.

Now that we're using MariaDB 10.8, it's easier to get the right mysqldump for the given database server.

Test Plan

I tested a backup from this updated image and then tested a restore of that backup on the same image

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
keyserver/
17 lines

Diff 15035

View Options

keyserver/Dockerfile

#include "CreateNewBackupReactor.h" #include "CreateNewBackupReactor.h"
#include "DatabaseManager.h" #include "DatabaseManager.h"
#include "GlobalTools.h" #include "GlobalTools.h"
#include "Tools.h" #include "Tools.h"
#include "blob_client/src/lib.rs.h"
namespace comm { namespace comm {
namespace network { namespace network {
namespace reactor { namespace reactor {
std::string CreateNewBackupReactor::generateBackupID() { std::string CreateNewBackupReactor::generateBackupID() {
if (this->deviceID.empty()) { if (this->deviceID.empty()) {
throw std::runtime_error( throw std::runtime_error(
"trying to generate a backup ID with an empty device ID"); "trying to generate a backup ID with an empty device ID");
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines case State::DATA_HASH: {
if (database::DatabaseManager::getInstance().findBackupItem( if (database::DatabaseManager::getInstance().findBackupItem(
this->userID, this->backupID) != nullptr) { this->userID, this->backupID) != nullptr) {
throw std::runtime_error( throw std::runtime_error(
"Backup with id [" + this->backupID + "] for user [" + "Backup with id [" + this->backupID + "] for user [" +
this->userID + "] already exists, creation aborted"); this->userID + "] already exists, creation aborted");
} }
response->set_backupid(this->backupID); response->set_backupid(this->backupID);
this->holder = tools::generateHolder(this->dataHash, this->backupID); this->holder = tools::generateHolder(this->dataHash, this->backupID);
// todo:blob perform put:initialize try {
put_client_initialize_cxx();
put_client_write_cxx(
tools::getBlobPutField(blob::PutRequest::DataCase::kHolder),
this->holder.c_str());
put_client_blocking_read_cxx(); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably want to
// delegate performing ops to separate
// threads in the base reactors
put_client_write_cxx(
tools::getBlobPutField(blob::PutRequest::DataCase::kBlobHash),
this->dataHash.c_str());
rust::String responseStr =
put_client_blocking_read_cxx(); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably
// want to delegate performing ops
// to separate threads in the base
// reactors
// data exists?
if ((bool)tools::charPtrToInt(responseStr.c_str())) {
return std::make_unique<ServerBidiReactorStatus>(
grpc::Status::OK, true);
}
} catch (std::exception &e) {
throw std::runtime_error(
e.what()); // todo in base reactors we can just handle std exception
// instead of keep rethrowing here
}
return nullptr; return nullptr;
} }
case State::DATA_CHUNKS: { case State::DATA_CHUNKS: {
// todo:blob perform put:add chunk if (request.mutable_newcompactionchunk()->empty()) {
// (std::move(*request.mutable_newcompactionchunk()) return std::make_unique<ServerBidiReactorStatus>(grpc::Status::OK);
}
try {
put_client_write_cxx(
tools::getBlobPutField(blob::PutRequest::DataCase::kDataChunk),
std::string(std::move(*request.mutable_newcompactionchunk()))
.c_str());
put_client_blocking_read_cxx(); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably want to
// delegate performing ops to separate
// threads in the base reactors
} catch (std::exception &e) {
throw std::runtime_error(
e.what()); // todo in base reactors we can just handle std exception
// instead of keep rethrowing here
}
return nullptr; return nullptr;
} }
} }
throw std::runtime_error("new backup - invalid state"); throw std::runtime_error("new backup - invalid state");
} }
void CreateNewBackupReactor::terminateCallback() { void CreateNewBackupReactor::terminateCallback() {
const std::lock_guard<std::mutex> lock(this->reactorStateMutex); const std::lock_guard<std::mutex> lock(this->reactorStateMutex);
// todo:blob perform put:add chunk ("") try {
// todo:blob perform put:wait for completion put_client_terminate_cxx();
} catch (std::exception &e) {
throw std::runtime_error(
e.what()); // todo in base reactors we can just handle std exception
// instead of keep rethrowing here
}
// TODO add recovery data // TODO add recovery data
// TODO handle attachments holders // TODO handle attachments holders
database::BackupItem backupItem( database::BackupItem backupItem(
this->userID, this->userID,
this->backupID, this->backupID,
tools::getCurrentTimestamp(), tools::getCurrentTimestamp(),
tools::generateRandomString(), tools::generateRandomString(),
this->holder, this->holder,
{}); {});
database::DatabaseManager::getInstance().putBackupItem(backupItem); database::DatabaseManager::getInstance().putBackupItem(backupItem);
} }
} // namespace reactor } // namespace reactor
} // namespace network } // namespace network
} // namespace comm } // namespace comm