King_DuckZ/dindexer
1
0
Fork 0
mirror of https://github.com/KingDuckZ/dindexer.git synced 2025-02-19 12:04:54 +00:00
Code Issues Releases Wiki Activity

Load postgresql plugin and use that in tag.

Browse source 
Only partially implemented.
This commit is contained in:
King_DuckZ 2016-05-27 20:31:07 +02:00
parent c97a08860f
commit 20b2a8695e
8 changed files with 83 additions and 65 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
dindexer.yml
View file

@ -1,6 +1,7 @@
%YAML 1.2
---
db_settings:
db_backend_name: postgresql
db_backend_settings:
username: your_username
password: your_password
dbname: dindexer

6
include/dindexer-common/settings.hpp
View file

@ -19,11 +19,13 @@
#define idDC29E3C667BD4793BA0644AE7DC5BD3F
#include <string>
#include "db/settings.hpp"
#include "backends/backend_loader.hpp"
#include "backends/db_backend.hpp"
namespace dinlib {
struct Settings {
dindb::Settings db;
std::string backend_name;
dindb::BackendPlugin backend_plugin;
};
bool load_settings ( const std::string& parPath, Settings& parOut, bool parExpand=true );

4
src/backends/postgresql/CMakeLists.txt
View file

@ -1,6 +1,6 @@
project(${bare_name}-backend-postgresql CXX)
add_library(${PROJECT_NAME} STATIC
add_library(${PROJECT_NAME} SHARED
tag.cpp
delete.cpp
locate.cpp
@ -10,7 +10,7 @@ add_library(${PROJECT_NAME} STATIC
)
target_include_directories(${PROJECT_NAME}
PUBLIC ${CMAKE_SOURCE_DIR}/include/backends/postgresql
PUBLIC ${DINDEXER_PUB_INCLUDE_DIR}/backends/postgresql
)
target_include_directories(${PROJECT_NAME} SYSTEM
PUBLIC ${Boost_INCLUDE_DIRS}

38
src/backends/postgresql/backend_postgresql.cpp
View file

@ -23,10 +23,22 @@
#include <cassert>
#include <yaml-cpp/yaml.h>
namespace dindb {
namespace {
struct PostgreConnectionSettings {
std::string address;
std::string username;
std::string password;
std::string dbname;
uint16_t port;
};
} //unnamed namespace
} //namespace dindb
namespace YAML {
template<>
struct convert<dindb::Settings> {
static Node encode (const dindb::Settings& parSettings) {
struct convert<dindb::PostgreConnectionSettings> {
static Node encode (const dindb::PostgreConnectionSettings& parSettings) {
Node node;
node["address"] = parSettings.address;
node["username"] = parSettings.username;
@ -36,7 +48,7 @@ namespace YAML {
return node;
}
static bool decode (const Node& parNode, dindb::Settings& parSettings) {
static bool decode (const Node& parNode, dindb::PostgreConnectionSettings& parSettings) {
if (not parNode.IsMap() or parNode.size() != 5) {
return false;
}
@ -92,11 +104,25 @@ namespace dindb {
}
} //namespace dindb
extern "C" dindb::Backend* create_backend (const YAML::Node*) {
return new dindb::BackendPostgreSql("A", "B", "C", "D", 1);
extern "C" dindb::Backend* dindexer_create_backend (const YAML::Node* parConfig) {
if (not parConfig)
return nullptr;
auto config = parConfig->as<dindb::PostgreConnectionSettings>();
return new dindb::BackendPostgreSql(
std::move(config.username),
std::move(config.password),
std::move(config.dbname),
std::move(config.address),
config.port
);
}
extern "C" void destroy_backend (dindb::Backend* parDele) {
extern "C" void dindexer_destroy_backend (dindb::Backend* parDele) {
if (parDele)
delete parDele;
}
extern "C" const char* dindexer_backend_name() {
return "postgresql";
}

2
src/common/CMakeLists.txt
View file

@ -23,7 +23,7 @@ target_link_libraries(${PROJECT_NAME}
PRIVATE ${bare_name}-if
PRIVATE ${YAMLCPP_LIBRARY}
PRIVATE ${Readline_LIBRARY}
PUBLIC ${bare_name}-backend-${DINDEXER_DB_BACKEND_LOWERCASE}
${bare_name}-backend
)
#install(TARGETS ${PROJECT_NAME}

50
src/common/settings.cpp
View file

@ -16,41 +16,15 @@
*/
#include "dindexer-common/settings.hpp"
#include "dindexerConfig.h"
#include <yaml-cpp/yaml.h>
#include <ciso646>
#include <wordexp.h>
namespace YAML {
template<>
struct convert<dindb::Settings> {
static Node encode (const dindb::Settings& parSettings) {
Node node;
node["address"] = parSettings.address;
node["username"] = parSettings.username;
node["password"] = parSettings.password;
node["port"] = parSettings.port;
node["dbname"] = parSettings.dbname;
return node;
}
static bool decode (const Node& parNode, dindb::Settings& parSettings) {
if (not parNode.IsMap() or parNode.size() != 5) {
return false;
}
parSettings.address = parNode["address"].as<std::string>();
parSettings.username = parNode["username"].as<std::string>();
parSettings.password = parNode["password"].as<std::string>();
parSettings.dbname = parNode["dbname"].as<std::string>();
parSettings.port = parNode["port"].as<uint16_t>();
return true;
}
};
} //namespace YAML
namespace dinlib {
namespace {
std::string expand ( const char* parString );
std::string find_plugin_by_name ( const std::string& parName );
} //unnamed namespace
bool load_settings (const std::string& parPath, dinlib::Settings& parOut, bool parExpand) {
@ -59,8 +33,14 @@ namespace dinlib {
try {
auto settings = YAML::LoadFile(path);
if (settings["db_settings"]) {
parOut.db = settings["db_settings"].as<dindb::Settings>();
if (not settings["db_backend_name"]) {
return false;
}
parOut.backend_name = settings["db_backend_name"].as<std::string>();
if (settings["db_backend_settings"]) {
//parOut.db = settings["db_backend_settings"].as<dindb::Settings>();
auto settings_node = settings["db_backend_settings"];
parOut.backend_plugin = dindb::BackendPlugin(find_plugin_by_name(parOut.backend_name), &settings_node);
return true;
}
}
@ -83,5 +63,15 @@ namespace dinlib {
wordfree(&p);
return oss.str();
}
std::string find_plugin_by_name (const std::string& parName) {
//assert(false); //not implemented
//TODO: write a proper implementation
std::string path = ACTIONS_SEARCH_PATH;
path += "/backends/postgresql/libdindexer-backend-postgresql.so";
assert(dindb::backend_name(path) == parName);
return path;
}
} //unnamed namespace
} //namespace dinlib

3
src/pq/CMakeLists.txt
View file

@ -1,5 +1,8 @@
project(${bare_name}-pq CXX)
set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fPIC")
set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fPIC")
add_library(${PROJECT_NAME} STATIC
connection.cpp
databaseexception.cpp

42
src/tag/main.cpp
View file

@ -18,7 +18,6 @@
#include "commandline.hpp"
#include "dindexer-common/settings.hpp"
#include "dindexerConfig.h"
#include "db/tag.hpp"
#include "dindexer-common/split_tags.hpp"
#include "glob2regex/glob2regex.hpp"
#include "enum.h"
@ -47,24 +46,18 @@ namespace {
return retval;
}
dindb::OwnerSetInfo make_owner_set_info (const boost::program_options::variables_map& parVM) {
dindb::OwnerSetInfo set_info;
if (parVM.count("set")) {
set_info.is_valid = true;
set_info.group_id = parVM["set"].as<uint32_t>();
}
else {
set_info.is_valid = false;
set_info.group_id = 0;
}
return set_info;
dindb::GroupIDType make_owner_set_info (const boost::program_options::variables_map& parVM) {
if (parVM.count("set"))
return parVM["set"].as<dindb::GroupIDType>();
else
return dindb::InvalidGroupID;
}
int tag_files (const dindb::Settings& parDB, TaggingMode parMode, const boost::program_options::variables_map& parVM, const std::vector<boost::string_ref>& parTags) {
int tag_files (dindb::Backend& parDB, TaggingMode parMode, const boost::program_options::variables_map& parVM, const std::vector<boost::string_ref>& parTags) {
using boost::lexical_cast;
using boost::string_ref;
const dindb::OwnerSetInfo set_info = make_owner_set_info(parVM);
const auto set_info = make_owner_set_info(parVM);
switch (parMode) {
case TaggingMode::ID:
@ -73,14 +66,14 @@ namespace {
std::vector<uint64_t> ids;
ids.reserve(ids_string.size());
std::transform(ids_string.begin(), ids_string.end(), std::back_inserter(ids), &lexical_cast<uint64_t, string_ref>);
dindb::tag_files(parDB, ids, parTags, set_info);
parDB.tag_files(ids, parTags, set_info);
return 0;
}
case TaggingMode::Glob:
{
const auto regexes(globs_to_regex_list(parVM["globs"].as<std::vector<std::string>>()));
dindb::tag_files(parDB, regexes, parTags, set_info);
parDB.tag_files(regexes, parTags, set_info);
return 0;
}
@ -90,7 +83,7 @@ namespace {
}
}
int delete_tags (const dindb::Settings& parDB, TaggingMode parMode, const boost::program_options::variables_map& parVM, const std::vector<boost::string_ref>& parTags) {
int delete_tags (dindb::Backend& parDB, TaggingMode parMode, const boost::program_options::variables_map& parVM, const std::vector<boost::string_ref>& parTags) {
using boost::lexical_cast;
using boost::string_ref;
@ -104,9 +97,9 @@ namespace {
ids.reserve(ids_string.size());
std::transform(ids_string.begin(), ids_string.end(), std::back_inserter(ids), &lexical_cast<uint64_t, string_ref>);
if (parVM.count("alltags"))
dindb::delete_all_tags(parDB, ids, make_owner_set_info(parVM));
parDB.delete_all_tags(ids, make_owner_set_info(parVM));
else
dindb::delete_tags(parDB, ids, parTags, make_owner_set_info(parVM));
parDB.delete_tags(ids, parTags, make_owner_set_info(parVM));
return 0;
}
@ -114,9 +107,9 @@ namespace {
{
const auto regexes(globs_to_regex_list(parVM["globs"].as<std::vector<std::string>>()));
if (parVM.count("alltags"))
dindb::delete_all_tags(parDB, regexes, make_owner_set_info(parVM));
parDB.delete_all_tags(regexes, make_owner_set_info(parVM));
else
dindb::delete_tags(parDB, regexes, parTags, make_owner_set_info(parVM));
parDB.delete_tags(regexes, parTags, make_owner_set_info(parVM));
return 0;
}
@ -160,6 +153,9 @@ int main (int parArgc, char* parArgv[]) {
std::cerr << "Can't load settings from " << CONFIG_FILE_PATH << ", quitting\n";
return 1;
}
//TODO: throw if plugin loading failed
assert(settings.backend_plugin.name() == settings.backend_name);
assert(settings.backend_plugin.is_loaded());
}
const auto master_tags_string = vm["tags"].as<std::string>();
@ -167,7 +163,7 @@ int main (int parArgc, char* parArgv[]) {
const auto mode = (glob_mode ? TaggingMode::Glob : TaggingMode::ID);
if (not vm.count("delete"))
return tag_files(settings.db, mode, vm, tags);
return tag_files(settings.backend_plugin.backend(), mode, vm, tags);
else
return delete_tags(settings.db, mode, vm, tags);
return delete_tags(settings.backend_plugin.backend(), mode, vm, tags);
}