asyncengine 0.0.1.testing1 → 0.0.2.alpha1

data/ext/asyncengine/libuv/src/uv-common.h

@@ -27,36 +27,39 @@
 #ifndef UV_COMMON_H_
 #define UV_COMMON_H_
 
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+
 #include "uv.h"
 #include "tree.h"
 
+
 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
 
+#define container_of(ptr, type, member) \
+  ((type *) ((char *) (ptr) - offsetof(type, member)))
 
-struct uv_ares_task_s {
-  UV_HANDLE_FIELDS
-#if _WIN32
-  struct uv_req_s ares_req;
-  SOCKET sock;
-  HANDLE h_wait;
-  WSAEVENT h_event;
-  HANDLE h_close_event;
+#ifdef _MSC_VER
+# define UNUSED /* empty */
+# define INLINE __inline
 #else
-  int sock;
-  ev_io read_watcher;
-  ev_io write_watcher;
+# define UNUSED __attribute__((unused))
+# define INLINE inline
 #endif
-  RB_ENTRY(uv_ares_task_s) node;
-};
-
-
-void uv_remove_ares_handle(uv_ares_task_t* handle);
-uv_ares_task_t* uv_find_ares_handle(uv_loop_t*, ares_socket_t sock);
 
-/* TODO Rename to uv_ares_task_init? */
-void uv_add_ares_handle(uv_loop_t* loop, uv_ares_task_t* handle);
 
-int uv_ares_handles_empty(uv_loop_t* loop);
+#ifndef _WIN32
+enum {
+  UV__HANDLE_INTERNAL = 0x8000,
+  UV__HANDLE_ACTIVE   = 0x4000,
+  UV__HANDLE_REF      = 0x2000
+};
+#else
+# define UV__HANDLE_INTERNAL  0x80
+# define UV__HANDLE_ACTIVE    0x40
+# define UV__HANDLE_REF       0x20
+#endif
 
 extern const uv_err_t uv_ok_;
 
@@ -83,5 +86,86 @@ int uv__tcp_connect6(uv_connect_t* req,
                     struct sockaddr_in6 address,
                     uv_connect_cb cb);
 
+void uv__fs_poll_close(uv_fs_poll_t* handle);
+
+
+UNUSED static int uv__has_active_reqs(const uv_loop_t* loop) {
+  return !ngx_queue_empty(&loop->active_reqs);
+}
+
+UNUSED static void uv__req_register(uv_loop_t* loop, uv_req_t* req) {
+  ngx_queue_insert_tail(&loop->active_reqs, &req->active_queue);
+}
+
+UNUSED static void uv__req_unregister(uv_loop_t* loop, uv_req_t* req) {
+  assert(uv__has_active_reqs(loop));
+  ngx_queue_remove(&req->active_queue);
+}
+
+
+UNUSED static int uv__has_active_handles(const uv_loop_t* loop) {
+  return loop->active_handles > 0;
+}
+
+UNUSED static void uv__active_handle_add(uv_handle_t* h) {
+  h->loop->active_handles++;
+}
+
+UNUSED static void uv__active_handle_rm(uv_handle_t* h) {
+  h->loop->active_handles--;
+}
+
+
+#define uv__active_handle_add(h) uv__active_handle_add((uv_handle_t*)(h))
+#define uv__active_handle_rm(h) uv__active_handle_rm((uv_handle_t*)(h))
+
+#define uv__req_register(loop, req) uv__req_register((loop), (uv_req_t*)(req))
+#define uv__req_unregister(loop, req) uv__req_unregister((loop), (uv_req_t*)(req))
+
+UNUSED static int uv__is_active(const uv_handle_t* h) {
+  return !!(h->flags & UV__HANDLE_ACTIVE);
+}
+#define uv__is_active(h) uv__is_active((const uv_handle_t*)(h))
+
+UNUSED static void uv__handle_start(uv_handle_t* h) {
+  if (h->flags & UV__HANDLE_ACTIVE) return;
+  if (h->flags & UV__HANDLE_REF) uv__active_handle_add(h);
+  h->flags |= UV__HANDLE_ACTIVE;
+}
+#define uv__handle_start(h) uv__handle_start((uv_handle_t*)(h))
+
+UNUSED static void uv__handle_stop(uv_handle_t* h) {
+  if (!(h->flags & UV__HANDLE_ACTIVE)) return;
+  if (h->flags & UV__HANDLE_REF) uv__active_handle_rm(h);
+  h->flags &= ~UV__HANDLE_ACTIVE;
+}
+#define uv__handle_stop(h) uv__handle_stop((uv_handle_t*)(h))
+
+UNUSED static void uv__handle_ref(uv_handle_t* h) {
+  if (h->flags & UV__HANDLE_REF) return;
+  if (h->flags & UV__HANDLE_ACTIVE) uv__active_handle_add(h);
+  h->flags |= UV__HANDLE_REF;
+}
+#define uv__handle_ref(h) uv__handle_ref((uv_handle_t*)(h))
+
+UNUSED static void uv__handle_unref(uv_handle_t* h) {
+  if (!(h->flags & UV__HANDLE_REF)) return;
+  if (h->flags & UV__HANDLE_ACTIVE) uv__active_handle_rm(h);
+  h->flags &= ~UV__HANDLE_REF;
+}
+#define uv__handle_unref(h) uv__handle_unref((uv_handle_t*)(h))
+
+UNUSED static void uv__handle_init(uv_loop_t* loop,
+                                   uv_handle_t* handle,
+                                   uv_handle_type type) {
+  loop->counters.handle_init++;
+  handle->loop = loop;
+  handle->type = type;
+  handle->flags = UV__HANDLE_REF; /* ref the loop when active */
+  ngx_queue_insert_tail(&loop->handle_queue, &handle->handle_queue);
+#ifndef _WIN32
+  handle->next_closing = NULL;
+#endif
+}
 
 #endif /* UV_COMMON_H_ */

