Differential D6712 Diff 23154 native/cpp/CommonCpp/DatabaseManagers/DatabaseManager.cpp

Changeset View

Standalone View

native/cpp/CommonCpp/DatabaseManagers/DatabaseManager.cpp

#include "DatabaseManager.h"		#include "DatabaseManager.h"
#include "../Tools/CommSecureStore.h"		#include "../Tools/CommSecureStore.h"
#include "Logger.h"		#include "Logger.h"
#include "SQLiteQueryExecutor.h"		#include "SQLiteQueryExecutor.h"

namespace comm {		namespace comm {

std::once_flag DatabaseManager::initialized;		std::once_flag DatabaseManager::initialized;

typedef const std::string DatabaseManagerStatus;		typedef const std::string DatabaseManagerStatus;
DatabaseManagerStatus DB_MANAGER_WORKABLE = "WORKABLE";		DatabaseManagerStatus DB_MANAGER_WORKABLE = "WORKABLE";
DatabaseManagerStatus DB_MANAGER_FIRST_FAILURE = "FIRST_FAILURE";		DatabaseManagerStatus DB_MANAGER_FIRST_FAILURE = "FIRST_FAILURE";
DatabaseManagerStatus DB_MANAGER_SECOND_FAILURE = "SECOND_FAILURE";		DatabaseManagerStatus DB_MANAGER_SECOND_FAILURE = "SECOND_FAILURE";
		DatabaseManagerStatus DB_OPERATIONS_FAILURE = "DB_OPERATIONS_FAILURE";

const std::string DATABASE_MANAGER_STATUS_KEY = "DATABASE_MANAGER_STATUS";		const std::string DATABASE_MANAGER_STATUS_KEY = "DATABASE_MANAGER_STATUS";

const DatabaseQueryExecutor &DatabaseManager::getQueryExecutor() {		const DatabaseQueryExecutor &DatabaseManager::getQueryExecutor() {
// TODO: conditionally create desired type of db manager		// TODO: conditionally create desired type of db manager
// maybe basing on some preprocessor flag		// maybe basing on some preprocessor flag
thread_local SQLiteQueryExecutor instance;		thread_local SQLiteQueryExecutor instance;

// creating an instance means that migration code was executed		// creating an instance means that migration code was executed
// and finished without error and database is workable		// and finished without error and database is workable
std::call_once(DatabaseManager::initialized, []() {		std::call_once(DatabaseManager::initialized, []() {
DatabaseManager::setDatabaseStatusAsWorkable();		DatabaseManager::indicateQueryExecutorCreation();
});		});
return instance;		return instance;
}		}

void DatabaseManager::clearSensitiveData() {		void DatabaseManager::clearSensitiveData() {
SQLiteQueryExecutor::clearSensitiveData();		SQLiteQueryExecutor::clearSensitiveData();
DatabaseManager::setDatabaseStatusAsWorkable();		DatabaseManager::setDatabaseStatusAsWorkable();
}		}

void DatabaseManager::initializeQueryExecutor(std::string &databasePath) {		void DatabaseManager::initializeQueryExecutor(std::string &databasePath) {
comm::CommSecureStore commSecureStore{};		comm::CommSecureStore commSecureStore{};
try {		try {
SQLiteQueryExecutor::initialize(databasePath);		SQLiteQueryExecutor::initialize(databasePath);
DatabaseManager::getQueryExecutor();		DatabaseManager::getQueryExecutor();
commSecureStore.set(DATABASE_MANAGER_STATUS_KEY, DB_MANAGER_WORKABLE);		DatabaseManager::indicateQueryExecutorCreation();
Logger::log("Database manager initialized");		Logger::log("Database manager initialized");
} catch (...) {		} catch (...) {
folly::Optional<std::string> databaseManagerStatus =		folly::Optional<std::string> databaseManagerStatus =
commSecureStore.get(DATABASE_MANAGER_STATUS_KEY);		commSecureStore.get(DATABASE_MANAGER_STATUS_KEY);
if (!databaseManagerStatus.hasValue() \|\|		if (!databaseManagerStatus.hasValue() \|\|
databaseManagerStatus.value() == DB_MANAGER_WORKABLE) {		databaseManagerStatus.value() == DB_MANAGER_WORKABLE) {
commSecureStore.set(		commSecureStore.set(
DATABASE_MANAGER_STATUS_KEY, DB_MANAGER_FIRST_FAILURE);		DATABASE_MANAGER_STATUS_KEY, DB_MANAGER_FIRST_FAILURE);
Show All 11 Lines	void DatabaseManager::initializeQueryExecutor(std::string &databasePath) {
}		}
}		}

void DatabaseManager::setDatabaseStatusAsWorkable() {		void DatabaseManager::setDatabaseStatusAsWorkable() {
comm::CommSecureStore commSecureStore{};		comm::CommSecureStore commSecureStore{};
commSecureStore.set(DATABASE_MANAGER_STATUS_KEY, DB_MANAGER_WORKABLE);		commSecureStore.set(DATABASE_MANAGER_STATUS_KEY, DB_MANAGER_WORKABLE);
}		}

		void DatabaseManager::indicateQueryExecutorCreation() {
		comm::CommSecureStore commSecureStore{};
		folly::Optional<std::string> databaseManagerStatus =
		commSecureStore.get(DATABASE_MANAGER_STATUS_KEY);
		if (!databaseManagerStatus.hasValue() \|\|
		databaseManagerStatus.value() != DB_OPERATIONS_FAILURE) {
		// creating query executor means that schema was created without error,
		// but this doesn't imply that schema has a proper structure,
		// and operation will not crash, this case should not be overridden
		commSecureStore.set(DATABASE_MANAGER_STATUS_KEY, DB_MANAGER_WORKABLE);
		}
		}

bool DatabaseManager::checkIfDatabaseNeedsDeletion() {		bool DatabaseManager::checkIfDatabaseNeedsDeletion() {
comm::CommSecureStore commSecureStore{};		comm::CommSecureStore commSecureStore{};
folly::Optional<std::string> databaseManagerStatus =		folly::Optional<std::string> databaseManagerStatus =
commSecureStore.get(DATABASE_MANAGER_STATUS_KEY);		commSecureStore.get(DATABASE_MANAGER_STATUS_KEY);
return databaseManagerStatus.hasValue() &&		return databaseManagerStatus.hasValue() &&
databaseManagerStatus.value() == DB_MANAGER_SECOND_FAILURE;		(databaseManagerStatus.value() == DB_MANAGER_SECOND_FAILURE \|\|
		databaseManagerStatus.value() == DB_OPERATIONS_FAILURE);
		}

		void DatabaseManager::reportDBOperationsFailure() {
		comm::CommSecureStore commSecureStore{};
		commSecureStore.set(DATABASE_MANAGER_STATUS_KEY, DB_OPERATIONS_FAILURE);
}		}

} // namespace comm		} // namespace comm