Page MenuHomePhabricator
Differential D8750

[Keyserver/rust] Implement upload_one_time_keys to identity service
ClosedPublic
Actions

Authored by kamil on Aug 7 2023, 8:03 AM.
Tags
None
Referenced Files
Unknown Object (File)
Thu, Apr 24, 5:17 PM
Unknown Object (File)
Fri, Apr 18, 2:23 PM
Unknown Object (File)
Fri, Apr 18, 1:33 PM
Unknown Object (File)
Fri, Apr 18, 9:54 AM
Unknown Object (File)
Fri, Apr 18, 2:00 AM
Unknown Object (File)
Fri, Apr 18, 12:03 AM
Unknown Object (File)
Thu, Apr 17, 9:15 PM
Unknown Object (File)
Thu, Apr 17, 12:25 AM
View All Files
Subscribers
ashoat
tomek

Details

Reviewers
bartek
varun
• jon
Commits
rCOMMd1359c5f69df: [Keyserver/rust] Implement upload_one_time_keys to identity service
Summary

Allow for the rust node addon to upload keys to identity
service.

https://linear.app/comm/issue/ENG-4601

Depends on D8749

Test Plan

Tested end-to-end in later diff

cd keyserver/addons/rust-node-addon
yarn build

Diff Detail

Repository
rCOMM Comm
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

