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

Backing out all commits after 159:3275abf4bb79

sync
heck 5 years ago
parent
ac9f433f17
commit
a62e51bec8
11 changed files with 33 additions and 113 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. 2
      .hgignore
  2. 42
      Adapter.cc
  3. 8
      Adapter.hh
  4. 6
      Adapter.hxx
  5. 2
      Makefile
  6. 4
      Makefile.conf
  7. 5
      test/Makefile
  8. 16
      test/test_adapter.cc
  9. 3
      test/test_adapter_cxx.cc
  10. 16
      test/test_peplog.cc
  11. 42
      utils.hh

2
.hgignore
View File

@ -9,5 +9,3 @@ test_adapter
lib
local.conf
build/
# Default ignored files
.idea/

42
Adapter.cc
View File

@ -6,15 +6,12 @@
#include <iomanip>
#include <assert.h>
#include "status_to_string.hh"
#include "utils.hh"
using namespace std;
namespace pEp {
void throw_status(PEP_STATUS status)
{
//pEpLog("called");
if (status == PEP_STATUS_OK)
return;
if (status >= 0x400 && status <= 0x4ff)
@ -31,7 +28,7 @@ namespace pEp {
RuntimeError::RuntimeError(const std::string& _text, PEP_STATUS _status)
: std::runtime_error(_text.c_str()), text(_text), status(_status)
{
pEpLog("called");
}
namespace Adapter {
@ -39,25 +36,21 @@ namespace pEp {
notifyHandshake_t _notifyHandshake = nullptr;
std::thread *_sync_thread = nullptr;
::utility::locked_queue< SYNC_EVENT, ::free_Sync_event > sync_q;
std::mutex mutex_global;
::utility::locked_queue< SYNC_EVENT, ::free_Sync_event > q;
std::mutex m;
int _inject_sync_event(SYNC_EVENT ev, void *management)
{
pEpLog("called");
try {
if (ev == nullptr) {
pEpLog("SYNC_EVENT: NULL");
sync_q.clear();
sync_q.push_back(ev);
q.clear();
q.push_back(ev);
}
else {
pEpLog("SYNC_EVENT:" << ev);
sync_q.push_front(ev);
q.push_front(ev);
}
}
catch (exception&) {
pEpErr("Exception");
return 1;
}
if (ev == nullptr) {
@ -68,7 +61,7 @@ namespace pEp {
delete _sync_thread;
_sync_thread = nullptr;
pEpLog("...thread joined");
sync_q.clear();
q.clear();
} else {
//FATAL
pEpLog("FATAL: sync thread not joinable/detached");
@ -81,22 +74,17 @@ namespace pEp {
// threshold: max waiting time in seconds
SYNC_EVENT _retrieve_next_sync_event(void *management, unsigned threshold)
{
pEpLog("called");
SYNC_EVENT syncEvent = nullptr;
const bool success = sync_q.try_pop_front(syncEvent, std::chrono::seconds(threshold));
const bool success = q.try_pop_front(syncEvent, std::chrono::seconds(threshold));
if (!success) {
pEpLog("timeout after [sec]: " << threshold);
if (!success)
return new_sync_timeout_event();
}
pEpLog("returning SYNC_EVENT: " << syncEvent);
return syncEvent;
}
bool on_sync_thread()
{
//pEpLog("called");
if (_sync_thread && _sync_thread->get_id() == this_thread::get_id())
return true;
else
@ -105,8 +93,7 @@ namespace pEp {
PEP_SESSION session(session_action action)
{
pEpLog("called");
std::lock_guard<mutex> lock(mutex_global);
std::lock_guard<mutex> lock(m);
bool in_sync = on_sync_thread();
thread_local static PEP_SESSION _session = nullptr;
@ -115,19 +102,14 @@ namespace pEp {
switch (action) {
case release:
if (_session) {
pEpLog("action = release: releasing session: " << _session);
::release(_session);
_session = nullptr;
} else {
pEpLog("action = release: No session to release");
}
break;
case init:
if (!_session) {
pEpLog("action = init: creating new session");
if (!_session)
status = ::init(&_session, _messageToSend, _inject_sync_event);
}
break;
default:
@ -135,7 +117,6 @@ namespace pEp {
}
throw_status(status);
pEpLog("returning session: " << _session);
return _session;
}
@ -150,7 +131,6 @@ namespace pEp {
bool is_sync_running()
{
pEpLog("called");
return _sync_thread != nullptr;
}
}

8
Adapter.hh
View File

@ -8,6 +8,14 @@
#include <pEp/sync_api.h>
#include <stdexcept>
// TODO: put into not yet existing libpEpAdapter_utils.h, to be across whole libpEpAdapter
#ifdef NDEBUG
#define pEpLog(msg) do{}while(0)
#else
#include <iostream>
#define pEpLog(msg) do{std::cerr << __FILE__ << "::" << __FUNCTION__ << " - " << msg << '\n';} while(0)
#endif
namespace pEp {
// throws std::bad_alloc if status==PEP_OUT_OF_MEMORY,

6
Adapter.hxx
View File

@ -6,7 +6,6 @@
#include <thread>
#include "locked_queue.hh"
#include <cassert>
#include "utils.hh"
namespace pEp {
namespace Adapter {
@ -17,7 +16,7 @@ namespace pEp {
extern std::thread *_sync_thread;
extern ::utility::locked_queue< SYNC_EVENT, ::free_Sync_event > q;
extern std::mutex mutex_global;
extern std::mutex m;
SYNC_EVENT _retrieve_next_sync_event(void *management, unsigned threshold);
@ -26,7 +25,6 @@ namespace pEp {
template< class T > void sync_thread(T *obj, function< void(T *) > _startup, function< void(T *) > _shutdown)
{
pEpLog("called");
_ex = nullptr;
assert(_messageToSend);
assert(_notifyHandshake);
@ -69,8 +67,6 @@ namespace pEp {
)
throw (RuntimeError)
{
pEpLog("called");
if (messageToSend)
_messageToSend = messageToSend;

2
Makefile
View File

@ -17,7 +17,7 @@ ifdef BUILD_CONFIG
$(info ================================================)
endif
.PHONY: all lib test install uninstall clean
.PHONY: all, lib, test, install, uninstall, clean
SOURCE=$(wildcard *.cc)
HEADERS=$(wildcard *.hh *.hxx)

4
Makefile.conf
View File

@ -32,11 +32,11 @@ else
CXXFLAGS+=-DNDEBUG=1
endif
# Defaults
######### Engine #########
ENGINE_LIB_PATH=$(HOME)/lib
ENGINE_INC_PATH=$(HOME)/include
# Config File
######### Overrides #########
-include $(HERE)/local.conf
# Add -L Prefixes to LIB/INC paths,

5
test/Makefile
View File

@ -6,7 +6,7 @@ CXXFLAGS+=-I../
.PHONY=all, test_adapter, test_adapter_cxx, test_library
all: test_adapter test_adapter_cxx test_library test_peplog
all: test_adapter test_adapter_cxx test_library
test_adapter: test_adapter.cc ../libpEpAdapter.a
@ -14,9 +14,6 @@ test_adapter_cxx: test_adapter_cxx.cc ../libpEpAdapter.a
test_library: test_library.cc ../libpEpAdapter.a
test_peplog: test_peplog.cc
clean:
rm -vf test_adapter
rm -rvf test_adapter.dSYM

16
test/test_adapter.cc
View File

@ -1,25 +1,24 @@
// This file is under GNU General Public License 3.0
// see LICENSE.txt
#include "Adapter.hh"
#include <iostream>
#include <assert.h>
#include <unistd.h>
#include <pEp/keymanagement.h>
#include "Adapter.hh"
#include "../utils.hh"
using namespace std;
using namespace pEp::Adapter;
PEP_STATUS messageToSend(struct _message *msg)
{
pEpLog("called");
pEpLog("called()");
return PEP_STATUS_OK;
}
PEP_STATUS notifyHandshake(pEp_identity *me, pEp_identity *partner, sync_handshake_signal signal)
{
pEpLog("called");
pEpLog("called()");
return PEP_STATUS_OK;
}
@ -34,16 +33,17 @@ int main()
pEp::throw_status(status);
// start and stop sync repeatedly
useconds_t sleepuSec = 1000 * 1000;
unsigned long long int nrIters = 3;//1000 * 1000 * 1000;
useconds_t sleepuSec = 1000 * 100;
unsigned long long int nrIters = 1000 * 1000 * 1000;
for (int i = 0; i < nrIters; i++) {
pEpLog("RUN NR: " << i);
pEpLog("RUN NR: ");
pEpLog(i);
pEpLog("SYNC START");
pEpLog("starting the adapter including sync");
startup(messageToSend, notifyHandshake);
pEpLog("SYNC STOP");
usleep(sleepuSec);
shutdown();
usleep(sleepuSec);
}
return 0;
}

3
test/test_adapter_cxx.cc
View File

@ -1,12 +1,11 @@
// This file is under GNU General Public License 3.0
// see LICENSE.txt
#include "Adapter.hh"
#include <iostream>
#include <assert.h>
#include <unistd.h>
#include <pEp/keymanagement.h>
#include "Adapter.hh"
#include "../utils.hh"
using namespace pEp::Adapter;

16
test/test_peplog.cc
View File

@ -1,16 +0,0 @@
// This file is under GNU General Public License 3.0
// see LICENSE.txt
#include "utils.hh"
// Single threaded test of pEpLog() function.
// check for uniformity of time
int main()
{
pEpLog("Test Starting... observe uniformity of timestamp.");
int nr_log_lines = 1000000;
for (int i; i < nr_log_lines; i++) {
pEpLog("log line nr: " << i);
}
return 0;
}

42
utils.hh
View File

@ -1,42 +0,0 @@
#pragma once
#include <iostream>
#include <thread>
#include <sstream>
#include <iomanip>
// Returns a timestamp string featuring microseconds precision
// Uses system clock, so time might not pass uniformly
inline std::string timestamp_usec() {
std::ostringstream buffer;
std::chrono::system_clock::duration d = std::chrono::system_clock::now().time_since_epoch();
std::chrono::microseconds us = std::chrono::duration_cast<std::chrono::microseconds>(d);
std::chrono::seconds s = std::chrono::duration_cast<std::chrono::seconds> (d);
std::time_t t = s.count();
std::tm tm = *std::localtime(&t);
std::size_t fractional_seconds = us.count() % 1000000;
buffer << std::put_time(&tm, "%H%:%M:%S") << "." << fractional_seconds;
return buffer.str();
}
// pEpLog(msg) - logs to STDOUT
// pEpErr(msg) - logs to STDERR
//
// Log format is:
// TIMESTAMP.usecs THREAD-ID SRC_FILE_NAME::FUNCTION_NAME - msg
//
// example:
// 21:06:04.214884 Thread:0x10f2ce5c0 test_peplog.cc::main - test run nr: 436744
//
// if -DNDEBUG=1 (for release builds), all pEpLog() calls will be optimized away.
#ifdef NDEBUG
#define pEpLog(msg) do{}while(0)
#else
#define pEpLog(msg) do{ std::cout << std::unitbuf; std::cout << timestamp_usec() << " Thread:" << std::this_thread::get_id() << ' ' <<__FILE__ << "::" << __FUNCTION__ << " - " << msg << std::endl;} while(0)
#endif
#define pEpErr(msg) do{ std::cerr << std::unitbuf; std::cerr << timestamp_usec() << " Thread:" << std::this_thread::get_id() << ' ' <<__FILE__ << "::" << __FUNCTION__ << " - " << msg << std::endl;} while(0)
Write Preview
Loading…
Cancel
Save