ffi-nats-core 0.3.0 → 0.3.1

data/vendor/cnats/examples/CMakeLists.txt

@@ -0,0 +1,56 @@
+# We need this directory to build the examples
+include_directories(${PROJECT_SOURCE_DIR}/src)
+include_directories(${PROJECT_SOURCE_DIR}/examples)
+
+if(NATS_BUILD_LIBUV_EXAMPLE)
+  include_directories(${LIBUV_DIR}/include)
+endif()
+
+if(NATS_BUILD_LIBEVENT_EXAMPLE)
+  include_directories(${LIBEVENT_DIR}/include)
+endif()
+
+if(WIN32)
+  set(LIB_SUFFIX ${CMAKE_STATIC_LIBRARY_SUFFIX})
+else()
+  set(LIB_SUFFIX ${CMAKE_SHARED_LIBRARY_SUFFIX})
+endif()
+
+# Get all the .c files in the examples directory
+file(GLOB EXAMPLES_SOURCES RELATIVE ${PROJECT_SOURCE_DIR}/examples *.c)
+
+add_definitions(-Dnats_IMPORTS)
+
+# For each file...
+foreach(examples_src ${EXAMPLES_SOURCES})
+
+    # Remove the suffix so that it becomes the executable name
+    string(REPLACE ".c" "" examplename ${examples_src})
+    set(exampleexe "nats-${examplename}")
+
+    set(buildExample OFF)
+    set(NATS_ASYNC_IO_LIB "")
+
+    if(examplename MATCHES "libuv")
+      if(NATS_BUILD_LIBUV_EXAMPLE)
+        set(buildExample ON)
+        set(NATS_ASYNC_IO_LIB ${LIBUV_DIR}/lib/libuv${LIB_SUFFIX})
+      endif()
+    elseif(examplename MATCHES "libevent")
+      if(NATS_BUILD_LIBEVENT_EXAMPLE)
+        set(buildExample ON)
+        set(NATS_ASYNC_IO_LIB ${LIBEVENT_DIR}/lib/libevent${LIB_SUFFIX})
+      endif()
+    else()
+      set(buildExample ON)
+    endif()
+
+    if(buildExample)
+      # Build the executable
+      add_executable(${exampleexe} ${PROJECT_SOURCE_DIR}/examples/${examples_src})
+
+      # Link dynamically
+      target_link_libraries(${exampleexe} nats ${NATS_EXTRA_LIB} ${NATS_ASYNC_IO_LIB})
+    endif()
+
+endforeach()

data/vendor/cnats/examples/asynctimeout.c

@@ -0,0 +1,83 @@
+// Copyright 2015-2016 Apcera Inc. All rights reserved.
+
+#include "examples.h"
+
+static const char *usage = ""\
+"-gd            use global message delivery thread pool\n" \
+"-queue         use a queue subscriber with this name\n" \
+"-timeout <ms>  timeout in milliseconds (default is 10sec)\n" \
+"-count         number of expected messages\n";
+
+static volatile bool done = false;
+
+static void
+onMsg(natsConnection *nc, natsSubscription *sub, natsMsg *msg, void *closure)
+{
+    // This callback will be invoked with a NULL message when the
+    // subscription times out.
+    if (print && (msg != NULL))
+        printf("Received msg: %s - %.*s\n",
+               natsMsg_GetSubject(msg),
+               natsMsg_GetDataLength(msg),
+               natsMsg_GetData(msg));
+
+    // 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 ((msg == NULL) || (++count == total))
+    {
+        printf("%s, destroying subscription\n",
+               (msg == NULL ? "Subscription timed-out" : "All messages received"));
+
+        natsSubscription_Destroy(sub);
+        done = true;
+    }
+
+    // It is safe to call natsMsg_Destroy() with a NULL message.
+    natsMsg_Destroy(msg);
+}
+
+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;
+}

data/vendor/cnats/examples/examples.h

