ffi-nats-core 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 043c01bc38fc465f9821578a42577235e5ab4991
-  data.tar.gz: ed03d81c41b868b9c694800364cd2b0ceef7739c
+  metadata.gz: 329ed5a98e503504856fb08d3eb7ad5339ef9460
+  data.tar.gz: b853d48d011a9510ee6003823687153b3afff86f
 SHA512:
-  metadata.gz: 136c51044e57100eabc6357e48795185058a9006ba057dde970786fb35d6aaccaff4605511cb131b8807b9b27636c0a5cddccc46bc5860cce696f69d5b0b85a0
-  data.tar.gz: 51460c9f09582ef1f9eae1120cee8054150d5a424e3adf91b834a16d991cf72a05787f81f89d4b71e0cc715e8603ed64c4e07490df0981c9bf18c640768e6652
+  metadata.gz: 36f22cd210b091b727ca62f11c39764c4d9473b3cebb79880a112c38f0fbb7dd8558ccbbec92e4b48e2831adbab2883a915fa8784f61a5e5fa2c47280213e6d0
+  data.tar.gz: 1e6102bf76d582972363e3cdc520d3ff6f15e0e9d14cde4c3200c9867a61f2a9074ec42cb0c56bb84f91d57db64d14b36114af3e5e5af311747d2fecd7dd9766

data/ffi-nats-core.gemspec

@@ -16,6 +16,14 @@ Gem::Specification.new do |spec|
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
   end
+
+  # cnats files
+  spec.files         += Dir.glob("vendor/cnats/CMakeLists.txt")
+  spec.files         += Dir.glob("vendor/cnats/adapters/**/*")
+  spec.files         += Dir.glob("vendor/cnats/src/**/*")
+  spec.files         += Dir.glob("vendor/cnats/test/**/*")
+  spec.files         += Dir.glob("vendor/cnats/examples/**/*")
+
   spec.bindir        = "exe"
   spec.extensions    = "ext/ffi/nats/core/Rakefile"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }

data/lib/ffi/nats/core/version.rb

@@ -1,7 +1,7 @@
 module FFI
   module Nats
     module Core
-      VERSION = "0.3.0"
+      VERSION = "0.3.1"
     end
   end
 end

data/vendor/cnats/CMakeLists.txt

