asyncengine 0.0.1.testing1 → 0.0.2.alpha1

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

@@ -24,6 +24,7 @@
 
 #include "uv.h"
 #include "internal.h"
+#include "req-inl.h"
 
 
 /*
@@ -77,23 +78,21 @@ static uv_err_code uv_translate_eai_error(int eai_errno) {
 
 /* getaddrinfo worker thread implementation */
 static DWORD WINAPI getaddrinfo_thread_proc(void* parameter) {
-  uv_getaddrinfo_t* handle = (uv_getaddrinfo_t*) parameter;
-  uv_loop_t* loop = handle->loop;
+  uv_getaddrinfo_t* req = (uv_getaddrinfo_t*) parameter;
+  uv_loop_t* loop = req->loop;
   int ret;
 
-  assert(handle != NULL);
+  assert(req != NULL);
 
-  if (handle != NULL) {
-    /* call OS function on this thread */
-    ret = GetAddrInfoW(handle->node,
-                       handle->service,
-                       handle->hints,
-                       &handle->res);
-    handle->retcode = ret;
+  /* call OS function on this thread */
+  ret = GetAddrInfoW(req->node,
+                     req->service,
+                     req->hints,
+                     &req->res);
+  req->retcode = ret;
 
-    /* post getaddrinfo completed */
-    POST_COMPLETION_FOR_REQ(loop, &handle->getadddrinfo_req);
-  }
+  /* post getaddrinfo completed */
+  POST_COMPLETION_FOR_REQ(loop, req);
 
   return 0;
 }
