ffi-nats-core 0.3.0 → 0.3.1

data/vendor/cnats/src/sub.h

@@ -0,0 +1,34 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+#ifndef SUB_H_
+#define SUB_H_
+
+#include "natsp.h"
+
+#ifdef DEV_MODE
+// For type safety...
+
+void natsSub_Lock(natsSubscription *sub);
+void natsSub_Unlock(natsSubscription *sub);
+
+#else
+
+#define natsSub_Lock(s)      natsMutex_Lock((s)->mu)
+#define natsSub_Unlock(s)    natsMutex_Unlock((s)->mu)
+
+#endif // DEV_MODE
+
+void
+natsSub_retain(natsSubscription *sub);
+
+void
+natsSub_release(natsSubscription *sub);
+
+natsStatus
+natsSub_create(natsSubscription **newSub, natsConnection *nc, const char *subj,
+               const char *queueGroup, int64_t timeout, natsMsgHandler cb, void *cbClosure);
+
+void
+natsSub_close(natsSubscription *sub, bool connectionClosed);
+
+#endif /* SUB_H_ */

data/vendor/cnats/src/timer.c

@@ -0,0 +1,86 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+#include "natsp.h"
+#include "mem.h"
+#include "util.h"
+
+static void
+_freeTimer(natsTimer *t)
+{
+    if (t == NULL)
+        return;
+
+    natsMutex_Destroy(t->mu);
+    NATS_FREE(t);
+}
+
+void
+natsTimer_Release(natsTimer *t)
+{
+    int refs = 0;
+
+    natsMutex_Lock(t->mu);
+
+    refs = --(t->refs);
+
+    natsMutex_Unlock(t->mu);
+
+    if (refs == 0)
+        _freeTimer(t);
+}
+
+natsStatus
+natsTimer_Create(natsTimer **timer, natsTimerCb timerCb, natsTimerStopCb stopCb,
+                 int64_t interval, void* closure)
+{
+    natsStatus  s  = NATS_OK;
+    natsTimer   *t = (natsTimer*) NATS_CALLOC(1, sizeof(natsTimer));
+
+    if (t == NULL)
+        return nats_setDefaultError(NATS_NO_MEMORY);
+
+    t->refs    = 1;
+    t->cb      = timerCb;
+    t->stopCb  = stopCb;
+    t->closure = closure;
+
+    s = natsMutex_Create(&(t->mu));
+    if (s == NATS_OK)
+    {
+        // Doing so, so that nats_resetTimer() does not try to remove the timer
+        // from the list (since it is new it would not be there!).
+        t->stopped = true;
+
+        nats_resetTimer(t, interval);
+
+        *timer = t;
+    }
+    else
+        _freeTimer(t);
+
+    return NATS_UPDATE_ERR_STACK(s);
+}
+
+void
+natsTimer_Stop(natsTimer *timer)
+{
+    // Proxy for this call:
+    nats_stopTimer(timer);
+}
+
+void
+natsTimer_Reset(natsTimer *timer, int64_t interval)
+{
+    // Proxy for this call:
+    nats_resetTimer(timer, interval);
+}
+
+void
+natsTimer_Destroy(natsTimer *timer)
+{
+    if (timer == NULL)
+        return;
+
+    nats_stopTimer(timer);
+    natsTimer_Release(timer);
+}

data/vendor/cnats/src/timer.h

@@ -0,0 +1,57 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+#ifndef TIMER_H_
+#define TIMER_H_
+
+#include <stdint.h>
+
+//#include "natsp.h"
+#include "status.h"
+
+struct __natsTimer;
+
+// Callback signature for timer
+typedef void (*natsTimerCb)(struct __natsTimer *timer, void* closure);
+
+// Callback invoked when the timer has been stopped and guaranteed
+// not to be in the timer callback.
+typedef void (*natsTimerStopCb)(struct __natsTimer *timer, void* closure);
+
+typedef struct __natsTimer
+{
+    struct __natsTimer  *prev;
+    struct __natsTimer  *next;
+
+    natsMutex           *mu;
+    int                 refs;
+
+    natsTimerCb         cb;
+    natsTimerStopCb     stopCb;
+    void*               closure;
+
+    int64_t             interval;
+    int64_t             absoluteTime;
+
+    bool                stopped;
+    bool                inCallback;
+
+} natsTimer;
+
+natsStatus
+natsTimer_Create(natsTimer **timer, natsTimerCb timerCb, natsTimerStopCb stopCb,
+                 int64_t interval, void* closure);
+
+void
+natsTimer_Stop(natsTimer *timer);
+
+void
+natsTimer_Reset(natsTimer *timer, int64_t interval);
+
+void
+natsTimer_Release(natsTimer *t);
+
+void
+natsTimer_Destroy(natsTimer *timer);
+
+
+#endif /* TIMER_H_ */