@@ -0,0 +1,137 @@
+cmake_minimum_required(VERSION 2.8)
+
+project(cnats)
+include(CTest)
+
+# Uncomment to have the build process verbose
+#set(CMAKE_VERBOSE_MAKEFILE TRUE)
+
+# Uncomment to have the executable moved to 'build' instead of their respective 'build/xxx' directories
+#set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR})
+
+set(NATS_INSTALL_PREFIX ../install CACHE PATH "Install prefix")
+set(CMAKE_INSTALL_PREFIX ${NATS_INSTALL_PREFIX} CACHE INTERNAL "")
+
+option(NATS_UPDATE_VERSION "Update the version file" OFF)
+option(NATS_COVERAGE "Code coverage" OFF)
+option(NATS_BUILD_WITH_TLS "Build with TLS support" ON)
+option(NATS_BUILD_WITH_TLS_CLIENT_METHOD "Use TLS_client_method()" OFF)
+option(NATS_BUILD_LIBUV_EXAMPLE "Compile libuv example" OFF)
+option(NATS_BUILD_LIBEVENT_EXAMPLE "Compile libevent example" OFF)
+
+if(NATS_BUILD_WITH_TLS)
+find_package(OpenSSL REQUIRED)
+endif(NATS_BUILD_WITH_TLS)
+
+set(LIBUV_DIR "/usr/local/" CACHE PATH "Libuv install directory")
+set(LIBEVENT_DIR "/usr/local/" CACHE PATH "Libevent install directory")
+
+# Platform specific settings
+if(UNIX)
+  #---------------------------------------------------------------------------
+  # Define NATS cache variables that override the CMAKE and MEMCHECK variables
+  #---------------------------------------------------------------------------
+  set(NATS_BUILD_TYPE Release CACHE STRING "Build type: Release, Debug, RelWithDebInfo, MinRelSize")
+  set(CMAKE_BUILD_TYPE ${NATS_BUILD_TYPE} CACHE INTERNAL "")
+
+  set(NATS_BUILD_ARCH "64" CACHE STRING "32 for 32bits builds")
+
+  set(NATS_MEMCHECK_CMD "/usr/bin/valgrind" CACHE FILE "Memcheck tool")
+  set(MEMORYCHECK_COMMAND ${NATS_MEMCHECK_CMD} CACHE INTERNAL "")
+
+  set(NATS_MEMCHECK_CMD_OPTS "--leak-check=full --track-fds=yes --show-reachable=yes --num-callers=50" CACHE STRING "Memcheck options")
+  set(MEMORYCHECK_COMMAND_OPTIONS ${NATS_MEMCHECK_CMD_OPTS} CACHE INTERNAL "")
+
+  set(NATS_COMMON_C_FLAGS "-std=c99 -pedantic")
+  
+  if(NATS_BUILD_TYPE MATCHES "Debug")
+    set(NATS_COMMON_C_FLAGS "${NATS_COMMON_C_FLAGS} -ggdb")    
+  endif(NATS_BUILD_TYPE MATCHES "Debug")
+  
+  set(NATS_WARNINGS "-Wall -W -Wno-unused-variable -Wno-unused-parameter -Wno-unused-function -Wstrict-prototypes -Wwrite-strings")
+  set(NATS_PLATFORM_INCLUDE "unix")
+  
+  if(APPLE)
+    set(CMAKE_MACOSX_RPATH OFF)
+    set(NATS_OS "DARWIN")
+  else(APPLE)
+    set(NATS_OS "LINUX")
+    set(NATS_USE_PTHREAD "-pthread")
+    set(NATS_EXTRA_LIB "rt")
+    if(NATS_COVERAGE)
+      set(NATS_CODE_COVERAGE "--coverage")
+    endif()
+  endif(APPLE)
+  
+  if (${NATS_BUILD_ARCH} MATCHES "32")
+    if(NOT APPLE)
+      message("-----------------------------------------------------------")
+      message("If build fails, you probably need to install libc6-dev-i386")
+      message("apt-get install libc6-dev-i386")
+      message("-----------------------------------------------------------")
+    endif(NOT APPLE)
+      
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -m32")
+    set(CMAKE_C_LINKER_FLAGS "${CMAKE_C_LINKER_FLAGS} -m32")
+  endif(${NATS_BUILD_ARCH} MATCHES "32")
+  
+elseif(WIN32)
+  set(NATS_OS "_WIN32")
+  set(NATS_PLATFORM_INCLUDE "win") 
+endif(UNIX)
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${NATS_CODE_COVERAGE} ${NATS_COMMON_C_FLAGS} ${NATS_USE_PTHREAD} ${NATS_WARNINGS}")
+
+add_definitions(-D${NATS_OS})
+add_definitions(-D_REENTRANT)
+if(NATS_BUILD_WITH_TLS)
+add_definitions(-DNATS_HAS_TLS)
+if(NATS_BUILD_WITH_TLS_CLIENT_METHOD)
+add_definitions(-DNATS_USE_TLS_CLIENT_METHOD)
+endif(NATS_BUILD_WITH_TLS_CLIENT_METHOD)
+endif(NATS_BUILD_WITH_TLS)
+
+#---------------------------------------------------------------------
+# Add to the 'clean' target the list (and location) of files to remove
+
+list(APPEND NATS_INSTALLED_FILES "${CMAKE_INSTALL_PREFIX}/include/nats.h")
+list(APPEND NATS_INSTALLED_FILES "${CMAKE_INSTALL_PREFIX}/include/status.h")
+list(APPEND NATS_INSTALLED_FILES "${CMAKE_INSTALL_PREFIX}/include/version.h")
+list(APPEND NATS_INSTALLED_FILES "${CMAKE_INSTALL_PREFIX}/lib/${nats}")
+list(APPEND NATS_INSTALLED_FILES "${CMAKE_INSTALL_PREFIX}/lib/${nats_static}")
+
+set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${NATS_INSTALLED_FILES}")
+#---------------------------------------------------------------------
+
+if(NATS_UPDATE_VERSION)
+#------------
+# Versionning
+
+set(NATS_VERSION_MAJOR  1)
+set(NATS_VERSION_MINOR  5)
+set(NATS_VERSION_PATCH  0)
+set(NATS_VERSION_SUFFIX "")
+
+set(NATS_VERSION_REQUIRED_NUMBER 0x010100)
+
+configure_file(
+	${CMAKE_CURRENT_SOURCE_DIR}/src/version.h.in
+	${CMAKE_CURRENT_SOURCE_DIR}/src/version.h
+	@ONLY)
+
+configure_file(
+	${CMAKE_SOURCE_DIR}/doc/DoxyFile.NATS.Client.in
+	${CMAKE_SOURCE_DIR}/doc/DoxyFile.NATS.Client
+	@ONLY)
+#------------
+endif()
+
+#----------------------------
+# Add the project directories
+
+add_subdirectory(src)
+add_subdirectory(examples)
+add_subdirectory(test)
+add_subdirectory(test/dylib)
+#----------------------------
+

