ffi-nats-core 0.3.0 → 0.3.1

data/vendor/cnats/src/parser.h

@@ -0,0 +1,87 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+#ifndef PARSER_H_
+#define PARSER_H_
+
+#include <stdint.h>
+
+//#include "natsp.h"
+#include "status.h"
+#include "buf.h"
+
+typedef enum
+{
+    OP_START = 0,
+    OP_PLUS,
+    OP_PLUS_O,
+    OP_PLUS_OK,
+    OP_MINUS,
+    OP_MINUS_E,
+    OP_MINUS_ER,
+    OP_MINUS_ERR,
+    OP_MINUS_ERR_SPC,
+    MINUS_ERR_ARG,
+    OP_M,
+    OP_MS,
+    OP_MSG,
+    OP_MSG_SPC,
+    MSG_ARG,
+    MSG_PAYLOAD,
+    MSG_END,
+    OP_P,
+    OP_PI,
+    OP_PIN,
+    OP_PING,
+    OP_PO,
+    OP_PON,
+    OP_PONG,
+    OP_I,
+    OP_IN,
+    OP_INF,
+    OP_INFO,
+    OP_INFO_SPC,
+    INFO_ARG
+
+} natsOp;
+
+typedef struct __natsMsgArg
+{
+    natsBuffer  subjectRec;
+    natsBuffer  *subject;
+    natsBuffer  replyRec;
+    natsBuffer  *reply;
+    int64_t     sid;
+    int         size;
+
+} natsMsgArg;
+
+#define MAX_CONTROL_LINE_SIZE   (1024)
+
+typedef struct __natsParser
+{
+    natsOp      state;
+    int         afterSpace;
+    int         drop;
+    natsMsgArg  ma;
+    natsBuffer  argBufRec;
+    natsBuffer  *argBuf;
+    natsBuffer  msgBufRec;
+    natsBuffer  *msgBuf;
+    char        scratch[MAX_CONTROL_LINE_SIZE];
+
+} natsParser;
+
+// This is defined in natsp.h, natsp.h includes us. Alternatively, we can move
+// all the parser defines in natsp.h
+struct __natsConnection;
+
+natsStatus
+natsParser_Create(natsParser **newParser);
+
+natsStatus
+natsParser_Parse(struct __natsConnection *nc, char *buf, int bufLen);
+
+void
+natsParser_Destroy(natsParser *parser);
+
+#endif /* PARSER_H_ */

data/vendor/cnats/src/pub.c