data/vendor/cnats/src/unix/cond.c

@@ -0,0 +1,103 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+#include "../natsp.h"
+
+#include <errno.h>
+
+#include "../util.h"
+#include "../mem.h"
+
+natsStatus
+natsCondition_Create(natsCondition **cond)
+{
+    natsCondition   *c = (natsCondition*) NATS_CALLOC(1, sizeof(natsCondition));
+    natsStatus      s  = NATS_OK;
+
+    if (c == NULL)
+        return nats_setDefaultError(NATS_NO_MEMORY);
+
+    if (pthread_cond_init(c, NULL) != 0)
+        s = nats_setError(NATS_SYS_ERROR, "pthread_cond_init error: %d", errno);
+
+    if (s == NATS_OK)
+        *cond = c;
+    else
+        NATS_FREE(c);
+
+    return s;
+}
+
+void
+natsCondition_Wait(natsCondition *cond, natsMutex *mutex)
+{
+    if (pthread_cond_wait(cond, mutex) != 0)
+        abort();
+}
+
+static natsStatus
+_timedWait(natsCondition *cond, natsMutex *mutex, bool isAbsolute, int64_t timeout)
+{
+    int     r;
+    struct  timespec ts;
+    int64_t target;
+
+    if (timeout <= 0)
+        return NATS_TIMEOUT;
+
+    target = (isAbsolute ? timeout : (nats_Now() + timeout));
+
+    ts.tv_sec = target / 1000;
+    ts.tv_nsec = (target % 1000) * 1000000;
+
+    if (ts.tv_nsec >= 1000000000L)
+    {
+        ts.tv_sec++;
+        ts.tv_nsec -= 1000000000L;
+    }
+
+    r = pthread_cond_timedwait(cond, mutex, &ts);
+
+    if (r == 0)
+        return NATS_OK;
+
+    if (r == ETIMEDOUT)
+        return NATS_TIMEOUT;
+
+    return nats_setError(NATS_SYS_ERROR, "pthread_cond_timedwait error: %d", errno);
+}
+
+natsStatus
+natsCondition_TimedWait(natsCondition *cond, natsMutex *mutex, int64_t timeout)
+{
+    return _timedWait(cond, mutex, false, timeout);
+}
+
+natsStatus
+natsCondition_AbsoluteTimedWait(natsCondition *cond, natsMutex *mutex, int64_t absoluteTime)
+{
+    return _timedWait(cond, mutex, true, absoluteTime);
+}
+
+void
+natsCondition_Signal(natsCondition *cond)
+{
+    if (pthread_cond_signal(cond) != 0)
+      abort();
+}
+
+void
+natsCondition_Broadcast(natsCondition *cond)
+{
+    if (pthread_cond_broadcast(cond) != 0)
+      abort();
+}
+
+void
+natsCondition_Destroy(natsCondition *cond)
+{
+    if (cond == NULL)
+        return;
+
+    pthread_cond_destroy(cond);
+    NATS_FREE(cond);
+}

data/vendor/cnats/src/unix/mutex.c

@@ -0,0 +1,107 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+#include "../natsp.h"
+#include "../mem.h"
+
+natsStatus
+natsMutex_Create(natsMutex **newMutex)
+{
+    natsStatus          s = NATS_OK;
+    pthread_mutexattr_t attr;
+    natsMutex           *m = NATS_CALLOC(1, sizeof(natsMutex));
+    bool                noAttrDestroy = false;
+
+    if (m == NULL)
+        s = nats_setDefaultError(NATS_NO_MEMORY);
+
+    if ((s == NATS_OK)
+        && (pthread_mutexattr_init(&attr) != 0)
+        && (noAttrDestroy = true))
+    {
+        s = nats_setError(NATS_SYS_ERROR, "pthread_mutexattr_init error: %d",
+                          errno);
+    }
+
+    if ((s == NATS_OK)
+        && (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE) != 0))
+    {
+        s = nats_setError(NATS_SYS_ERROR, "pthread_mutexattr_settype error: %d",
+                          errno);
+    }
+
+    if ((s == NATS_OK)
+        && (pthread_mutex_init(m, &attr) != 0))
+    {
+        s = nats_setError(NATS_SYS_ERROR, "pthread_mutex_init error: %d",
+                          errno);
+    }
+
+    if (!noAttrDestroy)
+        pthread_mutexattr_destroy(&attr);
+
+    if (s == NATS_OK)
+        *newMutex = m;
+    else
+        NATS_FREE(m);
+
+    return s;
+}
+
+bool
+natsMutex_TryLock(natsMutex *m)
+{
+    if (pthread_mutex_trylock(m) == 0)
+        return true;
+
+    return false;
+}
+
+void
+natsMutex_Lock(natsMutex *m)
+{
+    // The "rep" instruction used for spinning is not supported on ARM.
+#ifndef __arm__
+    if (gLockSpinCount > 0)
+    {
+        int64_t attempts = 0;
+
+        while (pthread_mutex_trylock(m) != 0)
+        {
+            if (++attempts <= gLockSpinCount)
+            {
+                __asm__ __volatile__ ("rep; nop");
+            }
+            else
+            {
+                if (pthread_mutex_lock(m))
+                    abort();
+
+                break;
+            }
+        }
+    }
+    else
+#endif
+    {
+        if (pthread_mutex_lock(m))
+            abort();
+    }
+}
+
+
+void
+natsMutex_Unlock(natsMutex *m)
+{
+    if (pthread_mutex_unlock(m))
+        abort();
+}
+
+void
+natsMutex_Destroy(natsMutex *m)
+{
+    if (m == NULL)
+        return;
+
+    pthread_mutex_destroy(m);
+    NATS_FREE(m);
+}

