[misc] Add `root=true` to `.editorconfig`
ClosedPublic
Actions

#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

[misc] Add `root=true` to `.editorconfig`ClosedPublicActions

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 10426

.editorconfig

[misc] Add `root=true` to `.editorconfig`
ClosedPublic
Actions

Revision Contents
Changeset List