data/vendor/cnats/adapters/libevent.h

@@ -0,0 +1,220 @@
+// Copyright 2016 Apcera Inc. All rights reserved.
+
+#ifndef LIBEVENT_H_
+#define LIBEVENT_H_
+
+/** \cond
+ *
+ */
+#include <event.h>
+#include <event2/thread.h>
+#include "nats.h"
+
+typedef struct
+{
+    natsConnection      *nc;
+    struct event_base   *loop;
+    struct event        *read;
+    struct event        *write;
+    struct event        *keepActive;
+
+} natsLibeventEvents;
+
+// Forward declarations
+natsStatus natsLibevent_Read(void *userData, bool add);
+natsStatus natsLibevent_Detach(void *userData);
+
+/** \endcond
+ *
+ */
+
+
+/** \defgroup libeventFunctions Libevent Adapter
+ *
+ *  Adapter to plug a `NATS` connection to a `libevent` event loop.
+ *  @{
+ */
+
+/** \brief Initialize the adapter.
+ *
+ * Needs to be called once so that the adapter can initialize some state.
+ */
+void
+natsLibevent_Init(void)
+{
+#if _WIN32
+    evthread_use_windows_threads();
+#else
+    evthread_use_pthreads();
+#endif
+}
+
+static void
+natsLibevent_ProcessEvent(int fd, short event, void *arg)
+{
+    natsLibeventEvents *nle = (natsLibeventEvents*) arg;
+
+    if (event & EV_READ)
+        natsConnection_ProcessReadEvent(nle->nc);
+
+    if (event & EV_WRITE)
+        natsConnection_ProcessWriteEvent(nle->nc);
+}
+
+static void
+keepAliveCb(evutil_socket_t fd, short flags, void * arg)
+{
+    // do nothing...
+}
+
+/** \brief Attach a connection to the given event loop.
+ *
+ * This callback is invoked after `NATS` library has connected, or reconnected.
+ * For a reconnect event, `*userData` will not be `NULL`. This function will
+ * start polling on READ events for the given `socket`.
+ *
+ * @param userData the location where the adapter stores the user object passed
+ * to the other callbacks.
+ * @param loop the event loop as a generic pointer. Cast to appropriate type.
+ * @param nc the connection to attach to the event loop
+ * @param socket the socket to start polling on.
+ */
+natsStatus
+natsLibevent_Attach(void **userData, void *loop, natsConnection *nc, int socket)
+{
+    struct event_base   *libeventLoop = (struct event_base*) loop;
+    natsLibeventEvents  *nle          = (natsLibeventEvents*) (*userData);
+    natsStatus          s             = NATS_OK;
+
+    // This is the first attach (when reconnecting, nle will be non-NULL).
+    if (nle == NULL)
+    {
+        nle = (natsLibeventEvents*) calloc(1, sizeof(natsLibeventEvents));
+        if (nle == NULL)
+            return NATS_NO_MEMORY;
+
+        nle->nc   = nc;
+        nle->loop = libeventLoop;
+
+        nle->keepActive = event_new(nle->loop, -1, EV_PERSIST, keepAliveCb, NULL);
+        if (nle->keepActive == NULL)
+            s = NATS_NO_MEMORY;
+
+        if (s == NATS_OK)
+        {
+            struct timeval timeout;
+
+            timeout.tv_sec = 100000;
+            timeout.tv_usec = 0;
+
+            if (event_add(nle->keepActive, &timeout) != 0)
+                s = NATS_ERR;
+        }
+    }
+    else
+    {
+        if (nle->read != NULL)
+        {
+            event_free(nle->read);
+            nle->read = NULL;
+        }
+        if (nle->write != NULL)
+        {
+            event_free(nle->write);
+            nle->write = NULL;
+        }
+    }
+
+    if (s == NATS_OK)
+    {
+        nle->read = event_new(nle->loop, socket, EV_READ|EV_PERSIST,
+                              natsLibevent_ProcessEvent, (void*) nle);
+        natsLibevent_Read((void*) nle, true);
+
+        nle->write = event_new(nle->loop, socket, EV_WRITE|EV_PERSIST,
+                               natsLibevent_ProcessEvent, (void*) nle);
+    }
+
+    if (s == NATS_OK)
+        *userData = (void*) nle;
+    else
+        natsLibevent_Detach((void*) nle);
+
+    return s;
+}
+
+/** \brief Start or stop polling on READ events.
+ *
+ * This callback is invoked to notify that the event library should start
+ * or stop polling for READ events.
+ *
+ * @param userData the user object created in #natsLibuv_Attach
+ * @param add `true` if the library needs to start polling, `false` otherwise.
+ */
+natsStatus
+natsLibevent_Read(void *userData, bool add)
+{
+    natsLibeventEvents  *nle = (natsLibeventEvents*) userData;
+    int                 res;
+
+    if (add)
+        res = event_add(nle->read, NULL);
+    else
+        res = event_del(nle->read);
+
+    return (res == 0 ? NATS_OK : NATS_ERR);
+}
+
+/** \brief Start or stop polling on WRITE events.
+ *
+ * This callback is invoked to notify that the event library should start
+ * or stop polling for WRITE events.
+ *
+ * @param userData the user object created in #natsLibuv_Attach
+ * @param add `true` if the library needs to start polling, `false` otherwise.
+ */
+natsStatus
+natsLibevent_Write(void *userData, bool add)
+{
+    natsLibeventEvents  *nle = (natsLibeventEvents*) userData;
+    int                 res;
+
+    if (add)
+        res = event_add(nle->write, NULL);
+    else
+        res = event_del(nle->write);
+
+    return (res == 0 ? NATS_OK : NATS_ERR);
+}
+
+/** \brief The connection is closed, it can be safely detached.
+ *
+ * When a connection is closed (not disconnected, pending a reconnect), this
+ * callback will be invoked. This is the opportunity to cleanup the state
+ * maintained by the adapter for this connection.
+ *
+ * @param userData the user object created in #natsLibuv_Attach
+ */
+natsStatus
+natsLibevent_Detach(void *userData)
+{
+    natsLibeventEvents *nle = (natsLibeventEvents*) userData;
+
+    if (nle->read != NULL)
+        event_free(nle->read);
+    if (nle->write != NULL)
+        event_free(nle->write);
+    if (nle->keepActive != NULL)
+    {
+        event_active(nle->keepActive, 0, 0);
+        event_free(nle->keepActive);
+    }
+
+    free(nle);
+
+    return NATS_OK;
+}
+
+/** @} */ // end of libeventFunctions
+
+#endif /* LIBEVENT_H_ */

