pEp.foundation
/
libpEpAdapter
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Refactor out into a dedicated replication driver (Implementing the GroupManagerInterface) 

This is just the C interface.
LIB-11
heck 4 years ago
parent
9ab5d92340
commit
2e7e1bfddf
3 changed files with 327 additions and 122 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 141
      src/adapter_group.cc
  2. 230
      src/grp_driver_replicator.cc
  3. 78
      src/grp_driver_replicator.hh

141
src/adapter_group.cc
View File

@ -3,11 +3,7 @@
#include <pEp/group.h>
#include "adapter_group.h"
#include "grp_update_interface.hh"
#include "grp_query_interface.hh"
#include "grp_update_drv_engine.hh"
#include "grp_update_drv_dummy.hh"
#include "grp_query_drv_dummy.hh"
#include "grp_driver_replicator.hh"
#include "pEpLog.hh"
#ifdef __cplusplus
@ -15,28 +11,12 @@ extern "C" {
#endif
using namespace std;
using namespace pEp;
//Listmanager config
string lm_dummy_db_filename = "listman_dummy.db";
#ifdef WIN32
string lm_dummy_db_path = string(::per_user_directory()) + "\\" + listman_db_filename;
#else
string lm_dummy_db_path = string(::per_user_directory()) + "/" + lm_dummy_db_filename;
#endif
pEp::Adapter::GroupDriverReplicator adapter_grp_manager{};
/*************************************************************************************************
* Group management functions
*************************************************************************************************/
// Engine Driver
GroupUpdateDriverEngine group_update_driver_engine{};
GroupUpdateInterface *gu_engine = &group_update_driver_engine;
// Listmanager Driver
GroupUpdateDriverDummy group_update_driver_dummy{ lm_dummy_db_path };
GroupUpdateInterface *gu_listman = &group_update_driver_dummy;
DYNAMIC_API PEP_STATUS adapter_group_create(
PEP_SESSION session,
pEp_identity *group_identity,
@ -44,72 +24,17 @@ DYNAMIC_API PEP_STATUS adapter_group_create(
identity_list *memberlist)
{
pEpLog("called");
// Do listmanager
PEP_STATUS status = gu_listman->adapter_group_create(session, group_identity, manager, memberlist);
if (status != PEP_STATUS_OK) {
return status;
}
// Do engine
status = gu_engine->adapter_group_create(session, group_identity, manager, memberlist);
if (status != PEP_STATUS_OK) {
// Rollback listman
PEP_STATUS rb_stat = gu_listman->adapter_group_dissolve(session, group_identity, manager);
if (rb_stat != PEP_STATUS_OK) {
//FATAL ERROR ON ROLLBACK
status = (PEP_STATUS)-9999;
}
}
PEP_STATUS status = adapter_grp_manager
.adapter_group_create(session, group_identity, manager, memberlist);
return status;
}
//DYNAMIC_API PEP_STATUS
//adapter_group_join(PEP_SESSION session, pEp_identity *group_identity, pEp_identity *as_member)
//{
// pEpLog("called");
// // Do listmanager
// PEP_STATUS status = gu_listman->adapter_group_join(session, group_identity, as_member);
// if (status != PEP_STATUS_OK) {
// return status;
// }
//
// // Do engine
// status = gu_engine->adapter_group_join(session, group_identity, as_member);
// if (status != PEP_STATUS_OK) {
// // Rollback listman
// //TODO: ????
// // PEP_STATUS rb_stat = gu_listman->adapter_group_dissolve(session, group_identity, manager);
// // if (rb_stat != PEP_STATUS_OK) {
// // //FATAL ERROR ON ROLLBACK
// // status = (PEP_STATUS)-9999;
// // }
// }
// return status;
//}
DYNAMIC_API PEP_STATUS
adapter_group_dissolve(PEP_SESSION session, pEp_identity *group_identity, pEp_identity *manager)
{
pEpLog("called");
// Do listmanager
PEP_STATUS status = gu_listman->adapter_group_dissolve(session, group_identity, manager);
if (status != PEP_STATUS_OK) {
return status;
}
// Do engine
status = gu_engine->adapter_group_dissolve(session, group_identity, manager);
if (status != PEP_STATUS_OK) {
// Rollback listman
// TODO: ????
// PEP_STATUS rb_stat = gu_listman->adapter_group_dissolve(session, group_identity, manager);
// if (rb_stat != PEP_STATUS_OK) {
// //FATAL ERROR ON ROLLBACK
// status = (PEP_STATUS)-9999;
// }
}
PEP_STATUS status = adapter_grp_manager.adapter_group_dissolve(session, group_identity, manager);
return status;
}
@ -119,22 +44,10 @@ DYNAMIC_API PEP_STATUS adapter_group_invite_member(
pEp_identity *group_member)
{
pEpLog("called");
// Do listmanager
PEP_STATUS status = gu_listman->adapter_group_invite_member(session, group_identity, group_member);
if (status != PEP_STATUS_OK) {
return status;
}
// Do engine
status = gu_engine->adapter_group_invite_member(session, group_identity, group_member);
if (status != PEP_STATUS_OK) {
// Rollback
PEP_STATUS rb_stat = gu_listman->adapter_group_remove_member(session, group_member, group_member);
if (rb_stat != PEP_STATUS_OK) {
//FATAL ERROR ON ROLLBACK
status = (PEP_STATUS)-9999;
}
}
PEP_STATUS status = adapter_grp_manager.adapter_group_invite_member(
session,
group_identity,
group_member);
return status;
}
@ -144,53 +57,37 @@ PEP_STATUS adapter_group_remove_member(
pEp_identity *group_member)
{
pEpLog("called");
// Do listmanager
PEP_STATUS status = gu_listman->adapter_group_remove_member(session, group_identity, group_member);
if (status != PEP_STATUS_OK) {
return status;
}
// Do engine
status = gu_engine->adapter_group_remove_member(session, group_identity, group_member);
if (status != PEP_STATUS_OK) {
// Rollback
PEP_STATUS rb_stat = gu_listman->adapter_group_invite_member(
session,
group_identity,
group_member);
if (rb_stat != PEP_STATUS_OK) {
//FATAL ERROR ON ROLLBACK
status = (PEP_STATUS)-9999;
}
}
PEP_STATUS status = adapter_grp_manager.adapter_group_remove_member(
session,
group_identity,
group_member);
return status;
}
/*************************************************************************************************
* Group query functions
*************************************************************************************************/
// Listmanager Driver
GroupQueryDriverDummy group_query_driver_dummy{ lm_dummy_db_path };
GroupQueryInterface *gq_listman = &group_query_driver_dummy;
DYNAMIC_API PEP_STATUS group_query_groups(PEP_SESSION session, identity_list **groups)
{
pEpLog("called");
return gq_listman->group_query_groups(session, groups);
PEP_STATUS status = adapter_grp_manager.group_query_groups(session, groups);
return status;
}
DYNAMIC_API PEP_STATUS
group_query_manager(PEP_SESSION session, const pEp_identity *const group, pEp_identity **manager)
{
pEpLog("called");
return gq_listman->group_query_manager(session, group, manager);
PEP_STATUS status = adapter_grp_manager.group_query_manager(session, group, manager);
return status;
}
DYNAMIC_API PEP_STATUS
group_query_members(PEP_SESSION session, const pEp_identity *const group, identity_list **members)
{
pEpLog("called");
return gq_listman->group_query_members(session, group, members);
PEP_STATUS status = adapter_grp_manager.group_query_members(session, group, members);
return status;
}
#ifdef __cplusplus

230
src/grp_driver_replicator.cc
View File

@ -0,0 +1,230 @@
// This file is under GNU General Public License 3.0
// see LICENSE.txt
#include "grp_driver_replicator.hh"
using namespace std;
namespace pEp {
namespace Adapter {
bool GroupDriverReplicator::log_enabled = false;
GroupDriverReplicator::GroupDriverReplicator()
{
pEpLogClass("called");
const string lm_dummy_db_filename = "listman_dummy.db";
#ifdef WIN32
const string lm_dummy_db_path = string(::per_user_directory()) + "\\" +
lm_dummy_db_filename;
#else
const string lm_dummy_db_path = string(::per_user_directory()) + "/" +
lm_dummy_db_filename;
#endif
default_repl_src = make_shared<GroupDriverDummy>(lm_dummy_db_path);
set_replication_source(*default_repl_src);
default_repl_dst = make_shared<GroupDriverEngine>();
set_replication_destination(*default_repl_dst);
}
void GroupDriverReplicator::set_replication_source(GroupManagerInterface &src)
{
pEpLogClass("called");
repl_src = &src;
}
void GroupDriverReplicator::set_replication_destination(GroupUpdateInterface &dst)
{
pEpLogClass("called");
repl_dst = &dst;
}
// GroupUpdateInterface
PEP_STATUS GroupDriverReplicator::adapter_group_create(
PEP_SESSION session,
pEp_identity *group_identity,
pEp_identity *manager,
identity_list *memberlist) noexcept
{
pEpLogClass("called");
if (!has_repl_src_and_dst()) {
return PEP_UNKNOWN_ERROR;
}
// Do listmanager
PEP_STATUS status = repl_src->adapter_group_create(
session,
group_identity,
manager,
memberlist);
if (status != PEP_STATUS_OK) {
return status;
}
// Do engine
status = repl_dst->adapter_group_create(session, group_identity, manager, memberlist);
if (status != PEP_STATUS_OK) {
// Rollback listman
PEP_STATUS rb_stat = repl_src->adapter_group_dissolve(session, group_identity, manager);
if (rb_stat != PEP_STATUS_OK) {
//FATAL ERROR ON ROLLBACK
status = (PEP_STATUS)-9999;
}
}
return status;
}
PEP_STATUS GroupDriverReplicator::adapter_group_dissolve(
PEP_SESSION session,
pEp_identity *group_identity,
pEp_identity *manager) noexcept
{
pEpLogClass("called");
if (!has_repl_src_and_dst()) {
return PEP_UNKNOWN_ERROR;
}
// Do listmanager
PEP_STATUS status = repl_src->adapter_group_dissolve(session, group_identity, manager);
if (status != PEP_STATUS_OK) {
return status;
}
// Do engine
status = repl_dst->adapter_group_dissolve(session, group_identity, manager);
if (status != PEP_STATUS_OK) {
// Rollback listman
// TODO: ????
// PEP_STATUS rb_stat = gu_listman->adapter_group_dissolve(session, group_identity, manager);
// if (rb_stat != PEP_STATUS_OK) {
// //FATAL ERROR ON ROLLBACK
// status = (PEP_STATUS)-9999;
// }
}
return status;
}
PEP_STATUS GroupDriverReplicator::adapter_group_invite_member(
PEP_SESSION session,
pEp_identity *group_identity,
pEp_identity *group_member) noexcept
{
pEpLogClass("called");
if (!has_repl_src_and_dst()) {
return PEP_UNKNOWN_ERROR;
}
// Do listmanager
PEP_STATUS status = repl_src->adapter_group_invite_member(
session,
group_identity,
group_member);
if (status != PEP_STATUS_OK) {
return status;
}
// Do engine
status = repl_dst->adapter_group_invite_member(session, group_identity, group_member);
if (status != PEP_STATUS_OK) {
// Rollback
PEP_STATUS rb_stat = repl_src->adapter_group_remove_member(
session,
group_member,
group_member);
if (rb_stat != PEP_STATUS_OK) {
//FATAL ERROR ON ROLLBACK
status = (PEP_STATUS)-9999;
}
}
return status;
}
PEP_STATUS GroupDriverReplicator::adapter_group_remove_member(
PEP_SESSION session,
pEp_identity *group_identity,
pEp_identity *group_member) noexcept
{
pEpLogClass("called");
if (!has_repl_src_and_dst()) {
return PEP_UNKNOWN_ERROR;
}
// Do listmanager
PEP_STATUS status = repl_src->adapter_group_remove_member(
session,
group_identity,
group_member);
if (status != PEP_STATUS_OK) {
return status;
}
// Do engine
status = repl_dst->adapter_group_remove_member(session, group_identity, group_member);
if (status != PEP_STATUS_OK) {
// Rollback
PEP_STATUS rb_stat = repl_src->adapter_group_invite_member(
session,
group_identity,
group_member);
if (rb_stat != PEP_STATUS_OK) {
//FATAL ERROR ON ROLLBACK
status = (PEP_STATUS)-9999;
}
}
return status;
}
// GroupQueryInterface
PEP_STATUS GroupDriverReplicator::group_query_groups(
PEP_SESSION session,
identity_list **groups) noexcept
{
pEpLogClass("called");
if (!has_repl_src_and_dst()) {
return PEP_UNKNOWN_ERROR;
}
return repl_src->group_query_groups(session, groups);
}
PEP_STATUS GroupDriverReplicator::group_query_manager(
PEP_SESSION session,
const pEp_identity *const group,
pEp_identity **manager) noexcept
{
pEpLogClass("called");
if (!has_repl_src_and_dst()) {
return PEP_UNKNOWN_ERROR;
}
return repl_src->group_query_manager(session, group, manager);
}
PEP_STATUS GroupDriverReplicator::group_query_members(
PEP_SESSION session,
const pEp_identity *const group,
identity_list **members) noexcept
{
pEpLogClass("called");
if (!has_repl_src_and_dst()) {
return PEP_UNKNOWN_ERROR;
}
return repl_src->group_query_members(session, group, members);
}
bool GroupDriverReplicator::has_repl_src_and_dst()
{
bool ret = true;
if (!repl_src) {
ret = false;
pEpLogClass("Abort: no replication source (listmanager)");
}
if (!repl_dst) {
ret = false;
pEpLogClass("Abort: no replication destination (pEpEngine)");
}
return ret;
}
} // namespace Adapter
} // namespace pEp

78
src/grp_driver_replicator.hh
View File

@ -0,0 +1,78 @@
// This file is under GNU General Public License 3.0
// see LICENSE.txt
#ifndef LIBPEPADAPTER_GRP_DRIVER_REPLICATOR_HH
#define LIBPEPADAPTER_GRP_DRIVER_REPLICATOR_HH
#include "grp_manager_interface.hh"
#include "grp_driver_engine.hh"
#include "grp_driver_dummy.hh"
#include "pEpLog.hh"
#include <pEp/message_api.h>
namespace pEp {
namespace Adapter {
class GroupDriverReplicator : public GroupManagerInterface {
public:
GroupDriverReplicator();
void set_replication_source(GroupManagerInterface &src);
void set_replication_destination(GroupUpdateInterface &dst);
// GroupUpdateInterface
PEP_STATUS adapter_group_create(
::PEP_SESSION session,
::pEp_identity *group_identity,
::pEp_identity *manager,
::identity_list *memberlist) noexcept override;
PEP_STATUS adapter_group_dissolve(
::PEP_SESSION session,
::pEp_identity *group_identity,
::pEp_identity *manager) noexcept override;
PEP_STATUS adapter_group_invite_member(
::PEP_SESSION session,
::pEp_identity *group_identity,
::pEp_identity *group_member) noexcept override;
PEP_STATUS adapter_group_remove_member(
::PEP_SESSION session,
::pEp_identity *group_identity,
::pEp_identity *group_member) noexcept override;
// GroupQueryInterface
PEP_STATUS group_query_groups(::PEP_SESSION session, ::identity_list **groups) noexcept override;
PEP_STATUS group_query_manager(
::PEP_SESSION session,
const ::pEp_identity *const group,
::pEp_identity **manager) noexcept override;
PEP_STATUS group_query_members(
::PEP_SESSION session,
const ::pEp_identity *const group,
::identity_list **members) noexcept override;
// Logging
static bool log_enabled;
Adapter::pEpLog::pEpLogger logger{ "GroupDriverReplicator", log_enabled };
private:
// Group replication roles
// Default replication source and destination
std::shared_ptr<GroupManagerInterface> default_repl_src;
std::shared_ptr<GroupUpdateInterface> default_repl_dst;
// Current replication source and destination
GroupManagerInterface *repl_src = nullptr; // Source needs full interface
GroupUpdateInterface *repl_dst = nullptr; // Destination needs update interface only
// Helpers
bool has_repl_src_and_dst();
// Logging
Adapter::pEpLog::pEpLogger &m4gic_logger_n4me = logger;
};
} // namespace Adapter
} // namespace pEp
#endif // LIBPEPADAPTER_GRP_DRIVER_REPLICATOR_HH
Write Preview
Loading…
Cancel
Save