@@ -0,0 +1,293 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+#include "natsp.h"
+
+#include <string.h>
+
+#include "conn.h"
+#include "sub.h"
+#include "msg.h"
+#include "nuid.h"
+
+static const char *digits = "0123456789";
+
+#define _publish(n, s, r, d, l) _publishEx((n), (s), (r), (d), (l), false)
+
+// _publish is the internal function to publish messages to a nats server.
+// Sends a protocol data message by queueing into the bufio writer
+// and kicking the flusher thread. These writes should be protected.
+static natsStatus
+_publishEx(natsConnection *nc, const char *subj,
+         const char *reply, const void *data, int dataLen,
+         bool directFlush)
+{
+    natsStatus  s = NATS_OK;
+    int         msgHdSize = 0;
+    char        b[12];
+    int         bSize = sizeof(b);
+    int         i = bSize;
+    int         subjLen = 0;
+    int         replyLen = 0;
+    int         sizeSize = 0;
+
+    if (nc == NULL)
+        return nats_setDefaultError(NATS_INVALID_ARG);
+
+    if ((subj == NULL)
+        || ((subjLen = (int) strlen(subj)) == 0))
+    {
+        return nats_setDefaultError(NATS_INVALID_SUBJECT);
+    }
+
+    replyLen = ((reply != NULL) ? (int) strlen(reply) : 0);
+
+    natsConn_Lock(nc);
+
+    // Pro-actively reject dataLen over the threshold set by server.
+    if ((int64_t) dataLen > nc->info.maxPayload)
+    {
+        natsConn_Unlock(nc);
+
+        return nats_setError(NATS_MAX_PAYLOAD,
+                             "Payload %d greater than maximum allowed: %" PRId64,
+                             dataLen, nc->info.maxPayload);
+
+    }
+
+    if ((s == NATS_OK) && natsConn_isClosed(nc))
+    {
+        s = nats_setDefaultError(NATS_CONNECTION_CLOSED);
+    }
+
+    // Check if we are reconnecting, and if so check if
+    // we have exceeded our reconnect outbound buffer limits.
+    if ((s == NATS_OK) && natsConn_isReconnecting(nc))
+    {
+        // Flush to underlying buffer.
+        natsConn_bufferFlush(nc);
+
+        // Check if we are over
+        if (natsBuf_Len(nc->pending) >= nc->opts->reconnectBufSize)
+        {
+            natsConn_Unlock(nc);
+            return NATS_INSUFFICIENT_BUFFER;
+        }
+    }
+
+    if (s == NATS_OK)
+    {
+        if (dataLen > 0)
+        {
+            int l;
+
+            for (l = dataLen; l > 0; l /= 10)
+            {
+                i -= 1;
+                b[i] = digits[l%10];
+            }
+        }
+        else
+        {
+            i -= 1;
+            b[i] = digits[0];
+        }
+
+        sizeSize = (bSize - i);
+
+        msgHdSize = _PUB_P_LEN_
+                    + subjLen + 1
+                    + (replyLen > 0 ? replyLen + 1 : 0)
+                    + sizeSize + _CRLF_LEN_;
+
+        natsBuf_RewindTo(nc->scratch, _PUB_P_LEN_);
+
+        if (natsBuf_Capacity(nc->scratch) < msgHdSize)
+        {
+            // Although natsBuf_Append() would make sure that the buffer
+            // grows, it is better to make sure that the buffer is big
+            // enough for the pre-calculated size. We make it even a bit bigger.
+            s = natsBuf_Expand(nc->scratch, (int) ((float)msgHdSize * 1.1));
+        }
+    }
+
+    if (s == NATS_OK)
+        s = natsBuf_Append(nc->scratch, subj, subjLen);
+    if (s == NATS_OK)
+        s = natsBuf_Append(nc->scratch, _SPC_, _SPC_LEN_);
+    if ((s == NATS_OK) && (reply != NULL))
+    {
+        s = natsBuf_Append(nc->scratch, reply, replyLen);
+        if (s == NATS_OK)
+            s = natsBuf_Append(nc->scratch, _SPC_, _SPC_LEN_);
+    }
+    if (s == NATS_OK)
+        s = natsBuf_Append(nc->scratch, (b+i), sizeSize);
+    if (s == NATS_OK)
+        s = natsBuf_Append(nc->scratch, _CRLF_, _CRLF_LEN_);
+
+    if (s == NATS_OK)
+        s = natsConn_bufferWrite(nc, natsBuf_Data(nc->scratch), msgHdSize);
+
+    if (s == NATS_OK)
+        s = natsConn_bufferWrite(nc, data, dataLen);
+
+    if (s == NATS_OK)
+        s = natsConn_bufferWrite(nc, _CRLF_, _CRLF_LEN_);
+
+    if (s == NATS_OK)
+    {
+        if (directFlush)
+            s = natsConn_bufferFlush(nc);
+        else
+            natsConn_kickFlusher(nc);
+    }
+
+    if (s == NATS_OK)
+    {
+        nc->stats.outMsgs  += 1;
+        nc->stats.outBytes += dataLen;
+    }
+
+    natsConn_Unlock(nc);
+
+    return NATS_UPDATE_ERR_STACK(s);
+}
+
+/*
+ * Publishes the data argument to the given subject. The data argument is left
+ * untouched and needs to be correctly interpreted on the receiver.
+ */
+natsStatus
+natsConnection_Publish(natsConnection *nc, const char *subj,
+                       const void *data, int dataLen)
+{
+    natsStatus s = _publish(nc, subj, NULL, data, dataLen);
+
+    return NATS_UPDATE_ERR_STACK(s);
+}
+
+/*
+ * Convenient function to publish a string. This call is equivalent to:
+ *
+ * const char* myString = "hello";
+ *
+ * natsPublish(nc, subj, (const void*) myString, (int) strlen(myString));
+ */
+natsStatus
+natsConnection_PublishString(natsConnection *nc, const char *subj,
+                             const char *str)
+{
+    natsStatus s = _publish(nc, subj, NULL, (const void*) str,
+                            (str != NULL ? (int) strlen(str) : 0));
+
+    return NATS_UPDATE_ERR_STACK(s);
+}
+
+/*
+ * Publishes the natsMsg structure, which includes the subject, an optional
+ * reply and optional data.
+ */
+natsStatus
+natsConnection_PublishMsg(natsConnection *nc, natsMsg *msg)
+{
+    natsStatus s = _publish(nc, msg->subject, msg->reply,
+                            msg->data, msg->dataLen);
+
+    return NATS_UPDATE_ERR_STACK(s);
+}
+
+/*
+ * Publishes the data argument to the given subject expecting a response on
+ * the reply subject. Use natsConnection_Request() for automatically waiting for a
+ * response inline.
+ */
+natsStatus
+natsConnection_PublishRequest(natsConnection *nc, const char *subj,
+                              const char *reply, const void *data, int dataLen)
+{
+    natsStatus s;
+
+    if ((reply == NULL) || (strlen(reply) == 0))
+        return nats_setDefaultError(NATS_INVALID_ARG);
+
+    s = _publish(nc, subj, reply, data, dataLen);
+
+    return NATS_UPDATE_ERR_STACK(s);
+}
+
+/*
+ * Convenient function to publish a request as a string. This call is
+ * equivalent to:
+ *
+ * const char* myString = "hello";
+ *
+ * natsPublishRequest(nc, subj, reply, (const void*) myString,
+ *                    (int) strlen(myString));
+ */
+natsStatus
+natsConnection_PublishRequestString(natsConnection *nc, const char *subj,
+                                    const char *reply, const char *str)
+{
+    natsStatus s;
+
+    if ((reply == NULL) || (strlen(reply) == 0))
+        return nats_setDefaultError(NATS_INVALID_ARG);
+
+    s = _publish(nc, subj, reply, (const void*) str, (int) strlen(str));
+
+    return NATS_UPDATE_ERR_STACK(s);
+}
+
+/*
+ * Creates an inbox and performs a natsPublishRequest() call with the reply
+ * set to that inbox. Returns the first reply received.
+ * This is optimized for the case of multiple responses.
+ */
+natsStatus
+natsConnection_Request(natsMsg **replyMsg, natsConnection *nc, const char *subj,
+                       const void *data, int dataLen, int64_t timeout)
+{
+    natsStatus          s       = NATS_OK;
+    natsSubscription    *sub    = NULL;
+    char                inbox[NATS_INBOX_PRE_LEN + NUID_BUFFER_LEN + 1];
+
+    if (replyMsg == NULL)
+        return nats_setDefaultError(NATS_INVALID_ARG);
+
+    s = natsInbox_init(inbox, sizeof(inbox));
+    if (s == NATS_OK)
+        s = natsConn_subscribe(&sub, nc, inbox, NULL, 0, NULL, NULL);
+    if (s == NATS_OK)
+        s = natsSubscription_AutoUnsubscribe(sub, 1);
+    if (s == NATS_OK)
+        s = _publishEx(nc, subj, inbox, data, dataLen, true);
+    if (s == NATS_OK)
+        s = natsSubscription_NextMsg(replyMsg, sub, timeout);
+
+    natsSubscription_Destroy(sub);
+
+    return NATS_UPDATE_ERR_STACK(s);
+}
+
+/*
+ * Convenient function to send a request as a string. This call is
+ * equivalent to:
+ *
+ * const char* myString = "hello";
+ *
+ * natsConnection_Request(nc, subj, reply, (const void*) myString,
+ *                        (int) strlen(myString));
+ */
+natsStatus
+natsConnection_RequestString(natsMsg **replyMsg, natsConnection *nc,
+                             const char *subj, const char *str,
+                             int64_t timeout)
+{
+    natsStatus s;
+
+    s = natsConnection_Request(replyMsg, nc, subj, (const void*) str,
+                               (str == NULL ? 0 : (int) strlen(str)),
+                               timeout);
+
+    return NATS_UPDATE_ERR_STACK(s);
+}