@@ -0,0 +1,322 @@
+// Copyright 2015-2016 Apcera Inc. All rights reserved.
+
+
+#ifndef EXAMPLES_H_
+#define EXAMPLES_H_
+
+#include <nats.h>
+#include <stdio.h>
+#include <string.h>
+
+#ifdef _WIN32
+#define strcasecmp  _stricmp
+#define strdup      _strdup
+#else
+#ifndef NATS_LIBUV_INCLUDE
+extern char *strdup(const char *s);
+#endif
+#include <strings.h>
+#endif
+
+#define STATS_IN        0x1
+#define STATS_OUT       0x2
+#define STATS_COUNT     0x4
+
+#define MAX_SERVERS     (10)
+
+bool        async   = true;
+const char  *subj   = "foo";
+const char  *txt    = "hello";
+const char  *name   = "worker";
+int64_t     total   = 1000000;
+
+volatile int64_t count   = 0;
+volatile int64_t dropped = 0;
+int64_t          start   = 0;
+volatile int64_t elapsed = 0;
+bool             print   = false;
+int64_t          timeout = 10000; // 10 seconds.
+
+natsOptions      *opts   = NULL;
+
+const char       *certFile = NULL;
+const char       *keyFile  = NULL;
+
+static natsStatus
+printStats(int mode, natsConnection *conn, natsSubscription *sub,
+           natsStatistics *stats)
+{
+    natsStatus  s = NATS_OK;
+    uint64_t    inMsgs, inBytes, outMsgs, outBytes, reconnected;
+    int         pending = 0;
+    int64_t     delivered, dropped = 0;
+
+    s = natsConnection_GetStats(conn, stats);
+    if (s == NATS_OK)
+        s = natsStatistics_GetCounts(stats, &inMsgs, &inBytes,
+                                     &outMsgs, &outBytes, &reconnected);
+    if ((s == NATS_OK) && (sub != NULL))
+    {
+        s = natsSubscription_GetStats(sub, &pending, NULL, NULL, NULL,
+                                      &delivered, &dropped);
+
+        // Since we use AutoUnsubscribe(), when the max has been reached,
+        // the subscription is automatically closed, so this call would
+        // return "Invalid Subscription". Ignore this error.
+        if (s == NATS_INVALID_SUBSCRIPTION)
+        {
+            s = NATS_OK;
+            pending = 0;
+        }
+    }
+
+    if (s == NATS_OK)
+    {
+        if (mode & STATS_IN)
+        {
+            printf("In Msgs: %9" PRIu64 " - "\
+                   "In Bytes: %9" PRIu64 " - ", inMsgs, inBytes);
+        }
+        if (mode & STATS_OUT)
+        {
+            printf("Out Msgs: %9" PRIu64 " - "\
+                   "Out Bytes: %9" PRIu64 " - ", outMsgs, outBytes);
+        }
+        if (mode & STATS_COUNT)
+        {
+            printf("Delivered: %9" PRId64 " - ", delivered);
+            printf("Pending: %5d - ", pending);
+            printf("Dropped: %5" PRId64 " - ", dropped);
+        }
+        printf("Reconnected: %3" PRIu64 "\n", reconnected);
+    }
+
+    return s;
+}
+
+static void
+printPerf(const char *txt, int64_t count, int64_t start, int64_t elapsed)
+{
+    if ((start > 0) && (elapsed == 0))
+        elapsed = nats_Now() - start;
+
+    if (elapsed <= 0)
+        printf("\nNot enough messages or too fast to report performance!\n");
+    else
+        printf("\n%s %" PRId64 " messages in "\
+               "%" PRId64 " milliseconds (%d msgs/sec)\n",
+               txt, count, elapsed, (int)((count * 1000) / elapsed));
+}
+
+static void
+printUsageAndExit(const char *progName, const char *usage)
+{
+    printf("\nUsage: %s [options]\n\nThe options are:\n\n"\
+"-h             prints the usage\n" \
+"-s             server url(s) (list of comma separated nats urls)\n" \
+"-tls           use secure (SSL/TLS) connection\n" \
+"-tlscacert     trusted certificates file\n" \
+"-tlscert       client certificate (PEM format only)\n" \
+"-tlskey        client private key file (PEM format only)\n" \
+"-tlsciphers    ciphers suite\n"
+"-tlshost       server certificate's expected hostname\n" \
+"-tlsskip       skip server certificate verification\n" \
+"-subj          subject (default is 'foo')\n" \
+                "%s\n",
+                progName, usage);
+
+    natsOptions_Destroy(opts);
+    nats_Close();
+
+    exit(1);
+}
+
+static natsStatus
+parseUrls(const char *urls, natsOptions *opts)
+{
+    char        *serverUrls[MAX_SERVERS];
+    int         count     = 0;
+    natsStatus  s         = NATS_OK;
+    char        *urlsCopy = NULL;
+    char        *commaPos = NULL;
+    char        *ptr      = NULL;
+
+    urlsCopy = strdup(urls);
+    if (urlsCopy == NULL)
+        return NATS_NO_MEMORY;
+
+    memset(serverUrls, 0, sizeof(serverUrls));
+
+    ptr = urlsCopy;
+
+    do
+    {
+        if (count == MAX_SERVERS)
+        {
+            s = NATS_INSUFFICIENT_BUFFER;
+            break;
+        }
+
+        serverUrls[count++] = ptr;
+        commaPos = strchr(ptr, ',');
+        if (commaPos != NULL)
+        {
+            ptr = (char*)(commaPos + 1);
+            *(commaPos) = '\0';
+        }
+        else
+        {
+            ptr = NULL;
+        }
+    } while (ptr != NULL);
+
+    if (s == NATS_OK)
+        s = natsOptions_SetServers(opts, (const char**) serverUrls, count);
+
+    free(urlsCopy);
+
+    return s;
+}
+
+static natsOptions*
+parseArgs(int argc, char **argv, const char *usage)
+{
+    natsStatus  s       = NATS_OK;
+    bool        urlsSet = false;
+    int         i;
+
+    if (natsOptions_Create(&opts) != NATS_OK)
+        s = NATS_NO_MEMORY;
+
+    for (i=1; (i<argc) && (s == NATS_OK); i++)
+    {
+        if ((strcasecmp(argv[i], "-h") == 0)
+            || (strcasecmp(argv[i], "-help") == 0))
+        {
+            printUsageAndExit(argv[0], usage);
+        }
+        else if (strcasecmp(argv[i], "-s") == 0)
+        {
+            if (i + 1 == argc)
+                printUsageAndExit(argv[0], usage);
+
+            s = parseUrls(argv[++i], opts);
+            if (s == NATS_OK)
+                urlsSet = true;
+        }
+        else if (strcasecmp(argv[i], "-tls") == 0)
+        {
+            s = natsOptions_SetSecure(opts, true);
+        }
+        else if (strcasecmp(argv[i], "-tlscacert") == 0)
+        {
+            if (i + 1 == argc)
+                printUsageAndExit(argv[0], usage);
+
+            s = natsOptions_LoadCATrustedCertificates(opts, argv[++i]);
+        }
+        else if (strcasecmp(argv[i], "-tlscert") == 0)
+        {
+            if (i + 1 == argc)
+                printUsageAndExit(argv[0], usage);
+
+            certFile = argv[++i];
+        }
+        else if (strcasecmp(argv[i], "-tlskey") == 0)
+        {
+            if (i + 1 == argc)
+                printUsageAndExit(argv[0], usage);
+
+            keyFile = argv[++i];
+        }
+        else if (strcasecmp(argv[i], "-tlsciphers") == 0)
+        {
+            if (i + 1 == argc)
+                printUsageAndExit(argv[0], usage);
+
+            s = natsOptions_SetCiphers(opts, argv[++i]);
+        }
+        else if (strcasecmp(argv[i], "-tlshost") == 0)
+        {
+            if (i + 1 == argc)
+                printUsageAndExit(argv[0], usage);
+
+            s = natsOptions_SetExpectedHostname(opts, argv[++i]);
+        }
+        else if (strcasecmp(argv[i], "-tlsskip") == 0)
+        {
+            s = natsOptions_SkipServerVerification(opts, true);
+        }
+        else if (strcasecmp(argv[i], "-sync") == 0)
+        {
+            async = false;
+        }
+        else if (strcasecmp(argv[i], "-subj") == 0)
+        {
+            if (i + 1 == argc)
+                printUsageAndExit(argv[0], usage);
+
+            subj = argv[++i];
+        }
+        else if ((strcasecmp(argv[i], "-name") == 0) ||
+                 (strcasecmp(argv[i], "-queue") == 0))
+        {
+            if (i + 1 == argc)
+                printUsageAndExit(argv[0], usage);
+
+            name = argv[++i];
+        }
+        else if (strcasecmp(argv[i], "-count") == 0)
+        {
+            if (i + 1 == argc)
+                printUsageAndExit(argv[0], usage);
+
+            total = atol(argv[++i]);
+        }
+        else if (strcasecmp(argv[i], "-txt") == 0)
+        {
+            if (i + 1 == argc)
+                printUsageAndExit(argv[0], usage);
+
+            txt = argv[++i];
+        }
+        else if (strcasecmp(argv[i], "-timeout") == 0)
+        {
+            if (i + 1 == argc)
+                printUsageAndExit(argv[0], usage);
+
+            timeout = atol(argv[++i]);
+        }
+        else if (strcasecmp(argv[i], "-gd") == 0)
+        {
+            s = natsOptions_UseGlobalMessageDelivery(opts, true);
+        }
+        else
+        {
+            printf("Unknown option: '%s'\n", argv[i]);
+            printUsageAndExit(argv[0], usage);
+        }
+    }
+
+    if ((s == NATS_OK) && ((certFile != NULL) || (keyFile != NULL)))
+        s = natsOptions_LoadCertificatesChain(opts, certFile, keyFile);
+
+    if ((s == NATS_OK) && !urlsSet)
+        s = parseUrls(NATS_DEFAULT_URL, opts);
+
+    if (s != NATS_OK)
+    {
+        printf("Error parsing arguments: %d - %s\n",
+               s, natsStatus_GetText(s));
+
+        nats_PrintLastErrorStack(stderr);
+
+        natsOptions_Destroy(opts);
+        nats_Close();
+        exit(1);
+    }
+
+    return opts;
+}
+
+#endif /* EXAMPLES_H_ */