ffi-nats-core 0.3.0 → 0.3.1

data/vendor/cnats/examples/publisher.c

@@ -0,0 +1,62 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+#include "examples.h"
+
+static const char *usage = ""\
+"-txt           text to send (default is 'hello')\n" \
+"-count         number of messages to send\n";
+
+int main(int argc, char **argv)
+{
+    natsConnection  *conn  = NULL;
+    natsStatistics  *stats = NULL;
+    natsOptions     *opts  = NULL;
+    int64_t         last   = 0;
+    natsStatus      s;
+
+    opts = parseArgs(argc, argv, usage);
+
+    printf("Sending %" PRId64 " messages to subject '%s'\n", total, subj);
+
+    s = natsConnection_Connect(&conn, opts);
+
+    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);
+            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));
+        nats_PrintLastErrorStack(stderr);
+    }
+
+    // Destroy all our objects to avoid report of memory leak
+    natsStatistics_Destroy(stats);
+    natsConnection_Destroy(conn);
+    natsOptions_Destroy(opts);
+
+    // To silence reports of memory still in used with valgrind
+    nats_Close();
+
+    return 0;
+}

data/vendor/cnats/examples/queuegroup.c

@@ -0,0 +1,132 @@
+// Copyright 2015-2016 Apcera Inc. All rights reserved.
+
+#include "examples.h"
+
+static const char *usage = "" \
+"-gd            use global message delivery thread pool\n" \
+"-name          queue name (default is 'worker')\n" \
+"-count         number of expected messages\n";
+
+static void
+onMsg(natsConnection *nc, natsSubscription *sub, natsMsg *msg, void *closure)
+{
+    // If 'print' is on, the server is likely to break the connection
+    // since the client library will become a slow consumer.
+    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);
+}
+
+static void
+asyncCb(natsConnection *nc, natsSubscription *sub, natsStatus err, void *closure)
+{
+    printf("Async error: %d - %s\n", err, natsStatus_GetText(err));
+}
+
+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;
+}

data/vendor/cnats/examples/replier.c

@@ -0,0 +1,149 @@
+// Copyright 2015-2016 Apcera Inc. All rights reserved.
+
+#include "examples.h"
+
+static const char *usage = "" \
+"-gd            use global message delivery thread pool\n" \
+"-sync          receive synchronously (default is asynchronous)\n" \
+"-count         number of expected requests\n";
+
+static void
+onMsg(natsConnection *nc, natsSubscription *sub, natsMsg *msg, void *closure)
+{
+    natsStatus s;
+
+    if (print)
+        printf("Received msg: %s - %.*s\n",
+               natsMsg_GetSubject(msg),
+               natsMsg_GetDataLength(msg),
+               natsMsg_GetData(msg));
+
+    if (start == 0)
+        start = nats_Now();
+
+    s = natsConnection_PublishString(nc, natsMsg_GetReply(msg),
+                                     "here's some help");
+    if (s == NATS_OK)
+        s = natsConnection_Flush(nc);
+
+    // 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);
+}
+
+static void
+asyncCb(natsConnection *nc, natsSubscription *sub, natsStatus err, void *closure)
+{
+    if (print)
+        printf("Async error: %d - %s\n", err, natsStatus_GetText(err));
+
+    natsSubscription_GetDropped(sub, (int64_t*) &dropped);
+}
+
+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 for requests on '%s'\n",
+           (async ? "a" : ""), subj);
+
+    s = natsOptions_SetErrorHandler(opts, asyncCb, NULL);
+
+    if (s == NATS_OK)
+        s = natsConnection_Connect(&conn, opts);
+
+    if (s == NATS_OK)
+    {
+        if (async)
+            s = natsConnection_Subscribe(&sub, conn, subj, onMsg, NULL);
+        else
+            s = natsConnection_SubscribeSync(&sub, conn, subj);
+    }
+
+    // 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 + dropped == 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)
+                s = natsConnection_PublishString(conn,
+                                                 natsMsg_GetReply(msg),
+                                                 "here's some help");
+            if (s == NATS_OK)
+                s = natsConnection_Flush(conn);
+            if (s == NATS_OK)
+            {
+                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)
+            s = natsConnection_FlushTimeout(conn, 1000);
+    }
+
+    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
+    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;
+}

data/vendor/cnats/examples/requestor.c

@@ -0,0 +1,75 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+#include "examples.h"
+
+static const char *usage = "" \
+"-txt           text to send (default is 'hello')\n" \
+"-count         number of requests to send\n";
+
+int main(int argc, char **argv)
+{
+    natsConnection  *conn  = NULL;
+    natsStatistics  *stats = NULL;
+    natsOptions     *opts  = NULL;
+    natsMsg         *reply = NULL;
+    int64_t         last   = 0;
+    natsStatus      s;
+
+    opts = parseArgs(argc, argv, usage);
+
+    printf("Sending %" PRId64 " requests to subject '%s'\n", total, subj);
+
+    s = natsConnection_Connect(&conn, opts);
+
+    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_RequestString(&reply, conn, subj, txt, 1000);
+        if (s != NATS_OK)
+            break;
+
+        if (print)
+        {
+            printf("Received reply: %s - %.*s\n",
+                   natsMsg_GetSubject(reply),
+                   natsMsg_GetDataLength(reply),
+                   natsMsg_GetData(reply));
+        }
+
+        if (nats_Now() - last >= 1000)
+        {
+            s = printStats(STATS_OUT,conn, NULL, stats);
+            last = nats_Now();
+        }
+
+        natsMsg_Destroy(reply);
+    }
+
+    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));
+        nats_PrintLastErrorStack(stderr);
+    }
+
+    // Destroy all our objects to avoid report of memory leak
+    natsStatistics_Destroy(stats);
+    natsConnection_Destroy(conn);
+    natsOptions_Destroy(opts);
+
+    // To silence reports of memory still in used with valgrind
+    nats_Close();
+
+    return 0;
+}

data/vendor/cnats/examples/subscriber.c

@@ -0,0 +1,133 @@
+// Copyright 2015-2016 Apcera Inc. All rights reserved.
+
+#include "examples.h"
+
+static const char *usage = ""\
+"-gd            use global message delivery thread pool\n" \
+"-sync          receive synchronously (default is asynchronous)\n" \
+"-count         number of expected messages\n";
+
+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);
+}
+
+static void
+asyncCb(natsConnection *nc, natsSubscription *sub, natsStatus err, void *closure)
+{
+    if (print)
+        printf("Async error: %d - %s\n", err, natsStatus_GetText(err));
+
+    natsSubscription_GetDropped(sub, (int64_t*) &dropped);
+}
+
+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'.\n",
+           (async ? "a" : ""), subj);
+
+    s = natsOptions_SetErrorHandler(opts, asyncCb, NULL);
+
+    if (s == NATS_OK)
+        s = natsConnection_Connect(&conn, opts);
+
+    if (s == NATS_OK)
+    {
+        if (async)
+            s = natsConnection_Subscribe(&sub, conn, subj, onMsg, NULL);
+        else
+            s = natsConnection_SubscribeSync(&sub, conn, subj);
+    }
+
+    // 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 + dropped == 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", 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
+    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;
+}