diff --git a/src/pEp/__init__.py b/src/pEp/__init__.py index 4758c5c..76416a0 100755 --- a/src/pEp/__init__.py +++ b/src/pEp/__init__.py @@ -14,11 +14,9 @@ try: from .__version__ import version as __version__ except ImportError: import warnings - warnings.warn("Error loading build-time defined __version__.py, trying setuptools now...") try: import setuptools_scm - __version__ = setuptools_scm.get_version() del setuptools_scm except Exception: @@ -33,6 +31,7 @@ from ._pEp import * import pEp._pEp # 3rd party imports +from os import environ from threading import Thread, Barrier from time import sleep from enum import Enum @@ -40,8 +39,42 @@ from enum import Enum # Executed on module import def init(): + # enable log until the desired setting is clear + _pEp.set_debug_log_enabled(True) + env_var_log_adapter_enabled: str = "PEP_LOG_ADAPTER" + log_adapter_enabled: bool = False + try: + if environ[env_var_log_adapter_enabled] == "0": + log_adapter_enabled = False + _pEp._log("env var {} set to 0".format(env_var_log_adapter_enabled)) + elif environ[env_var_log_adapter_enabled] == "1": + log_adapter_enabled = True + else: + _pEp._log("env var {}: valid values are 1 or 0".format(env_var_log_adapter_enabled)) + except: + _pEp._log("env var {} not set. Defaulting to {}".format(env_var_log_adapter_enabled, log_adapter_enabled)) + + _pEp.set_debug_log_enabled(log_adapter_enabled) + + + # Sync event processing (Sync/Async) + use_sync_thread: bool = True + env_var_use_sync_thread: str = "PEP_MULTITHREAD" + try: + if environ[env_var_use_sync_thread] == "0": + use_sync_thread = False + print("env var {} set to 0, Sync-event processing set to synchronous".format(env_var_use_sync_thread,use_sync_thread)) + elif environ[env_var_use_sync_thread] == "1": + use_sync_thread = True + print("env var {} set to 1, Sync-event processing set to asynchronous".format(env_var_use_sync_thread,use_sync_thread)) + else: + _pEp._log("env var {}: valid values are 1 or 0".format(env_var_log_adapter_enabled)) + except: + _pEp._log("env var {} not set. Defaulting to {}".format(env_var_use_sync_thread,use_sync_thread)) + + _pEp._init_callbackdispatcher() - _pEp._init_session(True) + _pEp._init_session(use_sync_thread) def start_sync() -> None: @@ -52,24 +85,6 @@ def start_sync() -> None: def shutdown_sync() -> None: """call this to shut down the sync thread""" Sync.shutdown_sync() - # set_sync_mode(SyncModes.Off) - - -class SyncModes(Enum): - OFF: int = 0 - SYNC: int = 1 - ASYNC: int = 2 - - -def set_sync_mode(mode): - if mode == SyncModes.SYNC: - Sync.shutdown_sync() - _pEp._init_session(False) - if mode == SyncModes.ASYNC: - _pEp._init_session(True) - Sync.start_sync() - if mode == SyncModes.OFF: - Sync.shutdown_sync() def is_sync_active() -> bool: @@ -105,7 +120,7 @@ class Sync(Thread): def __init__(self): if Sync.__instance != None: - raise Exception("singleton!") + raise Exception("singleton already instantiated. Dont use constructor, use getInstance()") else: Sync.__instance = self Thread.__init__(self) @@ -123,18 +138,15 @@ class Sync(Thread): register_sync_callbacks * 2. Create session for the sync thread (registers: messageToSend, _inject_sync_event, _ensure_passphrase) * 3. register_sync_callbacks() (registers: _notifyHandshake, _retrieve_next_sync_event) - * 4. Enter Sync Event Dispatching Loop (do_sync_protocol()) + * 4. Enter Sync Event Dispatching Loop (do_sync_protocol()) unregister_sync_callbacks * 5. unregister_sync_callbacks() * 6. Release the session * NOPE 7. Execute registered shutdown function """ - # TODO catch exception, and rethrow in start() - # _pEp._register_sync_callbacks() - _pEp._init_session(True) self.barr.wait() - while _pEp._do_protocol_step(): + while _pEp._do_protocol_step_from_queue(): sleep(1) _pEp._free_session() diff --git a/src/pEp/_pEp/pEpmodule.cc b/src/pEp/_pEp/pEpmodule.cc index a6ef6aa..c09603c 100644 --- a/src/pEp/_pEp/pEpmodule.cc +++ b/src/pEp/_pEp/pEpmodule.cc @@ -106,46 +106,30 @@ namespace pEp { } } - // TODO: GIL handling isnt really required here, i think PEP_STATUS _messageToSend(::message *msg) { pEpLog("called"); - try { - PyGILState_STATE gil = PyGILState_Ensure(); - pEpLog("GIL Aquired"); - object modref = import("pEp"); - object funcref = modref.attr("message_to_send"); - call(funcref.ptr(), Message(msg)); - PyGILState_Release(gil); - pEpLog("GIL released"); - } catch (std::exception &e) { - } - + object modref = import("pEp"); + object funcref = modref.attr("message_to_send"); + call(funcref.ptr(), Message(msg)); return PEP_STATUS_OK; } - // TODO: GIL handling isnt really required here, i think PEP_STATUS _notifyHandshake(pEp_identity *me, pEp_identity *partner, sync_handshake_signal signal) { pEpLog("called"); - try { - PyGILState_STATE gil = PyGILState_Ensure(); - pEpLog("GIL Aquired"); - object modref = import("pEp"); - object funcref = modref.attr("notify_handshake"); - call(funcref.ptr(), Identity(me), Identity(partner), signal); - PyGILState_Release(gil); - pEpLog("GIL released"); - } catch (std::exception &e) { - } - + object modref = import("pEp"); + object funcref = modref.attr("notify_handshake"); + call(funcref.ptr(), Identity(me), Identity(partner), signal); return PEP_STATUS_OK; } - bool _do_protocol_step() + bool _do_protocol_step_from_queue() { pEpLog("called"); - SYNC_EVENT event = Adapter::_cb_retrieve_next_sync_event_dequeue_next_sync_event(nullptr, 0); + SYNC_EVENT event = Adapter::_cb_retrieve_next_sync_event_dequeue_next_sync_event( + nullptr, + 0); if (event != NULL) { ::do_sync_protocol_step(Adapter::session(), event); return true; @@ -204,8 +188,9 @@ namespace pEp { for (int i = 0; i < boost::python::len(identities); ++i) { Identity ident = extract(identities[i]); si = identity_list_add(si, ident); - if (!si) + if (!si) { throw std::bad_alloc(); + } } } catch (std::exception &ex) { free_identity_list(shared_identities); @@ -221,6 +206,10 @@ namespace pEp { _throw_status(status); } + void _log(const std::string& msg) { + pEpLog(msg); + } + BOOST_PYTHON_MODULE(_pEp) { def("_init_callbackdispatcher", _init_callbackdispatcher); @@ -236,11 +225,11 @@ namespace pEp { scope().attr("protocol_version") = get_protocol_version(); def("set_debug_log_enabled", &Adapter::pEpLog::set_enabled, "Switch debug logging on/off"); - + def("_log", _log); def("_init_session", _init_session); def("_free_session", _free_session); - def("_do_protocol_step", _do_protocol_step); + def("_do_protocol_step_from_queue", _do_protocol_step_from_queue); def("_inject_sync_shutdown", Adapter::inject_sync_shutdown); def("_notifyHandshake_sync_start", _notifyHandshake_sync_start); def("_notifyHandshake_sync_stop", _notifyHandshake_sync_stop);