data/vendor/cnats/src/unix/sock.c

@@ -0,0 +1,105 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+#include "../natsp.h"
+#include "../mem.h"
+#include "../comsock.h"
+
+void
+natsSys_Init(void)
+{
+    // Would do anything that needs to be initialized when
+    // the libary loads, specific to unix.
+}
+
+natsStatus
+natsSock_Init(natsSockCtx *ctx)
+{
+    memset(ctx, 0, sizeof(natsSockCtx));
+
+    ctx->fd = NATS_SOCK_INVALID;
+
+
+    return natsSock_CreateFDSet(&ctx->fdSet);
+}
+
+void
+natsSock_Clear(natsSockCtx *ctx)
+{
+    natsSock_DestroyFDSet(ctx->fdSet);
+}
+
+natsStatus
+natsSock_WaitReady(int waitMode, natsSockCtx *ctx)
+{
+    struct timeval  *timeout = NULL;
+    int             res;
+    fd_set          *fdSet = ctx->fdSet;
+    natsSock        sock = ctx->fd;
+    natsDeadline    *deadline = &(ctx->deadline);
+
+    FD_ZERO(fdSet);
+    FD_SET(sock, fdSet);
+
+     if (deadline != NULL)
+        timeout = natsDeadline_GetTimeout(deadline);
+
+    switch (waitMode)
+    {
+        case WAIT_FOR_READ:     res = select((int) (sock + 1), fdSet, NULL, NULL, timeout); break;
+        case WAIT_FOR_WRITE:    res = select((int) (sock + 1), NULL, fdSet, NULL, timeout); break;
+        case WAIT_FOR_CONNECT:  res = select((int) (sock + 1), NULL, fdSet, NULL, timeout); break;
+        default: abort();
+    }
+
+    if (res == NATS_SOCK_ERROR)
+        return nats_setError(NATS_IO_ERROR, "select error: %d", res);
+
+    if ((res == 0) || !FD_ISSET(sock, fdSet))
+        return nats_setDefaultError(NATS_TIMEOUT);
+
+    return NATS_OK;
+}
+
+natsStatus
+natsSock_SetBlocking(natsSock fd, bool blocking)
+{
+    int flags;
+
+    if ((flags = fcntl(fd, F_GETFL)) == -1)
+        return nats_setError(NATS_SYS_ERROR, "fcntl error: %d", errno);
+
+    if (blocking)
+        flags &= ~O_NONBLOCK;
+    else
+        flags |= O_NONBLOCK;
+
+    if (fcntl(fd, F_SETFL, flags) == -1)
+        return nats_setError(NATS_SYS_ERROR, "fcntl error: %d", errno);
+
+    return NATS_OK;
+}
+
+bool
+natsSock_IsConnected(natsSock fd)
+{
+    int         res;
+    int         error = 0;
+    socklen_t   errorLen = (socklen_t) sizeof(int);
+
+    res = getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &errorLen);
+    if ((res == NATS_SOCK_ERROR) || (error != 0))
+        return false;
+
+    return true;
+}
+
+natsStatus
+natsSock_Flush(natsSock fd)
+{
+    if (fsync(fd) != 0)
+        return nats_setError(NATS_IO_ERROR,
+                             "Error flushing socket. Error: %d",
+                             NATS_SOCK_GET_ERROR);
+
+    return NATS_OK;
+}