asyncengine 0.0.1.testing1 → 0.0.2.alpha1

data/ext/asyncengine/libuv/src/cares.c

@@ -0,0 +1,225 @@
+/* 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.
+ */
+
+#include "uv.h"
+#include "tree.h"
+#include "uv-common.h"
+
+#include <assert.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+struct uv_ares_task_s {
+  UV_HANDLE_FIELDS
+  ares_socket_t sock;
+  uv_poll_t poll_watcher;
+  RB_ENTRY(uv_ares_task_s) node;
+};
+
+
+static int cmp_ares_tasks(const uv_ares_task_t* a, const uv_ares_task_t* b) {
+  if (a->sock < b->sock) return -1;
+  if (a->sock > b->sock) return 1;
+  return 0;
+}
+
+
+RB_GENERATE_STATIC(uv__ares_tasks, uv_ares_task_s, node, cmp_ares_tasks)
+
+
+/* Add ares handle to list. */
+static void uv_add_ares_handle(uv_loop_t* loop, uv_ares_task_t* handle) {
+  assert(loop == handle->loop);
+  RB_INSERT(uv__ares_tasks, &loop->ares_handles, handle);
+}
+
+
+/* Find matching ares handle in list. */
+static uv_ares_task_t* uv_find_ares_handle(uv_loop_t* loop, ares_socket_t sock) {
+  uv_ares_task_t handle;
+  handle.sock = sock;
+  return RB_FIND(uv__ares_tasks, &loop->ares_handles, &handle);
+}
+
+
+/* Remove ares handle from list. */
+static void uv_remove_ares_handle(uv_ares_task_t* handle) {
+  RB_REMOVE(uv__ares_tasks, &handle->loop->ares_handles, handle);
+}
+
+
+/* Returns 1 if the ares_handles list is empty, 0 otherwise. */
+static int uv_ares_handles_empty(uv_loop_t* loop) {
+  return RB_EMPTY(&loop->ares_handles);
+}
+
+
+/* This is called once per second by loop->timer. It is used to constantly */
+/* call back into c-ares for possibly processing timeouts. */
+static void uv__ares_timeout(uv_timer_t* handle, int status) {
+  assert(!uv_ares_handles_empty(handle->loop));
+  ares_process_fd(handle->loop->channel, ARES_SOCKET_BAD, ARES_SOCKET_BAD);
+}
+
+
+static void uv__ares_poll_cb(uv_poll_t* watcher, int status, int events) {
+  uv_loop_t* loop = watcher->loop;
+  uv_ares_task_t* task = container_of(watcher, uv_ares_task_t, poll_watcher);
+
+  /* Reset the idle timer */
+  uv_timer_again(&loop->ares_timer);
+
+  if (status < 0) {
+    /* An error happened. Just pretend that the socket is both readable and */
+    /* writable. */
+    ares_process_fd(loop->channel, task->sock, task->sock);
+    return;
+  }
+
+  /* Process DNS responses */
+  ares_process_fd(loop->channel,
+                  events & UV_READABLE ? task->sock : ARES_SOCKET_BAD,
+                  events & UV_WRITABLE ? task->sock : ARES_SOCKET_BAD);
+}
+
+
+static void uv__ares_poll_close_cb(uv_handle_t* watcher) {
+  uv_ares_task_t* task = container_of(watcher, uv_ares_task_t, poll_watcher);
+  free(task);
+}
+
+
+/* Allocates and returns a new uv_ares_task_t */
+static uv_ares_task_t* uv__ares_task_create(uv_loop_t* loop, ares_socket_t sock) {
+  uv_ares_task_t* task = (uv_ares_task_t*) malloc(sizeof *task);
+
+  if (task == NULL) {
+    /* Out of memory. */
+    return NULL;
+  }
+
+  task->loop = loop;
+  task->sock = sock;
+
+  if (uv_poll_init_socket(loop, &task->poll_watcher, sock) < 0) {
+    /* This should never happen. */
+    free(task);
+    return NULL;
+  }
+
+  return task;
+}
+
+
+/* Callback from ares when socket operation is started */
+static void uv__ares_sockstate_cb(void* data, ares_socket_t sock,
+    int read, int write) {
+  uv_loop_t* loop = (uv_loop_t*) data;
+  uv_ares_task_t* task;
+
+  task = uv_find_ares_handle(loop, sock);
+
+  if (read || write) {
+    if (!task) {
+      /* New socket */
+
+      /* If this is the first socket then start the timer. */
+      if (!uv_is_active((uv_handle_t*) &loop->ares_timer)) {
+        assert(uv_ares_handles_empty(loop));
+        uv_timer_start(&loop->ares_timer, uv__ares_timeout, 1000, 1000);
+      }
+
+      task = uv__ares_task_create(loop, sock);
+      if (task == NULL) {
+        /* This should never happen unless we're out of memory or something */
+        /* is seriously wrong. The socket won't be polled, but the the query */
+        /* will eventually time out. */
+        return;
+      }
+
+      uv_add_ares_handle(loop, task);
+    }
+
+    /* This should never fail. If it fails anyway, the query will eventually */
+    /* time out. */
+    uv_poll_start(&task->poll_watcher,
+                  (read ? UV_READABLE : 0) | (write ? UV_WRITABLE : 0),
+                  uv__ares_poll_cb);
+
+  } else {
+    /* read == 0 and write == 0 this is c-ares's way of notifying us that */
+    /* the socket is now closed. We must free the data associated with */
+    /* socket. */
+    assert(task &&
+           "When an ares socket is closed we should have a handle for it");
+
+    uv_remove_ares_handle(task);
+    uv_close((uv_handle_t*) &task->poll_watcher, uv__ares_poll_close_cb);
+
+    if (uv_ares_handles_empty(loop)) {
+      uv_timer_stop(&loop->ares_timer);
+    }
+  }
+}
+
+
+/* C-ares integration initialize and terminate */
+int uv_ares_init_options(uv_loop_t* loop, ares_channel *channelptr,
+    struct ares_options *options, int optmask) {
+  int rc;
+
+  /* only allow single init at a time */
+  if (loop->channel != NULL) {
+    uv__set_artificial_error(loop, UV_EALREADY);
+    return -1;
+  }
+
+  /* set our callback as an option */
+  options->sock_state_cb = uv__ares_sockstate_cb;
+  options->sock_state_cb_data = loop;
+  optmask |= ARES_OPT_SOCK_STATE_CB;
+
+  /* We do the call to ares_init_option for caller. */
+  rc = ares_init_options(channelptr, options, optmask);
+
+  /* if success, save channel */
+  if (rc == ARES_SUCCESS) {
+    loop->channel = *channelptr;
+  }
+
+  /* Initialize the timeout timer. The timer won't be started until the */
+  /* first socket is opened. */
+  uv_timer_init(loop, &loop->ares_timer);
+
+  return rc;
+}
+
+
+void uv_ares_destroy(uv_loop_t* loop, ares_channel channel) {
+  /* Only allow destroy if did init. */
+  if (loop->channel) {
+    uv_timer_stop(&loop->ares_timer);
+    ares_destroy(channel);
+    loop->channel = NULL;
+  }
+}

