static void
onMsg(natsConnection *nc, natsSubscription *sub, natsMsg *msg, void *closure)
{
if (print)
printf("Received msg: %s - %.*s\n",
natsMsg_GetSubject(msg),
natsMsg_GetDataLength(msg),
natsMsg_GetData(msg));
if (start == 0)
start = nats_Now();
// We should be using a mutex to protect those variables since
// they are used from the subscription's delivery and the main
// threads. For demo purposes, this is fine.
if (++count == total)
elapsed = nats_Now() - start;
natsMsg_Destroy(msg);
}
/*
* Return the next message available to a synchronous subscriber or block until
* one is available. A timeout can be used to return when no message has been
* delivered.
*/
natsStatus
natsSubscription_NextMsg(natsMsg **nextMsg, natsSubscription *sub, int64_t timeout)
{
natsStatus s = NATS_OK;
natsConnection *nc = NULL;
natsMsg *msg = NULL;
bool removeSub = false;
int64_t target = 0;
if ((sub == NULL) || (nextMsg == NULL))
return nats_setDefaultError(NATS_INVALID_ARG);
natsSub_Lock(sub);
if (sub->connClosed)
{
natsSub_Unlock(sub);
return nats_setDefaultError(NATS_CONNECTION_CLOSED);
}
if (sub->closed)
{
if ((sub->max > 0) && (sub->delivered >= sub->max))
s = NATS_MAX_DELIVERED_MSGS;
else
s = NATS_INVALID_SUBSCRIPTION;
natsSub_Unlock(sub);
return nats_setDefaultError(s);
}
if (sub->msgCb != NULL)
{
natsSub_Unlock(sub);
return nats_setDefaultError(NATS_ILLEGAL_STATE);
}
if (sub->slowConsumer)
{
sub->slowConsumer = false;
natsSub_Unlock(sub);
return nats_setDefaultError(NATS_SLOW_CONSUMER);
}
nc = sub->conn;
if (timeout > 0)
{
sub->inWait++;
while ((sub->msgList.msgs == 0)
&& (s != NATS_TIMEOUT)
&& !(sub->closed))
{
if (target == 0)
target = nats_Now() + timeout;
s = natsCondition_AbsoluteTimedWait(sub->cond, sub->mu, target);
if (s != NATS_OK)
s = nats_setDefaultError(s);
}
sub->inWait--;
if (sub->closed)
s = nats_setDefaultError(NATS_INVALID_SUBSCRIPTION);
}
else
{
s = (sub->msgList.msgs == 0 ? NATS_TIMEOUT : NATS_OK);
if (s != NATS_OK)
s = nats_setDefaultError(s);
}
if (s == NATS_OK)
{
msg = sub->msgList.head;
sub->msgList.head = msg->next;
if (sub->msgList.tail == msg)
sub->msgList.tail = NULL;
sub->msgList.msgs--;
sub->msgList.bytes -= msg->dataLen;
msg->next = NULL;
sub->delivered++;
if (sub->max > 0)
{
if (sub->delivered > sub->max)
s = nats_setDefaultError(NATS_MAX_DELIVERED_MSGS);
else if (sub->delivered == sub->max)
removeSub = true;
}
}
if (s == NATS_OK)
*nextMsg = msg;
natsSub_Unlock(sub);
if (removeSub)
natsConn_removeSubscription(nc, sub, true);
return NATS_UPDATE_ERR_STACK(s);
}
int main(int argc, char **argv)
{
natsConnection *conn = NULL;
natsOptions *opts = NULL;
natsSubscription *sub = NULL;
natsStatistics *stats = NULL;
natsMsg *msg = NULL;
natsStatus s;
opts = parseArgs(argc, argv, usage);
printf("Listening %ssynchronously on '%s' with name '%s'.\n",
(async ? "a" : ""), subj, name);
s = natsOptions_SetErrorHandler(opts, asyncCb, NULL);
if (s == NATS_OK)
s = natsConnection_Connect(&conn, opts);
if (s == NATS_OK)
{
if (async)
s = natsConnection_QueueSubscribe(&sub, conn, subj, name, onMsg, NULL);
else
s = natsConnection_QueueSubscribeSync(&sub, conn, subj, name);
}
// For maximum performance, set no limit on the number of pending messages.
if (s == NATS_OK)
s = natsSubscription_SetPendingLimits(sub, -1, -1);
if (s == NATS_OK)
s = natsSubscription_AutoUnsubscribe(sub, (int) total);
if (s == NATS_OK)
s = natsStatistics_Create(&stats);
if ((s == NATS_OK) && async)
{
while (s == NATS_OK)
{
s = printStats(STATS_IN|STATS_COUNT,conn, sub, stats);
if (count == total)
break;
if (s == NATS_OK)
nats_Sleep(1000);
}
}
else if (s == NATS_OK)
{
int64_t last = 0;
for (count = 0; (s == NATS_OK) && (count < total); count++)
{
s = natsSubscription_NextMsg(&msg, sub, 10000);
if (s != NATS_OK)
break;
if (start == 0)
start = nats_Now();
if (nats_Now() - last >= 1000)
{
s = printStats(STATS_IN|STATS_COUNT,conn, sub, stats);
last = nats_Now();
}
natsMsg_Destroy(msg);
}
}
if (s == NATS_OK)
{
printPerf("Received", total, start, elapsed);
}
else
{
printf("Error: %d - %s\n", s, natsStatus_GetText(s));
nats_PrintLastErrorStack(stderr);
}
// Destroy all our objects to avoid report of memory leak
natsStatistics_Destroy(stats);
natsSubscription_Destroy(sub);
natsConnection_Destroy(conn);
natsOptions_Destroy(opts);
// To silence reports of memory still in used with valgrind
nats_Close();
return 0;
}
int main(int argc, char **argv)
{
natsConnection *conn = NULL;
natsOptions *opts = NULL;
natsSubscription *sub = NULL;
natsStatus s = NATS_OK;
uv_loop_t *uvLoop= NULL;
uv_thread_t pub;
threadInfo info;
opts = parseArgs(argc, argv, usage);
printf("Sending %" PRId64 " messages to subject '%s'\n", total, subj);
// One time initialization of things that we need.
natsLibuv_Init();
// Create a loop.
uvLoop = uv_default_loop();
if (uvLoop != NULL)
{
// Libuv is not thread-safe. Almost all calls to libuv need to
// occur from the thread where the loop is running. NATS library
// may have to call into the event loop from different threads.
// This call allows natsLibuv APIs to know if they are executing
// from the event loop thread or not.
natsLibuv_SetThreadLocalLoop(uvLoop);
}
else
{
s = NATS_ERR;
}
// Indicate which loop and callbacks to use once connected.
if (s == NATS_OK)
s = natsOptions_SetEventLoop(opts, (void*) uvLoop,
natsLibuv_Attach,
natsLibuv_Read,
natsLibuv_Write,
natsLibuv_Detach);
if (s == NATS_OK)
s = natsConnection_Connect(&conn, opts);
if (s == NATS_OK)
start = nats_Now();
if (s == NATS_OK)
{
info.conn = conn;
info.status = NATS_OK;
if (uv_thread_create(&pub, pubThread, (void*) &info) != 0)
s = NATS_ERR;
}
if (s == NATS_OK)
{
uv_run(uvLoop, UV_RUN_DEFAULT);
uv_thread_join(&pub);
s = info.status;
}
if (s == NATS_OK)
{
printPerf("Sent", count, start, elapsed);
}
else
{
printf("Error: %d - %s\n", s, natsStatus_GetText(s));
nats_PrintLastErrorStack(stderr);
}
// Destroy all our objects to avoid report of memory leak
natsSubscription_Destroy(sub);
natsConnection_Destroy(conn);
natsOptions_Destroy(opts);
if (uvLoop != NULL)
uv_loop_close(uvLoop);
// To silence reports of memory still in used with valgrind
nats_Close();
return 0;
}
int main(int argc, char **argv)
{
natsConnection *conn = NULL;
natsOptions *opts = NULL;
natsSubscription *sub = NULL;
natsStatus s = NATS_OK;
struct event_base *evLoop= NULL;
THREAD_T pub;
threadInfo info;
nats_Open(-1);
opts = parseArgs(argc, argv, usage);
printf("Sending %" PRId64 " messages to subject '%s'\n", total, subj);
// One time initialization of things that we need.
natsLibevent_Init();
// Create a loop.
evLoop = event_base_new();
if (evLoop == NULL)
s = NATS_ERR;
// Indicate which loop and callbacks to use once connected.
if (s == NATS_OK)
s = natsOptions_SetEventLoop(opts, (void*) evLoop,
natsLibevent_Attach,
natsLibevent_Read,
natsLibevent_Write,
natsLibevent_Detach);
if (s == NATS_OK)
s = natsConnection_Connect(&conn, opts);
if (s == NATS_OK)
start = nats_Now();
if (s == NATS_OK)
{
info.conn = conn;
info.status = NATS_OK;
THREAD_START(pub, pubThread, (void*) &info);
}
if (s == NATS_OK)
{
event_base_dispatch(evLoop);
THREAD_JOIN(pub);
s = info.status;
}
if (s == NATS_OK)
{
printPerf("Sent", count, start, elapsed);
}
else
{
printf("Error: %d - %s\n", s, natsStatus_GetText(s));
nats_PrintLastErrorStack(stderr);
}
// Destroy all our objects to avoid report of memory leak
natsSubscription_Destroy(sub);
natsConnection_Destroy(conn);
natsOptions_Destroy(opts);
if (evLoop != NULL)
event_base_free(evLoop);
// To silence reports of memory still in used with valgrind
nats_Close();
libevent_global_shutdown();
return 0;
}
int main(int argc, char **argv)
{
natsConnection *conn = NULL;
natsStatistics *stats = NULL;
const char *subj = NULL;
const char *txt = NULL;
int64_t total = 0;
int64_t count = 0;
int64_t start = 0;
int64_t last = 0;
int64_t elapsed= 0;
natsStatus s;
if (argc != 4)
{
printf("Usage: %s <subject> <msg content> <count>\n", argv[0]);
exit(1);
}
subj = argv[1];
txt = argv[2];
total = atol(argv[3]);
printf("Sending %" PRId64 " messages to subject '%s'\n", total, subj);
s = natsConnection_ConnectTo(&conn, NATS_DEFAULT_URL);
if (s == NATS_OK)
s = natsStatistics_Create(&stats);
if (s == NATS_OK)
start = nats_Now();
for (count = 0; (s == NATS_OK) && (count < total); count++)
{
s = natsConnection_PublishString(conn, subj, txt);
if (nats_Now() - last >= 1000)
{
s = printStats(STATS_OUT, conn, NULL, stats, 0, 0);
last = nats_Now();
}
}
if (s == NATS_OK)
s = natsConnection_FlushTimeout(conn, 1000);
if (s == NATS_OK)
{
printPerf("Sent", total, start, elapsed);
}
else
{
printf("Error: %d - %s\n", s, natsStatus_GetText(s));
}
// Destroy all our objects to avoid report of memory leak
natsStatistics_Destroy(stats);
natsConnection_Destroy(conn);
// To silence reports of memory still in used with valgrind
nats_Close();
return 0;
}