data/ext/asyncengine/libuv/src/win/async.c

@@ -23,6 +23,8 @@
 
 #include "uv.h"
 #include "internal.h"
+#include "handle-inl.h"
+#include "req-inl.h"
 
 
 /* Atomic set operation on char */
@@ -58,13 +60,8 @@ void uv_async_endgame(uv_loop_t* loop, uv_async_t* handle) {
   if (handle->flags & UV_HANDLE_CLOSING &&
       !handle->async_sent) {
     assert(!(handle->flags & UV_HANDLE_CLOSED));
-    handle->flags |= UV_HANDLE_CLOSED;
-
-    if (handle->close_cb) {
-      handle->close_cb((uv_handle_t*)handle);
-    }
-
-    uv_unref(loop);
+    uv__handle_stop(handle);
+    uv__handle_close(handle);
   }
 }
 
@@ -72,12 +69,7 @@ void uv_async_endgame(uv_loop_t* loop, uv_async_t* handle) {
 int uv_async_init(uv_loop_t* loop, uv_async_t* handle, uv_async_cb async_cb) {
   uv_req_t* req;
 
-  loop->counters.handle_init++;
-  loop->counters.async_init++;
-
-  handle->type = UV_ASYNC;
-  handle->loop = loop;
-  handle->flags = 0;
+  uv__handle_init(loop, (uv_handle_t*) handle, UV_ASYNC);
   handle->async_sent = 0;
   handle->async_cb = async_cb;
 
@@ -86,12 +78,23 @@ int uv_async_init(uv_loop_t* loop, uv_async_t* handle, uv_async_cb async_cb) {
   req->type = UV_WAKEUP;
   req->data = handle;
 
-  uv_ref(loop);
+  loop->counters.async_init++;
+
+  uv__handle_start(handle);
 
   return 0;
 }
 
 
+void uv_async_close(uv_loop_t* loop, uv_async_t* handle) {
+  if (!((uv_async_t*)handle)->async_sent) {
+    uv_want_endgame(loop, (uv_handle_t*) handle);
+  }
+
+  uv__handle_start(handle);
+}
+
+
 int uv_async_send(uv_async_t* handle) {
   uv_loop_t* loop = handle->loop;
 
@@ -118,10 +121,10 @@ void uv_process_async_wakeup_req(uv_loop_t* loop, uv_async_t* handle,
   assert(req->type == UV_WAKEUP);
 
   handle->async_sent = 0;
-  if (handle->async_cb) {
+
+  if (!(handle->flags & UV_HANDLE_CLOSING)) {
     handle->async_cb((uv_async_t*) handle, 0);
-  }
-  if (handle->flags & UV_HANDLE_CLOSING) {
+  } else {
     uv_want_endgame(loop, (uv_handle_t*)handle);
   }
 }

data/ext/asyncengine/libuv/src/win/core.c

@@ -27,8 +27,9 @@
 #include <string.h>
 
 #include "uv.h"
-#include "../uv-common.h"
 #include "internal.h"
+#include "handle-inl.h"
+#include "req-inl.h"
 
 
 /* The only event loop we support right now */
@@ -44,17 +45,21 @@ static void uv_init(void) {
   SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX |
     SEM_NOOPENFILEERRORBOX);
 
+  /* Fetch winapi function pointers. This must be done first because other */
+  /* intialization code might need these function pointers to be loaded. */
+  uv_winapi_init();
+
   /* Initialize winsock */
   uv_winsock_init();
 
-  /* Fetch winapi function pointers */
-  uv_winapi_init();
-
   /* Initialize FS */
   uv_fs_init();
 
   /* Initialize console */
   uv_console_init();
+
+  /* Initialize utilities */
+  uv__util_init();
 }
 
 
@@ -65,16 +70,17 @@ static void uv_loop_init(uv_loop_t* loop) {
     uv_fatal_error(GetLastError(), "CreateIoCompletionPort");
   }
 
-  loop->refs = 0;
-
   uv_update_time(loop);
 
+  ngx_queue_init(&loop->handle_queue);
+  ngx_queue_init(&loop->active_reqs);
+  loop->active_handles = 0;
+
   loop->pending_reqs_tail = NULL;
 
   loop->endgame_handles = NULL;
 
   RB_INIT(&loop->timers);
-  RB_INIT(&loop->uv_ares_handles_);
 
   loop->check_handles = NULL;
   loop->prepare_handles = NULL;
@@ -84,25 +90,34 @@ static void uv_loop_init(uv_loop_t* loop) {
   loop->next_check_handle = NULL;
   loop->next_idle_handle = NULL;
 
-  loop->ares_active_sockets = 0;
-  loop->ares_chan = NULL;
+  memset(&loop->poll_peer_sockets, 0, sizeof loop->poll_peer_sockets);
+
+  loop->channel = NULL;
+  RB_INIT(&loop->ares_handles);
 
   loop->active_tcp_streams = 0;
   loop->active_udp_streams = 0;
 
   loop->last_err = uv_ok_;
+
+  memset(&loop->counters, 0, sizeof loop->counters);
 }
 
 
 static void uv_default_loop_init(void) {
   /* Initialize libuv itself first */
-  uv_once(&uv_init_guard_, uv_init);
+  uv__once_init();
 
   /* Initialize the main loop */
   uv_loop_init(&uv_default_loop_);
 }
 
 
+void uv__once_init(void) {
+  uv_once(&uv_init_guard_, uv_init);
+}
+
+
 uv_loop_t* uv_default_loop(void) {
   uv_once(&uv_default_loop_init_guard_, uv_default_loop_init);
   return &uv_default_loop_;
@@ -113,7 +128,7 @@ uv_loop_t* uv_loop_new(void) {
   uv_loop_t* loop;
 
   /* Initialize libuv itself first */
-  uv_once(&uv_init_guard_, uv_init);
+  uv__once_init();
 
   loop = (uv_loop_t*)malloc(sizeof(uv_loop_t));
 
@@ -128,26 +143,19 @@ uv_loop_t* uv_loop_new(void) {
 
 void uv_loop_delete(uv_loop_t* loop) {
   if (loop != &uv_default_loop_) {
+    int i;
+    for (i = 0; i < ARRAY_SIZE(loop->poll_peer_sockets); i++) {
+      SOCKET sock = loop->poll_peer_sockets[i];
+      if (sock != 0 && sock != INVALID_SOCKET) {
+        closesocket(sock);
+      }
+    }
+
     free(loop);
   }
 }
 
 
-int uv_loop_refcount(const uv_loop_t* loop) {
-  return loop->refs;
-}
-
-
-void uv_ref(uv_loop_t* loop) {
-  loop->refs++;
-}
-
-
-void uv_unref(uv_loop_t* loop) {
-  loop->refs--;
-}
-
-
 static void uv_poll(uv_loop_t* loop, int block) {
   BOOL success;
   DWORD bytes, timeout;
@@ -214,6 +222,11 @@ static void uv_poll_ex(uv_loop_t* loop, int block) {
   }
 }
 
+#define UV_LOOP_ALIVE(loop)                                                   \
+    ((loop)->active_handles > 0 ||                                            \
+     !ngx_queue_empty(&(loop)->active_reqs) ||                                \
+     (loop)->endgame_handles != NULL)
+
 #define UV_LOOP_ONCE(loop, poll)                                              \
   do {                                                                        \
     uv_update_time((loop));                                                   \
@@ -228,7 +241,7 @@ static void uv_poll_ex(uv_loop_t* loop, int block) {
     uv_process_reqs((loop));                                                  \
     uv_process_endgames((loop));                                              \
                                                                               \
-    if ((loop)->refs <= 0) {                                                  \
+    if (!UV_LOOP_ALIVE((loop))) {                                             \
       break;                                                                  \
     }                                                                         \
                                                                               \
@@ -237,13 +250,13 @@ static void uv_poll_ex(uv_loop_t* loop, int block) {
     poll((loop), (loop)->idle_handles == NULL &&                              \
                  (loop)->pending_reqs_tail == NULL &&                         \
                  (loop)->endgame_handles == NULL &&                           \
-                 (loop)->refs > 0);                                           \
+                 UV_LOOP_ALIVE((loop)));                                      \
                                                                               \
     uv_check_invoke((loop));                                                  \
   } while (0);
 
 #define UV_LOOP(loop, poll)                                                   \
-  while ((loop)->refs > 0) {                                                  \
+  while (UV_LOOP_ALIVE((loop))) {                                             \
     UV_LOOP_ONCE(loop, poll)                                                  \
   }
 
@@ -254,7 +267,7 @@ int uv_run_once(uv_loop_t* loop) {
   } else {
     UV_LOOP_ONCE(loop, uv_poll);
   }
-  return 0;
+  return UV_LOOP_ALIVE(loop);
 }
 
 
@@ -265,6 +278,6 @@ int uv_run(uv_loop_t* loop) {
     UV_LOOP(loop, uv_poll);
   }
 
-  assert(loop->refs == 0);
+  assert(!UV_LOOP_ALIVE((loop)));
   return 0;
 }

data/ext/asyncengine/libuv/src/win/dl.c

@@ -22,61 +22,65 @@
 #include "uv.h"
 #include "internal.h"
 
-__declspec( thread ) DWORD saved_errno = 0;
+static int uv__dlerror(uv_lib_t* lib, int errorno);
 
-uv_err_t uv_dlopen(const char* filename, uv_lib_t* library) {
+
+int uv_dlopen(const char* filename, uv_lib_t* lib) {
   wchar_t filename_w[32768];
-  HMODULE handle;
 
-  if (!uv_utf8_to_utf16(filename,
-                        filename_w,
-                        sizeof(filename_w) / sizeof(wchar_t))) {
-    saved_errno = GetLastError();
-    return uv__new_sys_error(saved_errno);
+  lib->handle = NULL;
+  lib->errmsg = NULL;
+
+  if (!uv_utf8_to_utf16(filename, filename_w, ARRAY_SIZE(filename_w))) {
+    return uv__dlerror(lib, GetLastError());
   }
 
-  handle = LoadLibraryW(filename_w);
-  if (handle == NULL) {
-    saved_errno = GetLastError();
-    return uv__new_sys_error(saved_errno);
+  lib->handle = LoadLibraryExW(filename_w, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
+  if (lib->handle == NULL) {
+    return uv__dlerror(lib, GetLastError());
   }
 
-  *library = handle;
-  return uv_ok_;
+  return 0;
 }
 
 
-uv_err_t uv_dlclose(uv_lib_t library) {
-  if (!FreeLibrary(library)) {
-    saved_errno = GetLastError();
-    return uv__new_sys_error(saved_errno);
+void uv_dlclose(uv_lib_t* lib) {
+  if (lib->errmsg) {
+    LocalFree((void*)lib->errmsg);
+    lib->errmsg = NULL;
   }
 
-  return uv_ok_;
+  if (lib->handle) {
+    /* Ignore errors. No good way to signal them without leaking memory. */
+    FreeLibrary(lib->handle);
+    lib->handle = NULL;
+  }
 }
 
 
-uv_err_t uv_dlsym(uv_lib_t library, const char* name, void** ptr) {
-  FARPROC proc = GetProcAddress(library, name);
-  if (proc == NULL) {
-    saved_errno = GetLastError();
-    return uv__new_sys_error(saved_errno);
-  }
-
-  *ptr = (void*) proc;
-  return uv_ok_;
+int uv_dlsym(uv_lib_t* lib, const char* name, void** ptr) {
+  *ptr = (void*) GetProcAddress(lib->handle, name);
+  return uv__dlerror(lib, *ptr ? 0 : GetLastError());
 }
 
 
-const char *uv_dlerror(uv_lib_t library) {
-  char* buf = NULL;
-  FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
-                 FORMAT_MESSAGE_IGNORE_INSERTS, NULL, saved_errno,
-                 MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), (LPSTR)&buf, 0, NULL);
-  return buf;
+const char* uv_dlerror(uv_lib_t* lib) {
+  return lib->errmsg ? lib->errmsg : "no error";
 }
 
 
-void uv_dlerror_free(uv_lib_t library, const char *msg) {
-  LocalFree((LPVOID)msg);
+static int uv__dlerror(uv_lib_t* lib, int errorno) {
+  if (lib->errmsg) {
+    LocalFree((void*)lib->errmsg);
+    lib->errmsg = NULL;
+  }
+
+  if (errorno) {
+    FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
+                   FORMAT_MESSAGE_IGNORE_INSERTS, NULL, errorno,
+                   MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
+                   (LPSTR)&lib->errmsg, 0, NULL);
+  }
+
+  return errorno ? -1 : 0;
 }