data/ext/asyncengine/libuv/src/fs-poll.c

@@ -0,0 +1,237 @@
+/* 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.
+ */
+
+#include "uv.h"
+#include "uv-common.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+static int statbuf_eq(const uv_statbuf_t* a, const uv_statbuf_t* b);
+static void timer_cb(uv_timer_t* timer, int status);
+static void poll_cb(uv_fs_t* req);
+
+static uv_statbuf_t zero_statbuf;
+
+
+int uv_fs_poll_init(uv_loop_t* loop, uv_fs_poll_t* handle) {
+  /* TODO(bnoordhuis) Mark fs_req internal. */
+  uv__handle_init(loop, (uv_handle_t*)handle, UV_FS_POLL);
+  loop->counters.fs_poll_init++;
+
+  if (uv_timer_init(loop, &handle->timer_handle))
+    return -1;
+
+  handle->timer_handle.flags |= UV__HANDLE_INTERNAL;
+  uv__handle_unref(&handle->timer_handle);
+
+  return 0;
+}
+
+
+int uv_fs_poll_start(uv_fs_poll_t* handle,
+                     uv_fs_poll_cb cb,
+                     const char* path,
+                     unsigned int interval) {
+  uv_fs_t* req;
+  size_t len;
+
+  if (uv__is_active(handle))
+    return 0;
+
+  len = strlen(path) + 1;
+  req = malloc(sizeof(*req) + len);
+
+  if (req == NULL)
+    return uv__set_artificial_error(handle->loop, UV_ENOMEM);
+
+  req->data = handle;
+  handle->path = memcpy(req + 1, path, len);
+  handle->fs_req = req;
+  handle->poll_cb = cb;
+  handle->interval = interval ? interval : 1;
+  handle->start_time = uv_now(handle->loop);
+  handle->busy_polling = 0;
+  memset(&handle->statbuf, 0, sizeof(handle->statbuf));
+
+  if (uv_fs_stat(handle->loop, handle->fs_req, handle->path, poll_cb))
+    abort();
+
+  uv__handle_start(handle);
+
+  return 0;
+}
+
+
+int uv_fs_poll_stop(uv_fs_poll_t* handle) {
+  if (!uv__is_active(handle))
+    return 0;
+
+  /* Don't free the fs req if it's active. Signal poll_cb that it needs to free
+   * the req by removing the handle backlink.
+   *
+   * TODO(bnoordhuis) Have uv-unix postpone the close callback until the req
+   * finishes so we don't need this pointer / lifecycle hackery. The callback
+   * always runs on the next tick now.
+   */
+  if (handle->fs_req->data)
+    handle->fs_req->data = NULL;
+  else
+    free(handle->fs_req);
+
+  handle->fs_req = NULL;
+  handle->path = NULL;
+
+  uv_timer_stop(&handle->timer_handle);
+  uv__handle_stop(handle);
+
+  return 0;
+}
+
+
+void uv__fs_poll_close(uv_fs_poll_t* handle) {
+  uv_fs_poll_stop(handle);
+  uv_close((uv_handle_t*)&handle->timer_handle, NULL);
+}
+
+
+static void timer_cb(uv_timer_t* timer, int status) {
+  uv_fs_poll_t* handle;
+
+  handle = container_of(timer, uv_fs_poll_t, timer_handle);
+  handle->start_time = uv_now(handle->loop);
+  handle->fs_req->data = handle;
+
+  if (uv_fs_stat(handle->loop, handle->fs_req, handle->path, poll_cb))
+    abort();
+
+  assert(uv__is_active(handle));
+}
+
+
+static void poll_cb(uv_fs_t* req) {
+  uv_statbuf_t* statbuf;
+  uv_fs_poll_t* handle;
+  uint64_t interval;
+
+  handle = req->data;
+
+  if (handle == NULL) /* Handle has been stopped or closed. */
+    goto out;
+
+  assert(req == handle->fs_req);
+
+  if (req->result != 0) {
+    if (handle->busy_polling != -req->errorno) {
+      uv__set_artificial_error(handle->loop, req->errorno);
+      handle->poll_cb(handle, -1, &handle->statbuf, &zero_statbuf);
+      handle->busy_polling = -req->errorno;
+    }
+    goto out;
+  }
+
+  statbuf = req->ptr;
+
+  if (handle->busy_polling != 0)
+    if (handle->busy_polling < 0 || !statbuf_eq(&handle->statbuf, statbuf))
+      handle->poll_cb(handle, 0, &handle->statbuf, statbuf);
+
+  handle->statbuf = *statbuf;
+  handle->busy_polling = 1;
+
+out:
+  uv_fs_req_cleanup(req);
+
+  if (req->data == NULL) { /* Handle has been stopped or closed. */
+    free(req);
+    return;
+  }
+
+  req->data = NULL; /* Tell uv_fs_poll_stop() it's safe to free the req. */
+
+  /* Reschedule timer, subtract the delay from doing the stat(). */
+  interval = handle->interval;
+  interval -= (uv_now(handle->loop) - handle->start_time) % interval;
+
+  if (uv_timer_start(&handle->timer_handle, timer_cb, interval, 0))
+    abort();
+}
+
+
+static int statbuf_eq(const uv_statbuf_t* a, const uv_statbuf_t* b) {
+#ifdef _WIN32
+  return a->st_mtime == b->st_mtime
+      && a->st_size == b->st_size
+      && a->st_mode == b->st_mode;
+#else
+
+  /* Jump through a few hoops to get sub-second granularity on Linux. */
+# if __linux__
+#  if __USE_MISC /* _BSD_SOURCE || _SVID_SOURCE */
+  if (a->st_ctim.tv_nsec != b->st_ctim.tv_nsec) return 0;
+  if (a->st_mtim.tv_nsec != b->st_mtim.tv_nsec) return 0;
+#  else
+  if (a->st_ctimensec != b->st_ctimensec) return 0;
+  if (a->st_mtimensec != b->st_mtimensec) return 0;
+#  endif
+# endif
+
+  /* Jump through different hoops on OS X. */
+# if __APPLE__
+#  if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
+  if (a->st_ctimespec.tv_nsec != b->st_ctimespec.tv_nsec) return 0;
+  if (a->st_mtimespec.tv_nsec != b->st_mtimespec.tv_nsec) return 0;
+#  else
+  if (a->st_ctimensec != b->st_ctimensec) return 0;
+  if (a->st_mtimensec != b->st_mtimensec) return 0;
+#  endif
+# endif
+
+  /* TODO(bnoordhuis) Other Unices have st_ctim and friends too, provided
+   * the stars and compiler flags are right...
+   */
+
+  return a->st_ctime == b->st_ctime
+      && a->st_mtime == b->st_mtime
+      && a->st_size == b->st_size
+      && a->st_mode == b->st_mode
+      && a->st_uid == b->st_uid
+      && a->st_gid == b->st_gid
+      && a->st_ino == b->st_ino
+      && a->st_dev == b->st_dev;
+#endif
+}
+
+
+#ifdef _WIN32
+
+#include "win/internal.h"
+#include "win/handle-inl.h"
+
+void uv__fs_poll_endgame(uv_loop_t* loop, uv_fs_poll_t* handle) {
+  assert(handle->flags & UV_HANDLE_CLOSING);
+  assert(!(handle->flags & UV_HANDLE_CLOSED));
+  uv__handle_stop(handle);
+  uv__handle_close(handle);
+}
+
+#endif /* _WIN32 */