int main(int argc, char **argv)
{
natsConnection *conn = NULL;
natsOptions *opts = NULL;
natsSubscription *sub = NULL;
natsStatus s;
opts = parseArgs(argc, argv, usage);
printf("Listening asynchronously on '%s' with a timeout of %d ms.\n",
subj, (int) timeout);
s = natsConnection_Connect(&conn, opts);
if (s == NATS_OK)
{
if (name != NULL)
s = natsConnection_QueueSubscribeTimeout(&sub, conn, subj, name,
timeout, onMsg, NULL);
else
s = natsConnection_SubscribeTimeout(&sub, conn, subj,
timeout, onMsg, NULL);
}
// Check every half a second for end of test.
while ((s == NATS_OK) && !done)
{
nats_Sleep(500);
}
if (s != NATS_OK)
{
printf("Error: %d - %s\n", s, natsStatus_GetText(s));
nats_PrintLastErrorStack(stderr);
}
// Destroy all our objects to avoid report of memory leak
// Do not destroy subscription since it is done in the callback
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;
struct event_base *evLoop= NULL;
nats_Open(-1);
opts = parseArgs(argc, argv, usage);
printf("Listening on '%s'.\n", 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)
s = natsConnection_Subscribe(&sub, conn, subj, onMsg, NULL);
// For maximum performance, set no limit on the number of pending messages.
if (s == NATS_OK)
s = natsSubscription_SetPendingLimits(sub, -1, -1);
// Run the event loop.
// This call will return when the connection is closed (either after
// receiving all messages, or disconnected and unable to reconnect).
if (s == NATS_OK)
event_base_dispatch(evLoop);
if (s == NATS_OK)
{
printPerf("Received", 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;
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;
}