data/vendor/cnats/src/srvpool.c

@@ -0,0 +1,380 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+#include "natsp.h"
+
+#include "mem.h"
+#include "url.h"
+
+static void
+_freeSrv(natsSrv *srv)
+{
+    if (srv == NULL)
+        return;
+
+    natsUrl_Destroy(srv->url);
+    NATS_FREE(srv);
+}
+
+static natsStatus
+_createSrv(natsSrv **newSrv, char *url, bool implicit)
+{
+    natsStatus  s = NATS_OK;
+    natsSrv     *srv = (natsSrv*) NATS_CALLOC(1, sizeof(natsSrv));
+
+    if (srv == NULL)
+        return nats_setDefaultError(NATS_NO_MEMORY);
+
+    srv->isImplicit = implicit;
+
+    s = natsUrl_Create(&(srv->url), url);
+    if (s == NATS_OK)
+        *newSrv = srv;
+    else
+        _freeSrv(srv);
+
+    return NATS_UPDATE_ERR_STACK(s);
+}
+
+natsSrv*
+natsSrvPool_GetCurrentServer(natsSrvPool *pool, const natsUrl *url, int *index)
+{
+    natsSrv *s = NULL;
+    int     i;
+
+    for (i = 0; i < pool->size; i++)
+    {
+        s = pool->srvrs[i];
+        if (s->url == url)
+        {
+            if (index != NULL)
+                *index = i;
+
+            return s;
+        }
+    }
+
+    if (index != NULL)
+        *index = -1;
+
+    return NULL;
+}
+
+// Pop the current server and put onto the end of the list. Select head of list as long
+// as number of reconnect attempts under MaxReconnect.
+natsSrv*
+natsSrvPool_GetNextServer(natsSrvPool *pool, natsOptions *opts, const natsUrl *ncUrl)
+{
+    natsSrv *s = NULL;
+    int     i, j;
+
+    s = natsSrvPool_GetCurrentServer(pool, ncUrl, &i);
+    if (i < 0)
+        return NULL;
+
+    // Shift left servers past current to the current's position
+    for (j = i; j < pool->size - 1; j++)
+        pool->srvrs[j] = pool->srvrs[j+1];
+
+    if ((opts->maxReconnect < 0)
+        || (s->reconnects < opts->maxReconnect))
+    {
+        // Move the current server to the back of the list
+        pool->srvrs[pool->size - 1] = s;
+    }
+    else
+    {
+        // Remove the server from the list
+        _freeSrv(s);
+        pool->size--;
+    }
+
+    if (pool->size <= 0)
+        return NULL;
+
+    return pool->srvrs[0];
+}
+
+void
+natsSrvPool_Destroy(natsSrvPool *pool)
+{
+    natsSrv *srv;
+    int     i;
+
+    if (pool == NULL)
+        return;
+
+    for (i = 0; i < pool->size; i++)
+    {
+        srv = pool->srvrs[i];
+        _freeSrv(srv);
+    }
+    natsStrHash_Destroy(pool->urls);
+    pool->urls = NULL;
+
+    NATS_FREE(pool->srvrs);
+    pool->srvrs = NULL;
+    pool->size  = 0;
+    NATS_FREE(pool);
+}
+
+static natsStatus
+_addURLToPool(natsSrvPool *pool, char *sURL, bool implicit)
+{
+    natsStatus  s;
+    natsSrv     *srv = NULL;
+    bool        addedToMap = false;
+    char        bareURL[256];
+
+    s = _createSrv(&srv, sURL, implicit);
+    if (s != NATS_OK)
+        return s;
+
+    // In the map, we need to add an URL that is just host:port
+    snprintf(bareURL, sizeof(bareURL), "%s:%d", srv->url->host, srv->url->port);
+    s = natsStrHash_Set(pool->urls, bareURL, true, (void*)1, NULL);
+    if (s == NATS_OK)
+    {
+        addedToMap = true;
+        if (pool->size + 1 > pool->cap)
+        {
+            natsSrv **newArray  = NULL;
+            int     newCap      = 2 * pool->cap;
+
+            newArray = (natsSrv**) NATS_REALLOC(pool->srvrs, newCap * sizeof(char*));
+            if (newArray == NULL)
+                s = nats_setDefaultError(NATS_NO_MEMORY);
+
+            if (s == NATS_OK)
+            {
+                pool->cap = newCap;
+                pool->srvrs = newArray;
+            }
+        }
+        if (s == NATS_OK)
+            pool->srvrs[pool->size++] = srv;
+    }
+    if (s != NATS_OK)
+    {
+        if (addedToMap)
+            natsStrHash_Remove(pool->urls, sURL);
+
+        _freeSrv(srv);
+    }
+
+    return NATS_UPDATE_ERR_STACK(s);
+}
+
+static void
+_shufflePool(natsSrvPool *pool)
+{
+    int     i, j;
+    natsSrv *tmp;
+
+    if (pool->size <= 1)
+        return;
+
+    srand((unsigned int) nats_NowInNanoSeconds());
+
+    for (i = 0; i < pool->size; i++)
+    {
+        j = rand() % (i + 1);
+        tmp = pool->srvrs[i];
+        pool->srvrs[i] = pool->srvrs[j];
+        pool->srvrs[j] = tmp;
+    }
+}
+
+natsStatus
+natsSrvPool_addNewURLs(natsSrvPool *pool, char **urls, int urlCount, bool doShuffle)
+{
+    natsStatus  s       = NATS_OK;
+    char        url[256];
+    int         i;
+    char        *sport;
+    int         portPos;
+    bool        found;
+    bool        isLH;
+
+    // If we can shuffle, we shuffle the given array, not the entire pool
+    if (urlCount > 0 && doShuffle)
+    {
+        int     j;
+        char    *tmp;
+
+        for (i = 0; i < urlCount; i++)
+        {
+            j = rand() % (i + 1);
+            tmp = urls[i];
+            urls[i] = urls[j];
+            urls[j] = tmp;
+        }
+    }
+
+    for (i=0; (s == NATS_OK) && (i<urlCount); i++)
+    {
+        isLH  = false;
+        found = false;
+
+        // Consider localhost:<port>, 127.0.0.1:<port> and [::1]:<port>
+        // all the same.
+        sport = strrchr(urls[i], ':');
+        portPos = (int) (sport - urls[i]);
+        if (((nats_strcasestr(urls[i], "localhost") == urls[i]) && (portPos == 9))
+                || (strncmp(urls[i], "127.0.0.1", portPos) == 0)
+                || (strncmp(urls[i], "[::1]", portPos) == 0))
+        {
+            isLH = ((urls[i][0] == 'l') || (urls[i][0] == 'L'));
+
+            snprintf(url, sizeof(url), "localhost%s", sport);
+            found = (natsStrHash_Get(pool->urls, url) != NULL);
+            if (!found)
+            {
+                snprintf(url, sizeof(url), "127.0.0.1%s", sport);
+                found = (natsStrHash_Get(pool->urls, url) != NULL);
+            }
+            if (!found)
+            {
+                snprintf(url, sizeof(url), "[::1]%s", sport);
+                found = (natsStrHash_Get(pool->urls, url) != NULL);
+            }
+        }
+        else
+        {
+            found = (natsStrHash_Get(pool->urls, urls[i]) != NULL);
+        }
+
+        if (!found)
+        {
+            // Make sure that localhost URL is always stored in lower case.
+            if (isLH)
+                snprintf(url, sizeof(url), "nats://localhost%s", sport);
+            else
+                snprintf(url, sizeof(url), "nats://%s", urls[i]);
+            s = _addURLToPool(pool, url, true);
+        }
+    }
+
+    return NATS_UPDATE_ERR_STACK(s);
+}
+
+// Create the server pool using the options given.
+// We will place a Url option first, followed by any
+// Server Options. We will randomize the server pool unlesss
+// the NoRandomize flag is set.
+natsStatus
+natsSrvPool_Create(natsSrvPool **newPool, natsOptions *opts)
+{
+    natsStatus  s        = NATS_OK;
+    natsSrvPool *pool    = NULL;
+    int         poolSize;
+    int         i;
+
+    poolSize  = (opts->url != NULL ? 1 : 0);
+    poolSize += opts->serversCount;
+
+    // If the pool is going to be empty, we will add the default URL.
+    if (poolSize == 0)
+        poolSize = 1;
+
+    pool = (natsSrvPool*) NATS_CALLOC(1, sizeof(natsSrvPool));
+    if (pool == NULL)
+        return nats_setDefaultError(NATS_NO_MEMORY);
+
+    pool->srvrs = (natsSrv**) NATS_CALLOC(poolSize, sizeof(natsSrv*));
+    if (pool->srvrs == NULL)
+    {
+        NATS_FREE(pool);
+        return nats_setDefaultError(NATS_NO_MEMORY);
+    }
+    // Set the current capacity. The array of urls may have to grow in
+    // the future.
+    pool->cap = poolSize;
+
+    // Map that helps find out if an URL is already known.
+    s = natsStrHash_Create(&(pool->urls), poolSize);
+
+    // Add URLs from Options' Servers
+    for (i=0; (s == NATS_OK) && (i < opts->serversCount); i++)
+        s = _addURLToPool(pool, opts->servers[i], false);
+
+    if (s == NATS_OK)
+    {
+        // Randomize if allowed to
+        if (!(opts->noRandomize))
+            _shufflePool(pool);
+    }
+
+    // Normally, if this one is set, Options.Servers should not be,
+    // but we always allowed that, so continue to do so.
+    if ((s == NATS_OK) && (opts->url != NULL))
+    {
+        // Add to the end of the array
+        s = _addURLToPool(pool, opts->url, false);
+        if ((s == NATS_OK) && (pool->size > 1))
+        {
+            // Then swap it with first to guarantee that Options.Url is tried first.
+            natsSrv *opstUrl = pool->srvrs[pool->size-1];
+
+            pool->srvrs[pool->size-1] = pool->srvrs[0];
+            pool->srvrs[0] = opstUrl;
+        }
+    }
+    else if ((s == NATS_OK) && (pool->size == 0))
+    {
+        // Place default URL if pool is empty.
+        s = _addURLToPool(pool, (char*) NATS_DEFAULT_URL, false);
+    }
+
+    if (s == NATS_OK)
+        *newPool = pool;
+    else
+        natsSrvPool_Destroy(pool);
+
+    return NATS_UPDATE_ERR_STACK(s);
+}
+
+natsStatus
+natsSrvPool_GetServers(natsSrvPool *pool, bool implicitOnly, char ***servers, int *count)
+{
+    natsStatus  s       = NATS_OK;
+    char        **srvrs = NULL;
+    natsSrv     *srv;
+    natsUrl     *url;
+    int         i;
+    int         discovered = 0;
+
+    if (pool->size == 0)
+    {
+        *servers = NULL;
+        *count   = 0;
+        return NATS_OK;
+    }
+
+    srvrs = (char **) NATS_CALLOC(pool->size, sizeof(char*));
+    if (srvrs == NULL)
+        return nats_setDefaultError(NATS_NO_MEMORY);
+
+    for (i=0; ((s == NATS_OK) && (i<pool->size)); i++)
+    {
+        srv = pool->srvrs[i];
+        if (implicitOnly && !srv->isImplicit)
+            continue;
+        url = srv->url;
+        if (nats_asprintf(&(srvrs[discovered]), "nats://%s:%d", url->host, url->port) == -1)
+            s = nats_setDefaultError(NATS_NO_MEMORY);
+        else
+            discovered++;
+    }
+    if (s == NATS_OK)
+    {
+        *servers = srvrs;
+        *count   = discovered;
+    }
+    else
+    {
+        for (i=0; i<discovered; i++)
+            NATS_FREE(srvrs[i]);
+        NATS_FREE(srvrs);
+    }
+    return NATS_UPDATE_ERR_STACK(s);
+}