BlockStorage/repertory
1
0
Fork 0
Code Issues 7 Pull Requests Releases 6 Wiki Activity

fix

Browse Source
This commit is contained in:
Scott E. Graves 2024-10-09 09:51:09 -05:00
parent 9adec02640
commit 8541e292cd
3 changed files with 77 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
repertory/librepertory/include/providers/encrypt/encrypt_provider.hpp
View File

@ -53,7 +53,7 @@ private:
private:
app_config &config_;
db::db3_t db_;
utils::db::sqlite::db3_t db_;
private:
i_file_manager *fm_ = nullptr;

116
repertory/librepertory/src/providers/encrypt/encrypt_provider.cpp
View File

@ -194,12 +194,12 @@ auto encrypt_provider::get_api_path_from_source(
};
try {
auto result = db::db_select{*db_, file_table}
auto result = utils::db::sqlite::db_select{*db_, file_table}
.column("data")
.where("source_path")
.equals(source_path)
.go();
std::optional<db::db_select::row> row;
std::optional<utils::db::sqlite::db_select::row> row;
if (result.get_row(row) && row.has_value()) {
api_path = row->get_column("data")
.get_value_as_json()
@ -208,7 +208,7 @@ auto encrypt_provider::get_api_path_from_source(
return api_error::success;
}
result = db::db_select{*db_, directory_table}
result = utils::db::sqlite::db_select{*db_, directory_table}
.column("api_path")
.where("source_path")
.equals(source_path)
@ -273,12 +273,13 @@ auto encrypt_provider::get_directory_items(
try {
std::string current_api_path{};
if (dir_entry->is_directory_item()) {
auto result = db::db_select{*db_, directory_table}
.column("api_path")
.where("source_path")
.equals(dir_entry->get_path())
.go();
std::optional<db::db_select::row> row;
auto result =
utils::db::sqlite::db_select{*db_, directory_table}
.column("api_path")
.where("source_path")
.equals(dir_entry->get_path())
.go();
std::optional<utils::db::sqlite::db_select::row> row;
if (result.get_row(row) && row.has_value()) {
current_api_path =
row->get_column("api_path").get_value<std::string>();
@ -287,7 +288,7 @@ auto encrypt_provider::get_directory_items(
process_directory_entry(*dir_entry.get(), cfg,
current_api_path);
result = db::db_select{*db_, directory_table}
result = utils::db::sqlite::db_select{*db_, directory_table}
.column("api_path")
.where("source_path")
.equals(dir_entry->get_path())
@ -302,12 +303,12 @@ auto encrypt_provider::get_directory_items(
}
} else {
std::string api_path_data{};
auto result = db::db_select{*db_, file_table}
auto result = utils::db::sqlite::db_select{*db_, file_table}
.column("data")
.where("source_path")
.equals(dir_entry->get_path())
.go();
std::optional<db::db_select::row> row;
std::optional<utils::db::sqlite::db_select::row> row;
if (result.get_row(row) && row.has_value()) {
api_path_data =
row->get_column("data").get_value<std::string>();
@ -387,12 +388,12 @@ auto encrypt_provider::get_file(const std::string &api_path,
return api_error::directory_exists;
}
auto result = db::db_select{*db_, source_table}
auto result = utils::db::sqlite::db_select{*db_, source_table}
.column("source_path")
.where("api_path")
.equals(api_path)
.go();
std::optional<db::db_select::row> row;
std::optional<utils::db::sqlite::db_select::row> row;
if (not(result.get_row(row) && row.has_value())) {
return api_error::item_not_found;
}
@ -443,12 +444,12 @@ auto encrypt_provider::get_file_size(
};
try {
auto result = db::db_select{*db_, source_table}
auto result = utils::db::sqlite::db_select{*db_, source_table}
.column("source_path")
.where("api_path")
.equals(api_path)
.go();
std::optional<db::db_select::row> row;
std::optional<utils::db::sqlite::db_select::row> row;
if (not(result.get_row(row) && row.has_value())) {
return api_error::item_not_found;
}
@ -468,12 +469,12 @@ auto encrypt_provider::get_file_size(
auto encrypt_provider::get_filesystem_item(
const std::string &api_path, bool directory,
filesystem_item &fsi) const -> api_error {
auto result = db::db_select{*db_, source_table}
auto result = utils::db::sqlite::db_select{*db_, source_table}
.column("source_path")
.where("api_path")
.equals(api_path)
.go();
std::optional<db::db_select::row> row;
std::optional<utils::db::sqlite::db_select::row> row;
if (not(result.get_row(row) && row.has_value())) {
return api_error::item_not_found;
}
@ -481,7 +482,7 @@ auto encrypt_provider::get_filesystem_item(
auto source_path = row->get_column("source_path").get_value<std::string>();
if (directory) {
result = db::db_select{*db_, directory_table}
result = utils::db::sqlite::db_select{*db_, directory_table}
.column("api_path")
.where("source_path")
.equals(source_path)
@ -500,7 +501,7 @@ auto encrypt_provider::get_filesystem_item(
return api_error::success;
}
result = db::db_select{*db_, file_table}
result = utils::db::sqlite::db_select{*db_, file_table}
.column("data")
.where("source_path")
.equals(source_path)
@ -586,12 +587,12 @@ auto encrypt_provider::get_item_meta(const std::string &api_path,
};
try {
auto result = db::db_select{*db_, source_table}
auto result = utils::db::sqlite::db_select{*db_, source_table}
.column("source_path")
.where("api_path")
.equals(api_path)
.go();
std::optional<db::db_select::row> row;
std::optional<utils::db::sqlite::db_select::row> row;
if (not(result.get_row(row) && row.has_value())) {
return api_error::item_not_found;
}
@ -635,10 +636,11 @@ auto encrypt_provider::get_total_drive_space() const -> std::uint64_t {
}
auto encrypt_provider::get_total_item_count() const -> std::uint64_t {
auto result =
db::db_select{*db_, source_table}.count("api_path", "count").go();
auto result = utils::db::sqlite::db_select{*db_, source_table}
.count("api_path", "count")
.go();
std::optional<db::db_select::row> row;
std::optional<utils::db::sqlite::db_select::row> row;
if (result.get_row(row) && row.has_value()) {
return static_cast<std::uint64_t>(
row->get_column("count").get_value<std::int64_t>());
@ -656,12 +658,12 @@ auto encrypt_provider::get_used_drive_space() const -> std::uint64_t {
auto encrypt_provider::is_directory(const std::string &api_path,
bool &exists) const -> api_error {
auto result = db::db_select{*db_, source_table}
auto result = utils::db::sqlite::db_select{*db_, source_table}
.column("source_path")
.where("api_path")
.equals(api_path)
.go();
std::optional<db::db_select::row> row;
std::optional<utils::db::sqlite::db_select::row> row;
if (not(result.get_row(row) && row.has_value())) {
exists = false;
return api_error::success;
@ -677,12 +679,12 @@ auto encrypt_provider::is_directory(const std::string &api_path,
auto encrypt_provider::is_file(const std::string &api_path,
bool &exists) const -> api_error {
auto result = db::db_select{*db_, source_table}
auto result = utils::db::sqlite::db_select{*db_, source_table}
.column("source_path")
.where("api_path")
.equals(api_path)
.go();
std::optional<db::db_select::row> row;
std::optional<utils::db::sqlite::db_select::row> row;
if (not(result.get_row(row) && row.has_value())) {
exists = false;
return api_error::success;
@ -739,12 +741,12 @@ auto encrypt_provider::process_directory_entry(
current_source_path = utils::path::combine(current_source_path, {part});
std::string current_api_path{};
auto result = db::db_select{*db_, directory_table}
auto result = utils::db::sqlite::db_select{*db_, directory_table}
.column("api_path")
.where("source_path")
.equals(current_source_path)
.go();
std::optional<db::db_select::row> row;
std::optional<utils::db::sqlite::db_select::row> row;
if (result.get_row(row) && row.has_value()) {
current_api_path = row->get_column("api_path").get_value<std::string>();
}
@ -753,12 +755,12 @@ auto encrypt_provider::process_directory_entry(
current_api_path = utils::path::create_api_path(
current_encrypted_path + '/' + encrypted_parts.at(current_idx));
auto ins_res = db::db_insert{*db_, directory_table}
auto ins_res = utils::db::sqlite::db_insert{*db_, directory_table}
.column_value("source_path", current_source_path)
.column_value("api_path", current_api_path)
.go();
// TODO handle error
ins_res = db::db_insert{*db_, source_table}
ins_res = utils::db::sqlite::db_insert{*db_, source_table}
.column_value("api_path", current_api_path)
.column_value("source_path", current_source_path)
.go();
@ -789,18 +791,18 @@ auto encrypt_provider::process_directory_entry(
utils::path::get_relative_path(dir_entry.get_path(), cfg.path);
std::string api_path_data{};
auto result = db::db_select{*db_, file_table}
auto result = utils::db::sqlite::db_select{*db_, file_table}
.column("data")
.where("source_path")
.equals(dir_entry.get_path())
.go();
std::optional<db::db_select::row> row;
std::optional<utils::db::sqlite::db_select::row> row;
if (result.get_row(row) && row.has_value()) {
api_path_data = row->get_column("data").get_value<std::string>();
}
std::string api_parent{};
result = db::db_select{*db_, directory_table}
result = utils::db::sqlite::db_select{*db_, directory_table}
.column("api_path")
.where("source_path")
.equals(utils::path::get_parent_path(dir_entry.get_path()))
@ -834,13 +836,13 @@ auto encrypt_provider::process_directory_entry(
.value_or(0U)),
},
};
auto ins_res = db::db_insert{*db_, file_table}
auto ins_res = utils::db::sqlite::db_insert{*db_, file_table}
.column_value("source_path", dir_entry.get_path())
.column_value("data", data.dump())
.go();
// TODO handle error
ins_res = db::db_insert{*db_, source_table}
ins_res = utils::db::sqlite::db_insert{*db_, source_table}
.column_value("api_path", api_path)
.column_value("source_path", dir_entry.get_path())
.go();
@ -865,12 +867,12 @@ auto encrypt_provider::read_file_bytes(const std::string &api_path,
static_cast<const char *>(__FUNCTION__),
};
auto result = db::db_select{*db_, source_table}
auto result = utils::db::sqlite::db_select{*db_, source_table}
.column("source_path")
.where("api_path")
.equals(api_path)
.go();
std::optional<db::db_select::row> row;
std::optional<utils::db::sqlite::db_select::row> row;
if (not(result.get_row(row) && row.has_value())) {
return api_error::item_not_found;
}
@ -880,7 +882,7 @@ auto encrypt_provider::read_file_bytes(const std::string &api_path,
return api_error::item_not_found;
}
result = db::db_select{*db_, file_table}
result = utils::db::sqlite::db_select{*db_, file_table}
.column("data")
.where("source_path")
.equals(source_path)
@ -919,7 +921,7 @@ auto encrypt_provider::read_file_bytes(const std::string &api_path,
file_data["original_file_size"] = file_size;
file_data["iv_list"] = iv_list;
auto ins_res = db::db_insert{*db_, file_table}
auto ins_res = utils::db::sqlite::db_insert{*db_, file_table}
.or_replace()
.column_value("source_path", source_path)
.column_value("data", file_data.dump())
@ -974,11 +976,11 @@ void encrypt_provider::remove_deleted_files() {
};
std::vector<removed_item> removed_list{};
std::vector<db::db_select::row> row_list{};
std::vector<utils::db::sqlite::db_select::row> row_list{};
auto result = db::db_select{*db_, source_table}.go();
auto result = utils::db::sqlite::db_select{*db_, source_table}.go();
while (result.has_row()) {
std::optional<db::db_select::row> row;
std::optional<utils::db::sqlite::db_select::row> row;
if (result.get_row(row) && row.has_value()) {
row_list.push_back(row.value());
}
@ -988,7 +990,7 @@ void encrypt_provider::remove_deleted_files() {
auto source_path = row.get_column("source_path").get_value<std::string>();
if (not utils::path::exists(source_path)) {
auto api_path = row.get_column("api_path").get_value<std::string>();
result = db::db_select{*db_, file_table}
result = utils::db::sqlite::db_select{*db_, file_table}
.column("source_path")
.where("source_path")
.equals(source_path)
@ -1000,12 +1002,12 @@ void encrypt_provider::remove_deleted_files() {
for (auto &&item : removed_list) {
if (not item.directory) {
auto del_res = db::db_delete{*db_, source_table}
auto del_res = utils::db::sqlite::db_delete{*db_, source_table}
.where("api_path")
.equals(item.api_path)
.go();
// TODO handle error
del_res = db::db_delete{*db_, file_table}
del_res = utils::db::sqlite::db_delete{*db_, file_table}
.where("source_path")
.equals(item.source_path)
.go();
@ -1017,12 +1019,12 @@ void encrypt_provider::remove_deleted_files() {
for (auto &&item : removed_list) {
if (item.directory) {
auto del_res = db::db_delete{*db_, source_table}
auto del_res = utils::db::sqlite::db_delete{*db_, source_table}
.where("api_path")
.equals(item.api_path)
.go();
// TODO handle error
del_res = db::db_delete{*db_, directory_table}
del_res = utils::db::sqlite::db_delete{*db_, directory_table}
.where("source_path")
.equals(item.source_path)
.go();
@ -1060,7 +1062,7 @@ auto encrypt_provider::start(api_item_added_callback /*api_item_added*/,
for (auto &&create : sql_create_tables) {
std::string err;
if (not db::execute_sql(*db_, create.second, err)) {
if (not utils::db::sqlite::execute_sql(*db_, create.second, err)) {
utils::error::raise_error(function_name, "failed to create table|" +
create.first + '|' + err);
db_.reset();
@ -1068,21 +1070,21 @@ auto encrypt_provider::start(api_item_added_callback /*api_item_added*/,
}
}
db::set_journal_mode(*db_);
utils::db::sqlite::set_journal_mode(*db_);
const auto cfg = config_.get_encrypt_config();
std::string source_path;
auto result = db::db_select{*db_, source_table}
auto result = utils::db::sqlite::db_select{*db_, source_table}
.column("source_path")
.where("api_path")
.equals("/")
.go();
std::optional<db::db_select::row> row;
std::optional<utils::db::sqlite::db_select::row> row;
if (result.get_row(row) && row.has_value()) {
source_path = row->get_column("source_path").get_value<std::string>();
} else {
auto ins_res = db::db_insert{*db_, source_table}
auto ins_res = utils::db::sqlite::db_insert{*db_, source_table}
.column_value("api_path", "/")
.column_value("source_path", cfg.path)
.go();
@ -1090,13 +1092,13 @@ auto encrypt_provider::start(api_item_added_callback /*api_item_added*/,
source_path = cfg.path;
}
result = db::db_select{*db_, directory_table}
result = utils::db::sqlite::db_select{*db_, directory_table}
.column("api_path")
.where("source_path")
.equals(source_path)
.go();
if (not result.has_row()) {
auto ins_res = db::db_insert{*db_, directory_table}
auto ins_res = utils::db::sqlite::db_insert{*db_, directory_table}
.column_value("source_path", source_path)
.column_value("api_path", "/")
.go();

34
repertory/repertory_test/src/database_test.cpp
View File

@ -32,7 +32,7 @@ namespace repertory {
class database_test : public ::testing::Test {
public:
static console_consumer cs;
db::db3_t db3;
utils::db::sqlite::db3_t db3;
void SetUp() override {
event_system::instance().start();
@ -54,7 +54,7 @@ public:
};
static void common_insert(sqlite3 &db, bool dump = false) {
auto query = db::db_insert{db, "table"}
auto query = utils::db::sqlite::db_insert{db, "table"}
.column_value("column1", "test0")
.column_value("column2", "test1");
if (dump) {
@ -67,7 +67,7 @@ static void common_insert(sqlite3 &db, bool dump = false) {
static void common_select(sqlite3 &db, std::string value1, std::string value2,
bool dump = false) {
auto query = db::db_select{db, "table"};
auto query = utils::db::sqlite::db_select{db, "table"};
if (dump) {
std::cout << query.dump() << std::endl;
}
@ -78,7 +78,7 @@ static void common_select(sqlite3 &db, std::string value1, std::string value2,
std::size_t row_count{};
while (res.has_row()) {
std::optional<db::db_select::row> row;
std::optional<utils::db::sqlite::db_select::row> row;
EXPECT_TRUE(res.get_row(row));
EXPECT_TRUE(row.has_value());
if (row.has_value()) {
@ -104,7 +104,7 @@ static void common_select(sqlite3 &db, std::string value1, std::string value2,
static void common_delete(sqlite3 &db, bool dump = false) {
{
auto query = db::db_delete{db, "table"};
auto query = utils::db::sqlite::db_delete{db, "table"};
if (dump) {
std::cout << query.dump() << std::endl;
}
@ -114,7 +114,7 @@ static void common_delete(sqlite3 &db, bool dump = false) {
}
{
auto query = db::db_select{db, "table"};
auto query = utils::db::sqlite::db_select{db, "table"};
auto res = query.go();
EXPECT_TRUE(res.ok());
@ -128,14 +128,14 @@ static void common_delete(sqlite3 &db, bool dump = false) {
}
TEST_F(database_test, db_delete_query) {
auto query = db::db_delete{*db3.get(), "table"};
auto query = utils::db::sqlite::db_delete{*db3.get(), "table"};
auto query_str = query.dump();
std::cout << query_str << std::endl;
EXPECT_STREQ(R"(DELETE FROM "table";)", query_str.c_str());
}
TEST_F(database_test, db_delete_where_query) {
auto query = db::db_delete{*db3.get(), "table"}
auto query = utils::db::sqlite::db_delete{*db3.get(), "table"}
.where("column1")
.equals("test1")
.and_()
@ -148,7 +148,7 @@ TEST_F(database_test, db_delete_where_query) {
}
TEST_F(database_test, db_insert_query) {
auto query = db::db_insert{*db3.get(), "table"}
auto query = utils::db::sqlite::db_insert{*db3.get(), "table"}
.column_value("column1", "test9")
.column_value("column2", "test9");
auto query_str = query.dump();
@ -158,7 +158,7 @@ TEST_F(database_test, db_insert_query) {
}
TEST_F(database_test, db_insert_or_replace_query) {
auto query = db::db_insert{*db3.get(), "table"}
auto query = utils::db::sqlite::db_insert{*db3.get(), "table"}
.or_replace()
.column_value("column1", "test1")
.column_value("column2", "test2");
@ -170,14 +170,14 @@ TEST_F(database_test, db_insert_or_replace_query) {
}
TEST_F(database_test, db_select_query) {
auto query = db::db_select{*db3.get(), "table"};
auto query = utils::db::sqlite::db_select{*db3.get(), "table"};
auto query_str = query.dump();
std::cout << query_str << std::endl;
EXPECT_STREQ(R"(SELECT * FROM "table";)", query_str.c_str());
}
TEST_F(database_test, db_select_where_query) {
auto query = db::db_select{*db3.get(), "table"}
auto query = utils::db::sqlite::db_select{*db3.get(), "table"}
.where("column1")
.equals("test1")
.and_()
@ -191,7 +191,7 @@ TEST_F(database_test, db_select_where_query) {
TEST_F(database_test, db_select_where_with_group_query) {
auto query =
db::db_select{*db3.get(), "table"}
utils::db::sqlite::db_select{*db3.get(), "table"}
.group([](auto &grp) {
grp.where("column1").equals("a").or_().where("column1").equals("b");
})
@ -211,7 +211,7 @@ TEST_F(database_test, db_select_where_with_group_query) {
}
TEST_F(database_test, db_select_columns_query) {
auto query = db::db_select{*db3.get(), "table"}
auto query = utils::db::sqlite::db_select{*db3.get(), "table"}
.column("column1")
.column("column2")
.where("column1")
@ -227,7 +227,7 @@ TEST_F(database_test, db_select_columns_query) {
}
TEST_F(database_test, db_update_query) {
auto query = db::db_update{*db3.get(), "table"}
auto query = utils::db::sqlite::db_update{*db3.get(), "table"}
.column_value("column1", "moose")
.where("column1")
.equals("test1")
@ -253,7 +253,7 @@ TEST_F(database_test, insert_update_delete) {
common_insert(*db3.get());
{
auto query = db::db_update{*db3.get(), "table"}
auto query = utils::db::sqlite::db_update{*db3.get(), "table"}
.column_value("column1", "moose")
.where("column1")
.equals("test0");
@ -271,7 +271,7 @@ TEST_F(database_test, insert_or_replace_and_delete) {
common_insert(*db3.get());
{
auto query = db::db_insert{*db3.get(), "table"}
auto query = utils::db::sqlite::db_insert{*db3.get(), "table"}
.or_replace()
.column_value("column1", "test0")
.column_value("column2", "moose");