ARXClientTest::~ARXClientTest()
{
if (mArx) {
mArx->destroy();
}
delete mCamRend[0];
delete mCamRend[1];
delete mPropL;
event_deinit(&mDoneEvt);
}
static void
core_ctx_destroy(struct context *ctx)
{
log_debug(LOG_VVERB, "destroy ctx %p id %"PRIu32"", ctx, ctx->id);
proxy_deinit(ctx);
server_pool_disconnect(ctx);
event_deinit(ctx);
stats_destroy(ctx->stats);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
nc_free(ctx);
}
void thread_main_func_translate(uint32_t argc, void* argv)
{
thread_t sosal_thread_hdl = argv;
/* Run client main func */
sosal_thread_hdl->exit_code = sosal_thread_hdl->client_func(sosal_thread_hdl->client_arg);
sosal_thread_hdl->bTaskReady = true_e;
#ifdef JOIN_SEMAPHORE
{
semaphore_t *semaphore_hdl;
semaphore_hdl = sosal_thread_hdl->join_semaphore;
SOSAL_PRINT(SOSAL_ZONE_THREAD, "thread_main_func_translate semaphore post (%d)\n", sosal_thread_hdl->join_number);
while(sosal_thread_hdl->join_number) {
semaphore_post(semaphore_hdl); /* signal next join task in the queue to continue */
sosal_thread_hdl->join_number--;
}
SOSAL_PRINT(SOSAL_ZONE_THREAD, "thread_main_func_translate semaphore delete (%d)\n", sosal_thread_hdl->join_number);
semaphore_delete(semaphore_hdl);
mutex_deinit(sosal_thread_hdl->join_mutex);
}
/* extra task memory releasing */
free(sosal_thread_hdl->join_semaphore);
sosal_thread_hdl->join_semaphore = NULL;
free(sosal_thread_hdl->join_mutex);
#else
/* Event mode signaling */
//SOSAL_PRINT(SOSAL_ZONE_THREAD, "thread_main_func_translate send ready event\n");
event_set(sosal_thread_hdl->exit_event);
// Wait all task to receive join event
while (sosal_thread_hdl->pAckList) {
ack_t *pAck;
pAck = sosal_thread_hdl->pAckList;
//SOSAL_PRINT(SOSAL_ZONE_THREAD, "thread_main_func_translate waits for ack\n");
event_wait(pAck->exit_event_ack, EVENT_FOREVER);
SOSAL_PRINT(SOSAL_ZONE_THREAD, "thread_main_func_translate ack received\n");
sosal_thread_hdl->pAckList = pAck->next;
sosal_free_ack(pAck);
}
event_deinit(sosal_thread_hdl->exit_event);
//SOSAL_PRINT(SOSAL_ZONE_THREAD, "thread_main_func_translate event deinited\n");
/* extra task memory releasing */
free(sosal_thread_hdl->exit_event);
#endif
free(sosal_thread_hdl);
sosal_thread_hdl = NULL;
SOSAL_PRINT(SOSAL_ZONE_THREAD, "thread_main_func_translate clean up\n");
}
static struct context *
core_ctx_create(struct instance *nci)
{
rstatus_t status;
struct context *ctx;
struct conn *sentinel_conn;
ctx = nc_alloc(sizeof(*ctx));
if (ctx == NULL) {
return NULL;
}
ctx->id = ++ctx_id;
ctx->cf = NULL;
ctx->stats = NULL;
array_null(&ctx->pool);
ctx->ep = -1;
ctx->nevent = EVENT_SIZE_HINT;
ctx->max_timeout = nci->stats_interval;
ctx->timeout = ctx->max_timeout;
ctx->event = NULL;
ctx->server_reconnect_interval = nci->server_reconnect_interval;
ctx->whitelist = nci->whitelist;
/* parse and create configuration */
ctx->cf = conf_create(nci->conf_filename);
if (ctx->cf == NULL) {
nc_free(ctx);
return NULL;
}
/* initialize server pool from configuration */
status = server_pool_init(&ctx->pool, &ctx->cf->pool, ctx);
if (status != NC_OK) {
conf_destroy(ctx->cf);
nc_free(ctx);
return NULL;
}
/* initialize sentinel server */
ctx->sentinel = sentinel_init(nci->sentinel_port, nci->sentinel_addr);
if (ctx->sentinel == NULL) {
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
nc_free(ctx);
return NULL;
}
/* create stats per server pool */
ctx->stats = stats_create(nci->stats_port, nci->stats_addr, nci->stats_interval,
nci->hostname, &ctx->pool);
if (ctx->stats == NULL) {
sentinel_deinit(ctx->sentinel);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
nc_free(ctx);
return NULL;
}
/* initialize event handling for client, proxy and server */
status = event_init(ctx, EVENT_SIZE_HINT);
if (status != NC_OK) {
stats_destroy(ctx->stats);
sentinel_deinit(ctx->sentinel);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
nc_free(ctx);
return NULL;
}
/* preconnect? servers in server pool */
status = server_pool_preconnect(ctx);
if (status != NC_OK) {
server_pool_disconnect(ctx);
event_deinit(ctx);
stats_destroy(ctx->stats);
sentinel_deinit(ctx->sentinel);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
nc_free(ctx);
return NULL;
}
/* initialize sentinel server conn */
sentinel_conn = sentinel_connect(ctx);
if (sentinel_conn == NULL) {
server_pool_disconnect(ctx);
event_deinit(ctx);
stats_destroy(ctx->stats);
sentinel_deinit(ctx->sentinel);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
nc_free(ctx);
}
/* initialize proxy per server pool */
status = proxy_init(ctx);
if (status != NC_OK) {
sentinel_conn->close(ctx, sentinel_conn);
server_pool_disconnect(ctx);
event_deinit(ctx);
stats_destroy(ctx->stats);
sentinel_deinit(ctx->sentinel);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
nc_free(ctx);
return NULL;
}
log_debug(LOG_VVERB, "created ctx %p id %"PRIu32"", ctx, ctx->id);
return ctx;
}
bool_e thread_unittest(int argc, char *argv[])
{
uint32_t i, counter = 10;
pingpongevent_t events;
int numErrors = 0;
bool_e verbose = false_e;
option_t hash_opts[] = {
{OPTION_TYPE_BOOL, &verbose, sizeof(bool_e), "-v", "--verbose", "Used to print out debugging information"},
};
msg_t msgs[] = {{3}, {9283}, {27}, {42}}; // last value == TEST_RET_VALUE
msg_thread_t msgt;
thread_t t;
thread_ret_t r;
option_process(argc, argv, hash_opts, dimof(hash_opts));
if (verbose) {
SOSAL_PRINT(SOSAL_ZONE_THREAD, "===THREAD TEST===\n");
}
// simple start, stop test
t = thread_create(thread_test, &counter);
r = thread_join(t);
if (r != TEST_RET_VALUE)
numErrors++;
if (verbose) {
SOSAL_PRINT(SOSAL_ZONE_THREAD, "===PING PONG TEST===\n");
}
// event test across threads
event_init(&events.ping, false_e);
event_init(&events.pong, false_e);
t = thread_create(thread_test_events, &events);
if (verbose) {
SOSAL_PRINT(SOSAL_ZONE_THREAD, "Test is waiting for thread to wakeup!\n");
}
if (event_wait(&events.ping, 500))
{
if (verbose)
SOSAL_PRINT(SOSAL_ZONE_THREAD, "Received Event from Thread!\n");
}
else
{
if (verbose)
SOSAL_PRINT(SOSAL_ZONE_THREAD, "ERROR! Thread Message Timedout!\n");
}
if (verbose) SOSAL_PRINT(SOSAL_ZONE_THREAD, "Sending Event to Thread!\n");
event_set(&events.pong);
r = thread_join(t);
SOSAL_PRINT(SOSAL_ZONE_THREAD, "=== THREAD JOIN exit = "THREAD_RET_FMT" ===\n", r);
if (r != TEST_RET_VALUE)
numErrors++;
event_deinit(&events.ping);
event_deinit(&events.pong);
if (verbose) {
SOSAL_PRINT(SOSAL_ZONE_THREAD, "===QUEUE TEST===\n");
}
msgt.msgs = queue_create(2, sizeof(msg_t));
msgt.running = true_e;
event_init(&msgt.signal, false_e);
t = thread_create(thread_test_msgs, &msgt);
if (verbose)
{
SOSAL_PRINT(SOSAL_ZONE_THREAD, "Waiting for thread to start!\n");
SOSAL_PRINT(SOSAL_ZONE_THREAD, "Thread Started?(%s!)\n", (event_wait(&msgt.signal, 1000)?"true":"false"));
}
for (i = 0; i < dimof(msgs); i++) {
if (queue_write(msgt.msgs, true_e, &msgs[i]) == false_e) {
SOSAL_PRINT(SOSAL_ZONE_ERROR, "ERROR! Failed to write to queue!\n");
} else {
if (verbose) SOSAL_PRINT(SOSAL_ZONE_THREAD, "Wrote message "FMT_SIZE_T" to the Queue!\n", msgs[i].code);
}
}
r = thread_join(t);
SOSAL_PRINT(SOSAL_ZONE_THREAD, "=== THREAD JOIN exit = "THREAD_RET_FMT" ===\n", r);
queue_destroy(msgt.msgs);
event_deinit(&msgt.signal);
if (verbose) {
SOSAL_PRINT(SOSAL_ZONE_THREAD, "===THREAD TEST EXIT Errors=%d ===\n", numErrors);
}
if (numErrors > 0)
return false_e;
else
return true_e;
}