@@ -108,8 +107,7 @@ static DWORD WINAPI getaddrinfo_thread_proc(void* parameter) {
  * and copy all structs and referenced strings into the one block.
  * Each size calculation is adjusted to avoid unaligned pointers.
  */
-void uv_process_getaddrinfo_req(uv_loop_t* loop, uv_getaddrinfo_t* handle,
-    uv_req_t* req) {
+void uv_process_getaddrinfo_req(uv_loop_t* loop, uv_getaddrinfo_t* req) {
   int addrinfo_len = 0;
   int name_len = 0;
   size_t addrinfo_struct_len = ALIGNED_SIZE(sizeof(struct addrinfo));
@@ -120,15 +118,15 @@ void uv_process_getaddrinfo_req(uv_loop_t* loop, uv_getaddrinfo_t* handle,
   int status = 0;
 
   /* release input parameter memory */
-  if (handle->alloc != NULL) {
-    free(handle->alloc);
-    handle->alloc = NULL;
+  if (req->alloc != NULL) {
+    free(req->alloc);
+    req->alloc = NULL;
   }
 
-  if (handle->retcode == 0) {
+  if (req->retcode == 0) {
     /* convert addrinfoW to addrinfo */
     /* first calculate required length */
-    addrinfow_ptr = handle->res;
+    addrinfow_ptr = req->res;
     while (addrinfow_ptr != NULL) {
       addrinfo_len += addrinfo_struct_len +
           ALIGNED_SIZE(addrinfow_ptr->ai_addrlen);
@@ -150,7 +148,7 @@ void uv_process_getaddrinfo_req(uv_loop_t* loop, uv_getaddrinfo_t* handle,
     /* do conversions */
     if (alloc_ptr != NULL) {
       cur_ptr = alloc_ptr;
-      addrinfow_ptr = handle->res;
+      addrinfow_ptr = req->res;
 
       while (addrinfow_ptr != NULL) {
         /* copy addrinfo struct data */
@@ -206,21 +204,21 @@ void uv_process_getaddrinfo_req(uv_loop_t* loop, uv_getaddrinfo_t* handle,
     }
   } else {
     /* GetAddrInfo failed */
-    uv__set_artificial_error(loop, uv_translate_eai_error(handle->retcode));
+    uv__set_artificial_error(loop, uv_translate_eai_error(req->retcode));
     status = -1;
   }
 
   /* return memory to system */
-  if (handle->res != NULL) {
-    FreeAddrInfoW(handle->res);
-    handle->res = NULL;
+  if (req->res != NULL) {
+    FreeAddrInfoW(req->res);
+    req->res = NULL;
   }
 
 complete:
-  /* finally do callback with converted result */
-  handle->getaddrinfo_cb(handle, status, (struct addrinfo*)alloc_ptr);
+  uv__req_unregister(loop, req);
 
-  uv_unref(loop);
+  /* finally do callback with converted result */
+  req->getaddrinfo_cb(req, status, (struct addrinfo*)alloc_ptr);
 }
 
 
@@ -237,7 +235,7 @@ void uv_freeaddrinfo(struct addrinfo* ai) {
 /*
  * Entry point for getaddrinfo
  * we convert the UTF-8 strings to UNICODE
- * and save the UNICODE string pointers in the handle
+ * and save the UNICODE string pointers in the req
  * We also copy hints so that caller does not need to keep memory until the
  * callback.
  * return UV_OK if a callback will be made
@@ -248,7 +246,7 @@ void uv_freeaddrinfo(struct addrinfo* ai) {
  * Each size calculation is adjusted to avoid unaligned pointers.
  */
 int uv_getaddrinfo(uv_loop_t* loop,
-                   uv_getaddrinfo_t* handle,
+                   uv_getaddrinfo_t* req,
                    uv_getaddrinfo_cb getaddrinfo_cb,
                    const char* node,
                    const char* service,
@@ -258,18 +256,18 @@ int uv_getaddrinfo(uv_loop_t* loop,
   int hintssize = 0;
   char* alloc_ptr = NULL;
 
-  if (handle == NULL || getaddrinfo_cb == NULL ||
+  if (req == NULL || getaddrinfo_cb == NULL ||
      (node == NULL && service == NULL)) {
     uv__set_sys_error(loop, WSAEINVAL);
     goto error;
   }
 
-  uv_req_init(loop, (uv_req_t*)handle);
+  uv_req_init(loop, (uv_req_t*)req);
 
-  handle->getaddrinfo_cb = getaddrinfo_cb;
-  handle->res = NULL;
-  handle->type = UV_GETADDRINFO;
-  handle->loop = loop;
+  req->getaddrinfo_cb = getaddrinfo_cb;
+  req->res = NULL;
+  req->type = UV_GETADDRINFO;
+  req->loop = loop;
 
   /* calculate required memory size for all input values */
   if (node != NULL) {
@@ -300,12 +298,12 @@ int uv_getaddrinfo(uv_loop_t* loop,
   }
 
   /* save alloc_ptr now so we can free if error */
-  handle->alloc = (void*)alloc_ptr;
+  req->alloc = (void*)alloc_ptr;
 
   /* convert node string to UTF16 into allocated memory and save pointer in */
-  /* handle */
+  /* the reques. */
   if (node != NULL) {
-    handle->node = (wchar_t*)alloc_ptr;
+    req->node = (wchar_t*)alloc_ptr;
     if (uv_utf8_to_utf16(node,
                          (wchar_t*) alloc_ptr,
                          nodesize / sizeof(wchar_t)) == 0) {
@@ -314,13 +312,13 @@ int uv_getaddrinfo(uv_loop_t* loop,
     }
     alloc_ptr += nodesize;
   } else {
-    handle->node = NULL;
+    req->node = NULL;
   }
 
   /* convert service string to UTF16 into allocated memory and save pointer */
-  /* in handle */
+  /* in the req. */
   if (service != NULL) {
-    handle->service = (wchar_t*)alloc_ptr;
+    req->service = (wchar_t*)alloc_ptr;
     if (uv_utf8_to_utf16(service,
                          (wchar_t*) alloc_ptr,
                          servicesize / sizeof(wchar_t)) == 0) {
@@ -329,44 +327,39 @@ int uv_getaddrinfo(uv_loop_t* loop,
     }
     alloc_ptr += servicesize;
   } else {
-    handle->service = NULL;
+    req->service = NULL;
   }
 
-  /* copy hints to allocated memory and save pointer in handle */
+  /* copy hints to allocated memory and save pointer in req */
   if (hints != NULL) {
-    handle->hints = (struct addrinfoW*)alloc_ptr;
-    handle->hints->ai_family = hints->ai_family;
-    handle->hints->ai_socktype = hints->ai_socktype;
-    handle->hints->ai_protocol = hints->ai_protocol;
-    handle->hints->ai_flags = hints->ai_flags;
-    handle->hints->ai_addrlen = 0;
-    handle->hints->ai_canonname = NULL;
-    handle->hints->ai_addr = NULL;
-    handle->hints->ai_next = NULL;
+    req->hints = (struct addrinfoW*)alloc_ptr;
+    req->hints->ai_family = hints->ai_family;
+    req->hints->ai_socktype = hints->ai_socktype;
+    req->hints->ai_protocol = hints->ai_protocol;
+    req->hints->ai_flags = hints->ai_flags;
+    req->hints->ai_addrlen = 0;
+    req->hints->ai_canonname = NULL;
+    req->hints->ai_addr = NULL;
+    req->hints->ai_next = NULL;
   } else {
-    handle->hints = NULL;
+    req->hints = NULL;
   }
 
-  /* init request for Post handling */
-  uv_req_init(loop, &handle->getadddrinfo_req);
-  handle->getadddrinfo_req.data = handle;
-  handle->getadddrinfo_req.type = UV_GETADDRINFO_REQ;
-
   /* Ask thread to run. Treat this as a long operation */
   if (QueueUserWorkItem(&getaddrinfo_thread_proc,
-                        handle,
+                        req,
                         WT_EXECUTELONGFUNCTION) == 0) {
     uv__set_sys_error(loop, GetLastError());
     goto error;
   }
 
-  uv_ref(loop);
+  uv__req_register(loop, req);
 
   return 0;
 
 error:
-  if (handle != NULL && handle->alloc != NULL) {
-    free(handle->alloc);
+  if (req != NULL && req->alloc != NULL) {
+    free(req->alloc);
   }
   return -1;
 }

data/ext/asyncengine/libuv/src/win/handle-inl.h

@@ -0,0 +1,145 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef UV_WIN_HANDLE_INL_H_
+#define UV_WIN_HANDLE_INL_H_
+
+#include <assert.h>
+
+#include "uv.h"
+#include "internal.h"
+
+
+#define DECREASE_ACTIVE_COUNT(loop, handle)                             \
+  do {                                                                  \
+    if (--(handle)->activecnt == 0 &&                                   \
+        !((handle)->flags & UV_HANDLE_CLOSING)) {                       \
+      uv__handle_stop((handle));                                        \
+    }                                                                   \
+    assert((handle)->activecnt >= 0);                                   \
+  } while (0)
+
+
+#define INCREASE_ACTIVE_COUNT(loop, handle)                             \
+  do {                                                                  \
+    if ((handle)->activecnt++ == 0) {                                   \
+      uv__handle_start((handle));                                       \
+    }                                                                   \
+    assert((handle)->activecnt > 0);                                    \
+  } while (0)
+
+
+#define DECREASE_PENDING_REQ_COUNT(handle)                              \
+  do {                                                                  \
+    assert(handle->reqs_pending > 0);                                   \
+    handle->reqs_pending--;                                             \
+                                                                        \
+    if (handle->flags & UV_HANDLE_CLOSING &&                            \
+        handle->reqs_pending == 0) {                                    \
+      uv_want_endgame(loop, (uv_handle_t*)handle);                      \
+    }                                                                   \
+  } while (0)
+
+
+#define uv__handle_close(handle)                                        \
+  do {                                                                  \
+    ngx_queue_remove(&(handle)->handle_queue);                          \
+    (handle)->flags |= UV_HANDLE_CLOSED;                                \
+    if ((handle)->close_cb) {                                           \
+      (handle)->close_cb((uv_handle_t*)(handle));                       \
+    }                                                                   \
+  } while (0)
+
+
+INLINE static void uv_want_endgame(uv_loop_t* loop, uv_handle_t* handle) {
+  if (!(handle->flags & UV_HANDLE_ENDGAME_QUEUED)) {
+    handle->flags |= UV_HANDLE_ENDGAME_QUEUED;
+
+    handle->endgame_next = loop->endgame_handles;
+    loop->endgame_handles = handle;
+  }
+}
+
+
+INLINE static void uv_process_endgames(uv_loop_t* loop) {
+  uv_handle_t* handle;
+
+  while (loop->endgame_handles) {
+    handle = loop->endgame_handles;
+    loop->endgame_handles = handle->endgame_next;
+
+    handle->flags &= ~UV_HANDLE_ENDGAME_QUEUED;
+
+    switch (handle->type) {
+      case UV_TCP:
+        uv_tcp_endgame(loop, (uv_tcp_t*) handle);
+        break;
+
+      case UV_NAMED_PIPE:
+        uv_pipe_endgame(loop, (uv_pipe_t*) handle);
+        break;
+
+      case UV_TTY:
+        uv_tty_endgame(loop, (uv_tty_t*) handle);
+        break;
+
+      case UV_UDP:
+        uv_udp_endgame(loop, (uv_udp_t*) handle);
+        break;
+
+      case UV_POLL:
+        uv_poll_endgame(loop, (uv_poll_t*) handle);
+        break;
+
+      case UV_TIMER:
+        uv_timer_endgame(loop, (uv_timer_t*) handle);
+        break;
+
+      case UV_PREPARE:
+      case UV_CHECK:
+      case UV_IDLE:
+        uv_loop_watcher_endgame(loop, handle);
+        break;
+
+      case UV_ASYNC:
+        uv_async_endgame(loop, (uv_async_t*) handle);
+        break;
+
+      case UV_PROCESS:
+        uv_process_endgame(loop, (uv_process_t*) handle);
+        break;
+
+      case UV_FS_EVENT:
+        uv_fs_event_endgame(loop, (uv_fs_event_t*) handle);
+        break;
+
+      case UV_FS_POLL:
+        uv__fs_poll_endgame(loop, (uv_fs_poll_t*) handle);
+        break;
+
+      default:
+        assert(0);
+        break;
+    }
+  }
+}
+
+#endif /* UV_WIN_HANDLE_INL_H_ */

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

@@ -24,6 +24,7 @@
 
 #include "uv.h"
 #include "internal.h"
+#include "handle-inl.h"
 
 
 uv_handle_type uv_guess_handle(uv_file file) {
@@ -56,28 +57,17 @@ uv_handle_type uv_guess_handle(uv_file file) {
 }
 
 
-int uv_is_active(uv_handle_t* handle) {
-  switch (handle->type) {
-    case UV_TIMER:
-    case UV_IDLE:
-    case UV_PREPARE:
-    case UV_CHECK:
-      return (handle->flags & UV_HANDLE_ACTIVE) ? 1 : 0;
-
-    default:
-      return 1;
-  }
+int uv_is_active(const uv_handle_t* handle) {
+  return (handle->flags & UV__HANDLE_ACTIVE) &&
+        !(handle->flags & UV_HANDLE_CLOSING);
 }
 
 
 void uv_close(uv_handle_t* handle, uv_close_cb cb) {
-  uv_pipe_t* pipe;
-  uv_udp_t* udp;
-  uv_process_t* process;
-
   uv_loop_t* loop = handle->loop;
 
   if (handle->flags & UV_HANDLE_CLOSING) {
+    assert(0);
     return;
   }
 
@@ -87,16 +77,11 @@ void uv_close(uv_handle_t* handle, uv_close_cb cb) {
   /* Handle-specific close actions */
   switch (handle->type) {
     case UV_TCP:
-      uv_tcp_close((uv_tcp_t*)handle);
+      uv_tcp_close(loop, (uv_tcp_t*)handle);
       return;
 
     case UV_NAMED_PIPE:
-      pipe = (uv_pipe_t*)handle;
-      pipe->flags &= ~(UV_HANDLE_READING | UV_HANDLE_LISTENING);
-      close_pipe(pipe, NULL, NULL);
-      if (pipe->reqs_pending == 0) {
-        uv_want_endgame(loop, handle);
-      }
+      uv_pipe_close(loop, (uv_pipe_t*) handle);
       return;
 
     case UV_TTY:
@@ -104,47 +89,53 @@ void uv_close(uv_handle_t* handle, uv_close_cb cb) {
       return;
 
     case UV_UDP:
-      udp = (uv_udp_t*) handle;
-      uv_udp_recv_stop(udp);
-      closesocket(udp->socket);
-      if (udp->reqs_pending == 0) {
-        uv_want_endgame(loop, handle);
-      }
+      uv_udp_close(loop, (uv_udp_t*) handle);
+      return;
+
+    case UV_POLL:
+      uv_poll_close(loop, (uv_poll_t*) handle);
       return;
 
     case UV_TIMER:
       uv_timer_stop((uv_timer_t*)handle);
+      uv__handle_start(handle);
       uv_want_endgame(loop, handle);
       return;
 
     case UV_PREPARE:
       uv_prepare_stop((uv_prepare_t*)handle);
+      uv__handle_start(handle);
       uv_want_endgame(loop, handle);
       return;
 
     case UV_CHECK:
       uv_check_stop((uv_check_t*)handle);
+      uv__handle_start(handle);
       uv_want_endgame(loop, handle);
       return;
 
     case UV_IDLE:
       uv_idle_stop((uv_idle_t*)handle);
+      uv__handle_start(handle);
       uv_want_endgame(loop, handle);
       return;
 
     case UV_ASYNC:
-      if (!((uv_async_t*)handle)->async_sent) {
-        uv_want_endgame(loop, handle);
-      }
+      uv_async_close(loop, (uv_async_t*) handle);
       return;
 
     case UV_PROCESS:
-      process = (uv_process_t*)handle;
-      uv_process_close(loop, process);
+      uv_process_close(loop, (uv_process_t*) handle);
       return;
 
     case UV_FS_EVENT:
-      uv_fs_event_close(loop, (uv_fs_event_t*)handle);
+      uv_fs_event_close(loop, (uv_fs_event_t*) handle);
+      return;
+
+    case UV_FS_POLL:
+      uv__fs_poll_close((uv_fs_poll_t*) handle);
+      uv__handle_start(handle);
+      uv_want_endgame(loop, handle);
       return;
 
     default:
@@ -154,72 +145,6 @@ void uv_close(uv_handle_t* handle, uv_close_cb cb) {
 }
 
 
-int uv_is_closing(uv_handle_t* handle) {
+int uv_is_closing(const uv_handle_t* handle) {
   return handle->flags & (UV_HANDLE_CLOSING | UV_HANDLE_CLOSED);
 }
-
-
-void uv_want_endgame(uv_loop_t* loop, uv_handle_t* handle) {
-  if (!(handle->flags & UV_HANDLE_ENDGAME_QUEUED)) {
-    handle->flags |= UV_HANDLE_ENDGAME_QUEUED;
-
-    handle->endgame_next = loop->endgame_handles;
-    loop->endgame_handles = handle;
-  }
-}
-
-
-void uv_process_endgames(uv_loop_t* loop) {
-  uv_handle_t* handle;
-
-  while (loop->endgame_handles && loop->refs > 0) {
-    handle = loop->endgame_handles;
-    loop->endgame_handles = handle->endgame_next;
-
-    handle->flags &= ~UV_HANDLE_ENDGAME_QUEUED;
-
-    switch (handle->type) {
-      case UV_TCP:
-        uv_tcp_endgame(loop, (uv_tcp_t*) handle);
-        break;
-
-      case UV_NAMED_PIPE:
-        uv_pipe_endgame(loop, (uv_pipe_t*) handle);
-        break;
-
-      case UV_TTY:
-        uv_tty_endgame(loop, (uv_tty_t*) handle);
-        break;
-
-      case UV_UDP:
-        uv_udp_endgame(loop, (uv_udp_t*) handle);
-        break;
-
-      case UV_TIMER:
-        uv_timer_endgame(loop, (uv_timer_t*) handle);
-        break;
-
-      case UV_PREPARE:
-      case UV_CHECK:
-      case UV_IDLE:
-        uv_loop_watcher_endgame(loop, handle);
-        break;
-
-      case UV_ASYNC:
-        uv_async_endgame(loop, (uv_async_t*) handle);
-        break;
-
-      case UV_PROCESS:
-        uv_process_endgame(loop, (uv_process_t*) handle);
-        break;
-
-      case UV_FS_EVENT:
-        uv_fs_event_endgame(loop, (uv_fs_event_t*) handle);
-        break;
-
-      default:
-        assert(0);
-        break;
-    }
-  }
-}