data/vendor/cnats/adapters/libuv.h

@@ -0,0 +1,472 @@
+// Copyright 2016 Apcera Inc. All rights reserved.
+
+#ifndef LIBUV_H_
+#define LIBUV_H_
+
+/** \cond
+ *
+ */
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#define NATS_LIBUV_INCLUDE
+
+#include <uv.h>
+#include "nats.h"
+
+#define NATS_LIBUV_ATTACH   (1)
+#define NATS_LIBUV_READ     (2)
+#define NATS_LIBUV_WRITE    (3)
+#define NATS_LIBUV_DETACH   (4)
+
+struct __natsLibuvEvent;
+
+typedef struct __natsLibuvEvent
+{
+    int                     type;
+    bool                    add;
+    struct __natsLibuvEvent *next;
+
+} natsLibuvEvent;
+
+typedef struct
+{
+    natsConnection  *nc;
+    uv_loop_t       *loop;
+    uv_poll_t       *handle;
+    uv_async_t      *scheduler;
+    int             events;
+    int             socket;
+    uv_mutex_t      *lock;
+    natsLibuvEvent  *head;
+    natsLibuvEvent  *tail;
+
+} natsLibuvEvents;
+
+// Forward declarations
+natsStatus natsLibuv_Detach(void *userData);
+
+/** \endcond
+ *
+ */
+
+static uv_once_t    uvOnce = UV_ONCE_INIT;
+static uv_key_t     uvLoopThreadKey;
+
+static void
+_initOnce(void)
+{
+    if (uv_key_create(&uvLoopThreadKey) != 0)
+        abort();
+}
+
+/** \defgroup libuvFunctions Libuv Adapter
+ *
+ *  Adapter to plug a `NATS` connection to a `libuv` event loop.
+ *  @{
+ */
+
+/** \brief Initialize the adapter.
+ *
+ * Needs to be called once so that the adapter can initialize some state.
+ */
+void
+natsLibuv_Init(void)
+{
+    uv_once(&uvOnce, _initOnce);
+}
+
+/** \brief Register the event loop with the thread running `uv_run()`.
+ *
+ * Since `libuv` is not thread-safe, the adapter needs to know in which
+ * thread `uv_run()` will run for the given `loop`. It allows the adapter
+ * to schedule events so that they are executed in the event loop thread.
+ *
+ * @param loop an event loop.
+ */
+void
+natsLibuv_SetThreadLocalLoop(uv_loop_t *loop)
+{
+    uv_key_set(&uvLoopThreadKey, (void*) loop);
+}
+
+static natsStatus
+uvScheduleToEventLoop(natsLibuvEvents *nle, int eventType, bool add)
+{
+    natsLibuvEvent  *newEvent = NULL;
+    int             res;
+
+    newEvent = (natsLibuvEvent*) malloc(sizeof(natsLibuvEvent));
+    if (newEvent == NULL)
+        return NATS_NO_MEMORY;
+
+    newEvent->type  = eventType;
+    newEvent->add   = add;
+    newEvent->next  = NULL;
+
+    uv_mutex_lock(nle->lock);
+
+    if (nle->head == NULL)
+        nle->head = newEvent;
+
+    if (nle->tail != NULL)
+        nle->tail->next = newEvent;
+
+    nle->tail = newEvent;
+
+    uv_mutex_unlock(nle->lock);
+
+    res = uv_async_send(nle->scheduler);
+
+    return (res == 0 ? NATS_OK : NATS_ERR);
+}
+
+static void
+natsLibuvPoll(uv_poll_t* handle, int status, int events)
+{
+    natsLibuvEvents *nle = (natsLibuvEvents*)handle->data;
+
+    if (status != 0)
+        return;
+
+    if (events & UV_READABLE)
+        natsConnection_ProcessReadEvent(nle->nc);
+
+    if (events & UV_WRITABLE)
+        natsConnection_ProcessWriteEvent(nle->nc);
+}
+
+static natsStatus
+uvPollUpdate(natsLibuvEvents *nle, int eventType, bool add)
+{
+    int res;
+
+    if (eventType == NATS_LIBUV_READ)
+    {
+        if (add)
+            nle->events |= UV_READABLE;
+        else
+            nle->events &= ~UV_READABLE;
+    }
+    else
+    {
+        if (add)
+            nle->events |= UV_WRITABLE;
+        else
+            nle->events &= ~UV_WRITABLE;
+    }
+
+    if (nle->events)
+        res = uv_poll_start(nle->handle, nle->events, natsLibuvPoll);
+    else
+        res = uv_poll_stop(nle->handle);
+
+    if (res != 0)
+        return NATS_ERR;
+
+    return NATS_OK;
+}
+
+static void
+uvHandleClosedCb(uv_handle_t *handle)
+{
+    free(handle);
+}
+
+static natsStatus
+uvAsyncAttach(natsLibuvEvents *nle)
+{
+    natsStatus  s = NATS_OK;
+
+    // We are reconnecting, destroy the old handle, create a new one
+    if (nle->handle != NULL)
+    {
+        uv_close((uv_handle_t*) nle->handle, uvHandleClosedCb);
+        nle->handle = NULL;
+    }
+
+    nle->handle = (uv_poll_t*) malloc(sizeof(uv_poll_t));
+    if (nle->handle == NULL)
+        s = NATS_NO_MEMORY;
+
+    if ((s == NATS_OK)
+        && (uv_poll_init_socket(nle->loop, nle->handle, nle->socket) != 0))
+    {
+        s = NATS_ERR;
+    }
+
+    if ((s == NATS_OK)
+        && (nle->handle->data = (void*) nle)
+        && (uv_poll_start(nle->handle, UV_READABLE, natsLibuvPoll) != 0))
+    {
+        s = NATS_ERR;
+    }
+
+    return s;
+}
+
+static void
+finalCloseCb(uv_handle_t* handle)
+{
+    natsLibuvEvents *nle = (natsLibuvEvents*)handle->data;
+    natsLibuvEvent  *event;
+
+    while ((event = nle->head) != NULL)
+    {
+        nle->head = event->next;
+        free(event);
+    }
+    free(nle->handle);
+    free(nle->scheduler);
+    uv_mutex_destroy(nle->lock);
+    free(nle->lock);
+    free(nle);
+}
+
+static void
+closeSchedulerCb(uv_handle_t* scheduler)
+{
+    natsLibuvEvents *nle = (natsLibuvEvents*) scheduler->data;
+
+    uv_close((uv_handle_t*) nle->handle, finalCloseCb);
+}
+
+static void
+uvAsyncDetach(natsLibuvEvents *nle)
+{
+    uv_close((uv_handle_t*) nle->scheduler, closeSchedulerCb);
+}
+
+static void
+uvAsyncCb(uv_async_t *handle)
+{
+    natsLibuvEvents *nle    = (natsLibuvEvents*) handle->data;
+    natsStatus      s       = NATS_OK;
+    natsLibuvEvent  *event  = NULL;
+    bool            remove  = false;
+    bool            more    = false;
+
+    while (1)
+    {
+        uv_mutex_lock(nle->lock);
+
+        event = nle->head;
+        if (event == NULL)
+        {
+            // This is possible, even on entry of this function because
+            // the callback is called when the handle is initialized.
+            uv_mutex_unlock(nle->lock);
+            return;
+        }
+
+        nle->head = event->next;
+        if (event == nle->tail)
+            nle->tail = NULL;
+
+        more = (nle->head != NULL ? true : false);
+
+        uv_mutex_unlock(nle->lock);
+
+        switch (event->type)
+        {
+            case NATS_LIBUV_ATTACH:
+            {
+                s = uvAsyncAttach(nle);
+                break;
+            }
+            case NATS_LIBUV_READ:
+            case NATS_LIBUV_WRITE:
+            {
+                s = uvPollUpdate(nle, event->type, event->add);
+                break;
+            }
+            case NATS_LIBUV_DETACH:
+            {
+                uvAsyncDetach(nle);
+                break;
+            }
+            default:
+            {
+                s = NATS_ERR;
+                break;
+            }
+        }
+
+        free(event);
+
+        if ((s != NATS_OK) || !more)
+            break;
+    }
+
+    if (s != NATS_OK)
+        natsConnection_Close(nle->nc);
+}
+
+/** \brief Attach a connection to the given event loop.
+ *
+ * This callback is invoked after `NATS` library has connected, or reconnected.
+ * For a reconnect event, `*userData` will not be `NULL`. This function will
+ * start polling on READ events for the given `socket`.
+ *
+ * @param userData the location where the adapter stores the user object passed
+ * to the other callbacks.
+ * @param loop the event loop as a generic pointer. Cast to appropriate type.
+ * @param nc the connection to attach to the event loop
+ * @param socket the socket to start polling on.
+ */
+natsStatus
+natsLibuv_Attach(void **userData, void *loop, natsConnection *nc, int socket)
+{
+    uv_loop_t       *uvLoop = (uv_loop_t*) loop;
+    bool            sched   = false;
+    natsLibuvEvents *nle    = (natsLibuvEvents*) (*userData);
+    natsStatus      s       = NATS_OK;
+
+    sched = ((uv_key_get(&uvLoopThreadKey) != loop) ? true : false);
+
+    // This is the first attach (when reconnecting, nle will be non-NULL).
+    if (nle == NULL)
+    {
+        // This has to run from the event loop!
+        if (sched)
+            return NATS_ILLEGAL_STATE;
+
+        nle = (natsLibuvEvents*) calloc(1, sizeof(natsLibuvEvents));
+        if (nle == NULL)
+            return NATS_NO_MEMORY;
+
+        nle->lock = (uv_mutex_t*) malloc(sizeof(uv_mutex_t));
+        if (nle->lock == NULL)
+            s = NATS_NO_MEMORY;
+
+        if ((s == NATS_OK) && (uv_mutex_init(nle->lock) != 0))
+            s = NATS_ERR;
+
+        if ((s == NATS_OK)
+            && ((nle->scheduler = (uv_async_t*) malloc(sizeof(uv_async_t))) == NULL))
+        {
+            s = NATS_NO_MEMORY;
+        }
+
+        if ((s == NATS_OK)
+            && (uv_async_init(uvLoop, nle->scheduler, uvAsyncCb) != 0))
+        {
+            s = NATS_ERR;
+        }
+
+        if (s == NATS_OK)
+        {
+            nle->nc              = nc;
+            nle->loop            = uvLoop;
+            nle->scheduler->data = (void*) nle;
+        }
+    }
+
+    if (s == NATS_OK)
+    {
+        nle->socket = socket;
+        nle->events = UV_READABLE;
+
+        if (sched)
+            s = uvScheduleToEventLoop(nle, NATS_LIBUV_ATTACH, true);
+        else
+            s = uvAsyncAttach(nle);
+    }
+
+    if (s == NATS_OK)
+        *userData = (void*) nle;
+    else
+        natsLibuv_Detach((void*) nle);
+
+    return s;
+}
+
+/** \brief Start or stop polling on READ events.
+ *
+ * This callback is invoked to notify that the event library should start
+ * or stop polling for READ events.
+ *
+ * @param userData the user object created in #natsLibuv_Attach
+ * @param add `true` if the library needs to start polling, `false` otherwise.
+ */
+natsStatus
+natsLibuv_Read(void *userData, bool add)
+{
+    natsLibuvEvents *nle = (natsLibuvEvents*) userData;
+    natsStatus      s    = NATS_OK;
+    bool            sched;
+
+    sched = ((uv_key_get(&uvLoopThreadKey) != nle->loop) ? true : false);
+
+    // If this call is made from a different thread than the event loop's
+    // thread, or if there are already scheduled events, then schedule
+    // this new event.
+
+    // We don't need to get the lock for nle->head because if sched is
+    // false, we are in the event loop thread, which is the thread removing
+    // events from the list. Also, all calls to the read/write/etc.. callbacks
+    // are protected by the connection's lock in the NATS library.
+    if (sched || (nle->head != NULL))
+        s = uvScheduleToEventLoop(nle, NATS_LIBUV_READ, add);
+    else
+        s = uvPollUpdate(nle, NATS_LIBUV_READ, add);
+
+    return s;
+}
+
+/** \brief Start or stop polling on WRITE events.
+ *
+ * This callback is invoked to notify that the event library should start
+ * or stop polling for WRITE events.
+ *
+ * @param userData the user object created in #natsLibuv_Attach
+ * @param add `true` if the library needs to start polling, `false` otherwise.
+ */
+natsStatus
+natsLibuv_Write(void *userData, bool add)
+{
+    natsLibuvEvents *nle = (natsLibuvEvents*) userData;
+    natsStatus      s    = NATS_OK;
+    bool            sched;
+
+    sched = ((uv_key_get(&uvLoopThreadKey) != nle->loop) ? true : false);
+
+    // See comment in natsLibuvRead
+    if (sched || (nle->head != NULL))
+        s = uvScheduleToEventLoop(nle, NATS_LIBUV_WRITE, add);
+    else
+        s = uvPollUpdate(nle, NATS_LIBUV_WRITE, add);
+
+    return s;
+}
+
+/** \brief The connection is closed, it can be safely detached.
+ *
+ * When a connection is closed (not disconnected, pending a reconnect), this
+ * callback will be invoked. This is the opportunity to cleanup the state
+ * maintained by the adapter for this connection.
+ *
+ * @param userData the user object created in #natsLibuv_Attach
+ */
+natsStatus
+natsLibuv_Detach(void *userData)
+{
+    natsLibuvEvents *nle = (natsLibuvEvents*) userData;
+    natsStatus      s    = NATS_OK;
+    bool            sched;
+
+    sched = ((uv_key_get(&uvLoopThreadKey) != nle->loop) ? true : false);
+
+    // See comment in natsLibuvRead
+    if (sched || (nle->head != NULL))
+        s = uvScheduleToEventLoop(nle, NATS_LIBUV_DETACH, true);
+    else
+        uvAsyncDetach(nle);
+
+    return s;
+}
+
+/** @} */ // end of libuvFunctions
+
+#endif /* LIBUV_H_ */