• jon created this revision.Aug 7 2023, 8:03 AM
Herald added subscribers: tomek, ashoat. · View Herald TranscriptAug 7 2023, 8:03 AM
Harbormaster completed remote builds in B21565: Diff 29586.Aug 7 2023, 8:20 AM
• jon requested review of this revision.Aug 7 2023, 8:20 AM
• jon added a child revision: D8751: [Keyserver] Refactor getOneTimeKeyValues.Aug 7 2023, 8:21 AM
• jon removed a parent revision: D8749: [Identity/Tunnelbroker] Add integration tests.Aug 8 2023, 8:54 AM
• jon added a parent revision: D7691: [Keyserver] Open websocket connection with tunnelbroker.
bartek accepted this revision.Aug 8 2023, 10:04 AM
This revision is now accepted and ready to land.Aug 8 2023, 10:04 AM
• jon added inline comments.Aug 8 2023, 10:34 AM
keyserver/addons/rust-node-addon/src/identity_client/upload_one_time_keys.rs
19 ↗(On Diff #29586)
kamil commandeered this revision.Sep 8 2023, 7:28 AM
kamil added a reviewer: • jon.
kamil updated this revision to Diff 30866.Sep 8 2023, 7:28 AM
kamil added a parent revision: D8749: [Identity/Tunnelbroker] Add integration tests.
  • rebase
  • update comment
kamil removed a parent revision: D8749: [Identity/Tunnelbroker] Add integration tests.Sep 8 2023, 7:29 AM
Harbormaster completed remote builds in B22449: Diff 30866.Sep 8 2023, 7:46 AM
kamil updated this revision to Diff 30956.Sep 12 2023, 3:17 AM
kamil added a parent revision: D8749: [Identity/Tunnelbroker] Add integration tests.

rebase

Harbormaster failed remote builds in B22519: Diff 30956!Sep 12 2023, 3:32 AM
kamil updated this revision to Diff 31033.Sep 13 2023, 5:58 AM

rebase before landing

Harbormaster completed remote builds in B22580: Diff 31033.Sep 13 2023, 6:16 AM
Closed by commit rCOMMd1359c5f69df: [Keyserver/rust] Implement upload_one_time_keys to identity service (authored by • jon, committed by kamil). · Explain WhySep 13 2023, 6:43 AM
This revision was automatically updated to reflect the committed changes.
kamil added a commit: rCOMMd1359c5f69df: [Keyserver/rust] Implement upload_one_time_keys to identity service.

Revision Contents
Changeset List

PathSize
keyserver/
addons/
rust-node-addon/
7 lines
src/
identity_client/
3 lines
29 lines

Diff 31033

View Options

keyserver/addons/rust-node-addon/rust-binding-types.js

Show First 20 Lines • Show All 487 Lines • ▼ Show 20 Lines attempt_delete_file(
"Failed to delete unencrypted database."); "Failed to delete unencrypted database.");
attempt_rename_file( attempt_rename_file(
temp_encrypted_db_path, temp_encrypted_db_path,
SQLiteQueryExecutor::sqliteFilePath, SQLiteQueryExecutor::sqliteFilePath,
"Failed to move encrypted database to default location."); "Failed to move encrypted database to default location.");
Logger::log("Encryption completed successfully."); Logger::log("Encryption completed successfully.");
} }
auto &SQLiteQueryExecutor::getStorage() {
static auto storage = make_storage(
SQLiteQueryExecutor::sqliteFilePath,
make_index("messages_idx_thread_time", &Message::thread, &Message::time),
make_index("media_idx_container", &Media::container),
make_table(
"drafts",
make_column("key", &Draft::key, unique(), primary_key()),
make_column("text", &Draft::text)),
make_table(
"messages",
make_column("id", &Message::id, unique(), primary_key()),
make_column("local_id", &Message::local_id),
make_column("thread", &Message::thread),
make_column("user", &Message::user),
make_column("type", &Message::type),
make_column("future_type", &Message::future_type),
make_column("content", &Message::content),
make_column("time", &Message::time)),
make_table(
"olm_persist_account",
make_column("id", &OlmPersistAccount::id, unique(), primary_key()),
make_column("account_data", &OlmPersistAccount::account_data)),
make_table(
"olm_persist_sessions",
make_column(
"target_user_id",
&OlmPersistSession::target_user_id,
unique(),
primary_key()),
make_column("session_data", &OlmPersistSession::session_data)),
make_table(
"media",
make_column("id", &Media::id, unique(), primary_key()),
make_column("container", &Media::container),
make_column("thread", &Media::thread),
make_column("uri", &Media::uri),
make_column("type", &Media::type),
make_column("extras", &Media::extras)),
make_table(
"threads",
make_column("id", &Thread::id, unique(), primary_key()),
make_column("type", &Thread::type),
make_column("name", &Thread::name),
make_column("description", &Thread::description),
make_column("color", &Thread::color),
make_column("creation_time", &Thread::creation_time),
make_column("parent_thread_id", &Thread::parent_thread_id),
make_column("containing_thread_id", &Thread::containing_thread_id),
make_column("community", &Thread::community),
make_column("members", &Thread::members),
make_column("roles", &Thread::roles),
make_column("current_user", &Thread::current_user),
make_column("source_message_id", &Thread::source_message_id),
make_column("replies_count", &Thread::replies_count)),
make_table(
"metadata",
make_column("name", &Metadata::name, unique(), primary_key()),
make_column("data", &Metadata::data)));
storage.on_open = on_database_open;
return storage;
}
typedef bool ShouldBeInTransaction; typedef bool ShouldBeInTransaction;
typedef std::pair<std::function<bool(sqlite3 *)>, ShouldBeInTransaction> typedef std::pair<std::function<bool(sqlite3 *)>, ShouldBeInTransaction>
SQLiteMigration; SQLiteMigration;
std::vector<std::pair<uint, SQLiteMigration>> migrations{ std::vector<std::pair<uint, SQLiteMigration>> migrations{
{{1, {create_drafts_table, true}}, {{1, {create_drafts_table, true}},
{2, {rename_threadID_to_key, true}}, {2, {rename_threadID_to_key, true}},
{4, {create_persist_account_table, true}}, {4, {create_persist_account_table, true}},
{5, {create_persist_sessions_table, true}}, {5, {create_persist_sessions_table, true}},
Show All 28 Linesvoid SQLiteQueryExecutor::migrate() const {
int current_user_version = sqlite3_column_int(user_version_stmt, 0); int current_user_version = sqlite3_column_int(user_version_stmt, 0);
sqlite3_finalize(user_version_stmt); sqlite3_finalize(user_version_stmt);
std::stringstream version_msg; std::stringstream version_msg;
version_msg << "db version: " << current_user_version << std::endl; version_msg << "db version: " << current_user_version << std::endl;
Logger::log(version_msg.str()); Logger::log(version_msg.str());
if (current_user_version == 0) {
SQLiteQueryExecutor::getStorage().sync_schema();
Logger::log("Creating new database, syncing structure with ORM storage.");
auto latest_version = migrations.back().first;
std::stringstream update_version;
update_version << "PRAGMA user_version=" << latest_version << ";";
auto update_version_str = update_version.str();
char *error;
sqlite3_exec(db, update_version_str.c_str(), nullptr, nullptr, &error);
if (error) {
std::ostringstream errorStream;
errorStream << "Error saving database version: " << error;
Logger::log(errorStream.str());
marcinUnsubmitted
Not Done
Inline Actions

How is application going to function if this error occurs? In most places we the runtime error to kill the app if database operation fails since application is not going to work correctly. I just want to know whether it is also the case here.

marcin: How is application going to function if this error occurs? In most places we the runtime error…
sqlite3_free(error);
}
return;
}
for (const auto &[idx, migration] : migrations) { for (const auto &[idx, migration] : migrations) {
if (idx <= current_user_version) { if (idx <= current_user_version) {
continue; continue;
} }
const auto &[applyMigration, shouldBeInTransaction] = migration; const auto &[applyMigration, shouldBeInTransaction] = migration;
std::stringstream migration_msg; std::stringstream migration_msg;
Show All 28 Linesvoid SQLiteQueryExecutor::assign_encryption_key() {
CommSecureStore commSecureStore{}; CommSecureStore commSecureStore{};
std::string encryptionKey = comm::crypto::Tools::generateRandomHexString( std::string encryptionKey = comm::crypto::Tools::generateRandomHexString(
SQLiteQueryExecutor::sqlcipherEncryptionKeySize); SQLiteQueryExecutor::sqlcipherEncryptionKeySize);
commSecureStore.set( commSecureStore.set(
SQLiteQueryExecutor::secureStoreEncryptionKeyID, encryptionKey); SQLiteQueryExecutor::secureStoreEncryptionKeyID, encryptionKey);
SQLiteQueryExecutor::encryptionKey = encryptionKey; SQLiteQueryExecutor::encryptionKey = encryptionKey;
} }
auto &SQLiteQueryExecutor::getStorage() {
static auto storage = make_storage(
SQLiteQueryExecutor::sqliteFilePath,
make_index("messages_idx_thread_time", &Message::thread, &Message::time),
make_index("media_idx_container", &Media::container),
make_table(
"drafts",
make_column("key", &Draft::key, unique(), primary_key()),
make_column("text", &Draft::text)),
make_table(
"messages",
make_column("id", &Message::id, unique(), primary_key()),
make_column("local_id", &Message::local_id),
make_column("thread", &Message::thread),
make_column("user", &Message::user),
make_column("type", &Message::type),
make_column("future_type", &Message::future_type),
make_column("content", &Message::content),
make_column("time", &Message::time)),
make_table(
"olm_persist_account",
make_column("id", &OlmPersistAccount::id, unique(), primary_key()),
make_column("account_data", &OlmPersistAccount::account_data)),
make_table(
"olm_persist_sessions",
make_column(
"target_user_id",
&OlmPersistSession::target_user_id,
unique(),
primary_key()),
make_column("session_data", &OlmPersistSession::session_data)),
make_table(
"media",
make_column("id", &Media::id, unique(), primary_key()),
make_column("container", &Media::container),
make_column("thread", &Media::thread),
make_column("uri", &Media::uri),
make_column("type", &Media::type),
make_column("extras", &Media::extras)),
make_table(
"threads",
make_column("id", &Thread::id, unique(), primary_key()),
make_column("type", &Thread::type),
make_column("name", &Thread::name),
make_column("description", &Thread::description),
make_column("color", &Thread::color),
make_column("creation_time", &Thread::creation_time),
make_column("parent_thread_id", &Thread::parent_thread_id),
make_column("containing_thread_id", &Thread::containing_thread_id),
make_column("community", &Thread::community),
make_column("members", &Thread::members),
make_column("roles", &Thread::roles),
make_column("current_user", &Thread::current_user),
make_column("source_message_id", &Thread::source_message_id),
make_column("replies_count", &Thread::replies_count)),
make_table(
"metadata",
make_column("name", &Metadata::name, unique(), primary_key()),
make_column("data", &Metadata::data)));
storage.on_open = on_database_open;
return storage;
}
void SQLiteQueryExecutor::initialize(std::string &databasePath) { void SQLiteQueryExecutor::initialize(std::string &databasePath) {
std::call_once(SQLiteQueryExecutor::initialized, [&databasePath]() { std::call_once(SQLiteQueryExecutor::initialized, [&databasePath]() {
SQLiteQueryExecutor::sqliteFilePath = databasePath; SQLiteQueryExecutor::sqliteFilePath = databasePath;
CommSecureStore commSecureStore{}; CommSecureStore commSecureStore{};
folly::Optional<std::string> maybeEncryptionKey = folly::Optional<std::string> maybeEncryptionKey =
commSecureStore.get(SQLiteQueryExecutor::secureStoreEncryptionKeyID); commSecureStore.get(SQLiteQueryExecutor::secureStoreEncryptionKeyID);
if (file_exists(databasePath) && maybeEncryptionKey) { if (file_exists(databasePath) && maybeEncryptionKey) {
▲ Show 20 Lines • Show All 277 Lines • Show Last 20 Lines
View Options

keyserver/addons/rust-node-addon/src/identity_client/mod.rs

Show First 20 Lines • Show All 487 Lines • ▼ Show 20 Lines attempt_delete_file(
"Failed to delete unencrypted database."); "Failed to delete unencrypted database.");
attempt_rename_file( attempt_rename_file(
temp_encrypted_db_path, temp_encrypted_db_path,
SQLiteQueryExecutor::sqliteFilePath, SQLiteQueryExecutor::sqliteFilePath,
"Failed to move encrypted database to default location."); "Failed to move encrypted database to default location.");
Logger::log("Encryption completed successfully."); Logger::log("Encryption completed successfully.");
} }
auto &SQLiteQueryExecutor::getStorage() {
static auto storage = make_storage(
SQLiteQueryExecutor::sqliteFilePath,
make_index("messages_idx_thread_time", &Message::thread, &Message::time),
make_index("media_idx_container", &Media::container),
make_table(
"drafts",
make_column("key", &Draft::key, unique(), primary_key()),
make_column("text", &Draft::text)),
make_table(
"messages",
make_column("id", &Message::id, unique(), primary_key()),
make_column("local_id", &Message::local_id),
make_column("thread", &Message::thread),
make_column("user", &Message::user),
make_column("type", &Message::type),
make_column("future_type", &Message::future_type),
make_column("content", &Message::content),
make_column("time", &Message::time)),
make_table(
"olm_persist_account",
make_column("id", &OlmPersistAccount::id, unique(), primary_key()),
make_column("account_data", &OlmPersistAccount::account_data)),
make_table(
"olm_persist_sessions",
make_column(
"target_user_id",
&OlmPersistSession::target_user_id,
unique(),
primary_key()),
make_column("session_data", &OlmPersistSession::session_data)),
make_table(
"media",
make_column("id", &Media::id, unique(), primary_key()),
make_column("container", &Media::container),
make_column("thread", &Media::thread),
make_column("uri", &Media::uri),
make_column("type", &Media::type),
make_column("extras", &Media::extras)),
make_table(
"threads",
make_column("id", &Thread::id, unique(), primary_key()),
make_column("type", &Thread::type),
make_column("name", &Thread::name),
make_column("description", &Thread::description),
make_column("color", &Thread::color),
make_column("creation_time", &Thread::creation_time),
make_column("parent_thread_id", &Thread::parent_thread_id),
make_column("containing_thread_id", &Thread::containing_thread_id),
make_column("community", &Thread::community),
make_column("members", &Thread::members),
make_column("roles", &Thread::roles),
make_column("current_user", &Thread::current_user),
make_column("source_message_id", &Thread::source_message_id),
make_column("replies_count", &Thread::replies_count)),
make_table(
"metadata",
make_column("name", &Metadata::name, unique(), primary_key()),
make_column("data", &Metadata::data)));
storage.on_open = on_database_open;
return storage;
}
typedef bool ShouldBeInTransaction; typedef bool ShouldBeInTransaction;
typedef std::pair<std::function<bool(sqlite3 *)>, ShouldBeInTransaction> typedef std::pair<std::function<bool(sqlite3 *)>, ShouldBeInTransaction>
SQLiteMigration; SQLiteMigration;
std::vector<std::pair<uint, SQLiteMigration>> migrations{ std::vector<std::pair<uint, SQLiteMigration>> migrations{
{{1, {create_drafts_table, true}}, {{1, {create_drafts_table, true}},
{2, {rename_threadID_to_key, true}}, {2, {rename_threadID_to_key, true}},
{4, {create_persist_account_table, true}}, {4, {create_persist_account_table, true}},
{5, {create_persist_sessions_table, true}}, {5, {create_persist_sessions_table, true}},
Show All 28 Linesvoid SQLiteQueryExecutor::migrate() const {
int current_user_version = sqlite3_column_int(user_version_stmt, 0); int current_user_version = sqlite3_column_int(user_version_stmt, 0);
sqlite3_finalize(user_version_stmt); sqlite3_finalize(user_version_stmt);
std::stringstream version_msg; std::stringstream version_msg;
version_msg << "db version: " << current_user_version << std::endl; version_msg << "db version: " << current_user_version << std::endl;
Logger::log(version_msg.str()); Logger::log(version_msg.str());
if (current_user_version == 0) {
SQLiteQueryExecutor::getStorage().sync_schema();
Logger::log("Creating new database, syncing structure with ORM storage.");
auto latest_version = migrations.back().first;
std::stringstream update_version;
update_version << "PRAGMA user_version=" << latest_version << ";";
auto update_version_str = update_version.str();
char *error;
sqlite3_exec(db, update_version_str.c_str(), nullptr, nullptr, &error);
if (error) {
std::ostringstream errorStream;
errorStream << "Error saving database version: " << error;
Logger::log(errorStream.str());
marcinUnsubmitted
Not Done
Inline Actions

How is application going to function if this error occurs? In most places we the runtime error to kill the app if database operation fails since application is not going to work correctly. I just want to know whether it is also the case here.

marcin: How is application going to function if this error occurs? In most places we the runtime error…
sqlite3_free(error);
}
return;
}
for (const auto &[idx, migration] : migrations) { for (const auto &[idx, migration] : migrations) {
if (idx <= current_user_version) { if (idx <= current_user_version) {
continue; continue;
} }
const auto &[applyMigration, shouldBeInTransaction] = migration; const auto &[applyMigration, shouldBeInTransaction] = migration;
std::stringstream migration_msg; std::stringstream migration_msg;
Show All 28 Linesvoid SQLiteQueryExecutor::assign_encryption_key() {
CommSecureStore commSecureStore{}; CommSecureStore commSecureStore{};
std::string encryptionKey = comm::crypto::Tools::generateRandomHexString( std::string encryptionKey = comm::crypto::Tools::generateRandomHexString(
SQLiteQueryExecutor::sqlcipherEncryptionKeySize); SQLiteQueryExecutor::sqlcipherEncryptionKeySize);
commSecureStore.set( commSecureStore.set(
SQLiteQueryExecutor::secureStoreEncryptionKeyID, encryptionKey); SQLiteQueryExecutor::secureStoreEncryptionKeyID, encryptionKey);
SQLiteQueryExecutor::encryptionKey = encryptionKey; SQLiteQueryExecutor::encryptionKey = encryptionKey;
} }
auto &SQLiteQueryExecutor::getStorage() {
static auto storage = make_storage(
SQLiteQueryExecutor::sqliteFilePath,
make_index("messages_idx_thread_time", &Message::thread, &Message::time),
make_index("media_idx_container", &Media::container),
make_table(
"drafts",
make_column("key", &Draft::key, unique(), primary_key()),
make_column("text", &Draft::text)),
make_table(
"messages",
make_column("id", &Message::id, unique(), primary_key()),
make_column("local_id", &Message::local_id),
make_column("thread", &Message::thread),
make_column("user", &Message::user),
make_column("type", &Message::type),
make_column("future_type", &Message::future_type),
make_column("content", &Message::content),
make_column("time", &Message::time)),
make_table(
"olm_persist_account",
make_column("id", &OlmPersistAccount::id, unique(), primary_key()),
make_column("account_data", &OlmPersistAccount::account_data)),
make_table(
"olm_persist_sessions",
make_column(
"target_user_id",
&OlmPersistSession::target_user_id,
unique(),
primary_key()),
make_column("session_data", &OlmPersistSession::session_data)),
make_table(
"media",
make_column("id", &Media::id, unique(), primary_key()),
make_column("container", &Media::container),
make_column("thread", &Media::thread),
make_column("uri", &Media::uri),
make_column("type", &Media::type),
make_column("extras", &Media::extras)),
make_table(
"threads",
make_column("id", &Thread::id, unique(), primary_key()),
make_column("type", &Thread::type),
make_column("name", &Thread::name),
make_column("description", &Thread::description),
make_column("color", &Thread::color),
make_column("creation_time", &Thread::creation_time),
make_column("parent_thread_id", &Thread::parent_thread_id),
make_column("containing_thread_id", &Thread::containing_thread_id),
make_column("community", &Thread::community),
make_column("members", &Thread::members),
make_column("roles", &Thread::roles),
make_column("current_user", &Thread::current_user),
make_column("source_message_id", &Thread::source_message_id),
make_column("replies_count", &Thread::replies_count)),
make_table(
"metadata",
make_column("name", &Metadata::name, unique(), primary_key()),
make_column("data", &Metadata::data)));
storage.on_open = on_database_open;
return storage;
}
void SQLiteQueryExecutor::initialize(std::string &databasePath) { void SQLiteQueryExecutor::initialize(std::string &databasePath) {
std::call_once(SQLiteQueryExecutor::initialized, [&databasePath]() { std::call_once(SQLiteQueryExecutor::initialized, [&databasePath]() {
SQLiteQueryExecutor::sqliteFilePath = databasePath; SQLiteQueryExecutor::sqliteFilePath = databasePath;
CommSecureStore commSecureStore{}; CommSecureStore commSecureStore{};
folly::Optional<std::string> maybeEncryptionKey = folly::Optional<std::string> maybeEncryptionKey =
commSecureStore.get(SQLiteQueryExecutor::secureStoreEncryptionKeyID); commSecureStore.get(SQLiteQueryExecutor::secureStoreEncryptionKeyID);
if (file_exists(databasePath) && maybeEncryptionKey) { if (file_exists(databasePath) && maybeEncryptionKey) {
▲ Show 20 Lines • Show All 277 Lines • Show Last 20 Lines
View Options

keyserver/addons/rust-node-addon/src/identity_client/upload_one_time_keys.rs

Show First 20 Lines • Show All 487 Lines • ▼ Show 20 Lines attempt_delete_file(
"Failed to delete unencrypted database."); "Failed to delete unencrypted database.");
attempt_rename_file( attempt_rename_file(
temp_encrypted_db_path, temp_encrypted_db_path,
SQLiteQueryExecutor::sqliteFilePath, SQLiteQueryExecutor::sqliteFilePath,
"Failed to move encrypted database to default location."); "Failed to move encrypted database to default location.");
Logger::log("Encryption completed successfully."); Logger::log("Encryption completed successfully.");
} }
auto &SQLiteQueryExecutor::getStorage() {
static auto storage = make_storage(
SQLiteQueryExecutor::sqliteFilePath,
make_index("messages_idx_thread_time", &Message::thread, &Message::time),
make_index("media_idx_container", &Media::container),
make_table(
"drafts",
make_column("key", &Draft::key, unique(), primary_key()),
make_column("text", &Draft::text)),
make_table(
"messages",
make_column("id", &Message::id, unique(), primary_key()),
make_column("local_id", &Message::local_id),
make_column("thread", &Message::thread),
make_column("user", &Message::user),
make_column("type", &Message::type),
make_column("future_type", &Message::future_type),
make_column("content", &Message::content),
make_column("time", &Message::time)),
make_table(
"olm_persist_account",
make_column("id", &OlmPersistAccount::id, unique(), primary_key()),
make_column("account_data", &OlmPersistAccount::account_data)),
make_table(
"olm_persist_sessions",
make_column(
"target_user_id",
&OlmPersistSession::target_user_id,
unique(),
primary_key()),
make_column("session_data", &OlmPersistSession::session_data)),
make_table(
"media",
make_column("id", &Media::id, unique(), primary_key()),
make_column("container", &Media::container),
make_column("thread", &Media::thread),
make_column("uri", &Media::uri),
make_column("type", &Media::type),
make_column("extras", &Media::extras)),
make_table(
"threads",
make_column("id", &Thread::id, unique(), primary_key()),
make_column("type", &Thread::type),
make_column("name", &Thread::name),
make_column("description", &Thread::description),
make_column("color", &Thread::color),
make_column("creation_time", &Thread::creation_time),
make_column("parent_thread_id", &Thread::parent_thread_id),
make_column("containing_thread_id", &Thread::containing_thread_id),
make_column("community", &Thread::community),
make_column("members", &Thread::members),
make_column("roles", &Thread::roles),
make_column("current_user", &Thread::current_user),
make_column("source_message_id", &Thread::source_message_id),
make_column("replies_count", &Thread::replies_count)),
make_table(
"metadata",
make_column("name", &Metadata::name, unique(), primary_key()),
make_column("data", &Metadata::data)));
storage.on_open = on_database_open;
return storage;
}
typedef bool ShouldBeInTransaction; typedef bool ShouldBeInTransaction;
typedef std::pair<std::function<bool(sqlite3 *)>, ShouldBeInTransaction> typedef std::pair<std::function<bool(sqlite3 *)>, ShouldBeInTransaction>
SQLiteMigration; SQLiteMigration;
std::vector<std::pair<uint, SQLiteMigration>> migrations{ std::vector<std::pair<uint, SQLiteMigration>> migrations{
{{1, {create_drafts_table, true}}, {{1, {create_drafts_table, true}},
{2, {rename_threadID_to_key, true}}, {2, {rename_threadID_to_key, true}},
{4, {create_persist_account_table, true}}, {4, {create_persist_account_table, true}},
{5, {create_persist_sessions_table, true}}, {5, {create_persist_sessions_table, true}},
Show All 28 Linesvoid SQLiteQueryExecutor::migrate() const {
int current_user_version = sqlite3_column_int(user_version_stmt, 0); int current_user_version = sqlite3_column_int(user_version_stmt, 0);
sqlite3_finalize(user_version_stmt); sqlite3_finalize(user_version_stmt);
std::stringstream version_msg; std::stringstream version_msg;
version_msg << "db version: " << current_user_version << std::endl; version_msg << "db version: " << current_user_version << std::endl;
Logger::log(version_msg.str()); Logger::log(version_msg.str());
if (current_user_version == 0) {
SQLiteQueryExecutor::getStorage().sync_schema();
Logger::log("Creating new database, syncing structure with ORM storage.");
auto latest_version = migrations.back().first;
std::stringstream update_version;
update_version << "PRAGMA user_version=" << latest_version << ";";
auto update_version_str = update_version.str();
char *error;
sqlite3_exec(db, update_version_str.c_str(), nullptr, nullptr, &error);
if (error) {
std::ostringstream errorStream;
errorStream << "Error saving database version: " << error;
Logger::log(errorStream.str());
marcinUnsubmitted
Not Done
Inline Actions

How is application going to function if this error occurs? In most places we the runtime error to kill the app if database operation fails since application is not going to work correctly. I just want to know whether it is also the case here.

marcin: How is application going to function if this error occurs? In most places we the runtime error…
sqlite3_free(error);
}
return;
}
for (const auto &[idx, migration] : migrations) { for (const auto &[idx, migration] : migrations) {
if (idx <= current_user_version) { if (idx <= current_user_version) {
continue; continue;
} }
const auto &[applyMigration, shouldBeInTransaction] = migration; const auto &[applyMigration, shouldBeInTransaction] = migration;
std::stringstream migration_msg; std::stringstream migration_msg;
Show All 28 Linesvoid SQLiteQueryExecutor::assign_encryption_key() {
CommSecureStore commSecureStore{}; CommSecureStore commSecureStore{};
std::string encryptionKey = comm::crypto::Tools::generateRandomHexString( std::string encryptionKey = comm::crypto::Tools::generateRandomHexString(
SQLiteQueryExecutor::sqlcipherEncryptionKeySize); SQLiteQueryExecutor::sqlcipherEncryptionKeySize);
commSecureStore.set( commSecureStore.set(
SQLiteQueryExecutor::secureStoreEncryptionKeyID, encryptionKey); SQLiteQueryExecutor::secureStoreEncryptionKeyID, encryptionKey);
SQLiteQueryExecutor::encryptionKey = encryptionKey; SQLiteQueryExecutor::encryptionKey = encryptionKey;
} }
auto &SQLiteQueryExecutor::getStorage() {
static auto storage = make_storage(
SQLiteQueryExecutor::sqliteFilePath,
make_index("messages_idx_thread_time", &Message::thread, &Message::time),
make_index("media_idx_container", &Media::container),
make_table(
"drafts",
make_column("key", &Draft::key, unique(), primary_key()),
make_column("text", &Draft::text)),
make_table(
"messages",
make_column("id", &Message::id, unique(), primary_key()),
make_column("local_id", &Message::local_id),
make_column("thread", &Message::thread),
make_column("user", &Message::user),
make_column("type", &Message::type),
make_column("future_type", &Message::future_type),
make_column("content", &Message::content),
make_column("time", &Message::time)),
make_table(
"olm_persist_account",
make_column("id", &OlmPersistAccount::id, unique(), primary_key()),
make_column("account_data", &OlmPersistAccount::account_data)),
make_table(
"olm_persist_sessions",
make_column(
"target_user_id",
&OlmPersistSession::target_user_id,
unique(),
primary_key()),
make_column("session_data", &OlmPersistSession::session_data)),
make_table(
"media",
make_column("id", &Media::id, unique(), primary_key()),
make_column("container", &Media::container),
make_column("thread", &Media::thread),
make_column("uri", &Media::uri),
make_column("type", &Media::type),
make_column("extras", &Media::extras)),
make_table(
"threads",
make_column("id", &Thread::id, unique(), primary_key()),
make_column("type", &Thread::type),
make_column("name", &Thread::name),
make_column("description", &Thread::description),
make_column("color", &Thread::color),
make_column("creation_time", &Thread::creation_time),
make_column("parent_thread_id", &Thread::parent_thread_id),
make_column("containing_thread_id", &Thread::containing_thread_id),
make_column("community", &Thread::community),
make_column("members", &Thread::members),
make_column("roles", &Thread::roles),
make_column("current_user", &Thread::current_user),
make_column("source_message_id", &Thread::source_message_id),
make_column("replies_count", &Thread::replies_count)),
make_table(
"metadata",
make_column("name", &Metadata::name, unique(), primary_key()),
make_column("data", &Metadata::data)));
storage.on_open = on_database_open;
return storage;
}
void SQLiteQueryExecutor::initialize(std::string &databasePath) { void SQLiteQueryExecutor::initialize(std::string &databasePath) {
std::call_once(SQLiteQueryExecutor::initialized, [&databasePath]() { std::call_once(SQLiteQueryExecutor::initialized, [&databasePath]() {
SQLiteQueryExecutor::sqliteFilePath = databasePath; SQLiteQueryExecutor::sqliteFilePath = databasePath;
CommSecureStore commSecureStore{}; CommSecureStore commSecureStore{};
folly::Optional<std::string> maybeEncryptionKey = folly::Optional<std::string> maybeEncryptionKey =
commSecureStore.get(SQLiteQueryExecutor::secureStoreEncryptionKeyID); commSecureStore.get(SQLiteQueryExecutor::secureStoreEncryptionKeyID);
if (file_exists(databasePath) && maybeEncryptionKey) { if (file_exists(databasePath) && maybeEncryptionKey) {
▲ Show 20 Lines • Show All 277 Lines • Show Last 20 Lines