asyncengine 0.0.1.testing

data/ext/asyncengine_ext/libuv/src/unix/idle.c

@@ -0,0 +1,79 @@
+/* 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 "internal.h"
+
+
+static void uv__idle(EV_P_ ev_idle* w, int revents) {
+  uv_idle_t* idle = container_of(w, uv_idle_t, idle_watcher);
+
+  if (idle->idle_cb) {
+    idle->idle_cb(idle, 0);
+  }
+}
+
+
+int uv_idle_init(uv_loop_t* loop, uv_idle_t* idle) {
+  uv__handle_init(loop, (uv_handle_t*)idle, UV_IDLE);
+  loop->counters.idle_init++;
+
+  ev_idle_init(&idle->idle_watcher, uv__idle);
+  idle->idle_cb = NULL;
+
+  return 0;
+}
+
+
+int uv_idle_start(uv_idle_t* idle, uv_idle_cb cb) {
+  int was_active = ev_is_active(&idle->idle_watcher);
+
+  idle->idle_cb = cb;
+  ev_idle_start(idle->loop->ev, &idle->idle_watcher);
+
+  if (!was_active) {
+    ev_unref(idle->loop->ev);
+  }
+
+  return 0;
+}
+
+
+int uv_idle_stop(uv_idle_t* idle) {
+  int was_active = ev_is_active(&idle->idle_watcher);
+
+  ev_idle_stop(idle->loop->ev, &idle->idle_watcher);
+
+  if (was_active) {
+    ev_ref(idle->loop->ev);
+  }
+
+  return 0;
+}
+
+
+int uv__idle_active(const uv_idle_t* handle) {
+  return ev_is_active(&handle->idle_watcher);
+}
+
+
+void uv__idle_close(uv_idle_t* handle) {
+  uv_idle_stop(handle);
+}

data/ext/asyncengine_ext/libuv/src/unix/internal.h

@@ -0,0 +1,161 @@
+/* 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_UNIX_INTERNAL_H_
+#define UV_UNIX_INTERNAL_H_
+
+#include "uv-common.h"
+#include "uv-eio.h"
+
+#include <assert.h>
+#include <stdlib.h> /* abort */
+#include <stddef.h> /* offsetof */
+
+#if __STRICT_ANSI__
+# define inline __inline
+#endif
+
+#undef HAVE_FUTIMES
+#undef HAVE_KQUEUE
+#undef HAVE_PORTS_FS
+
+#if __linux__
+# include "linux/syscalls.h"
+# define HAVE_FUTIMES 1 /* emulated with utimesat() */
+#endif /* __linux__ */
+
+#if defined(__sun)
+# include <sys/port.h>
+# include <port.h>
+# ifdef PORT_SOURCE_FILE
+#  define HAVE_PORTS_FS 1
+# endif
+# define HAVE_FUTIMES 1
+# define futimes(fd, tv) futimesat(fd, (void*)0, tv)
+#endif /* __sun */
+
+#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__sun)
+# define HAVE_FUTIMES 1
+#endif
+
+/* FIXME exact copy of the #ifdef guard in uv-unix.h */
+#if defined(__APPLE__)  \
+  || defined(__FreeBSD__) \
+  || defined(__OpenBSD__) \
+  || defined(__NetBSD__)
+# define HAVE_KQUEUE 1
+#endif
+
+#define container_of(ptr, type, member) \
+  ((type *) ((char *) (ptr) - offsetof(type, member)))
+
+#define UNREACHABLE()                                                         \
+  do {                                                                        \
+    assert(0 && "unreachable code");                                          \
+    abort();                                                                  \
+  }                                                                           \
+  while (0)
+
+#define SAVE_ERRNO(block)                                                     \
+  do {                                                                        \
+    int _saved_errno = errno;                                                 \
+    do { block; } while (0);                                                  \
+    errno = _saved_errno;                                                     \
+  }                                                                           \
+  while (0)
+
+/* flags */
+enum {
+  UV_CLOSING       = 0x01,   /* uv_close() called but not finished. */
+  UV_CLOSED        = 0x02,   /* close(2) finished. */
+  UV_READING       = 0x04,   /* uv_read_start() called. */
+  UV_SHUTTING      = 0x08,   /* uv_shutdown() called but not complete. */
+  UV_SHUT          = 0x10,   /* Write side closed. */
+  UV_READABLE      = 0x20,   /* The stream is readable */
+  UV_WRITABLE      = 0x40,   /* The stream is writable */
+  UV_TCP_NODELAY   = 0x080,  /* Disable Nagle. */
+  UV_TCP_KEEPALIVE = 0x100,  /* Turn on keep-alive. */
+  UV_TIMER_ACTIVE  = 0x080,
+  UV_TIMER_REPEAT  = 0x100
+};
+
+/* core */
+void uv__handle_init(uv_loop_t* loop, uv_handle_t* handle, uv_handle_type type);
+int uv__nonblock(int fd, int set) __attribute__((unused));
+int uv__cloexec(int fd, int set) __attribute__((unused));
+int uv__socket(int domain, int type, int protocol);
+int uv__dup(int fd);
+
+/* loop */
+int uv__loop_init(uv_loop_t* loop, int default_loop);
+void uv__loop_delete(uv_loop_t* loop);
+
+/* error */
+uv_err_code uv_translate_sys_error(int sys_errno);
+void uv_fatal_error(const int errorno, const char* syscall);
+
+/* requests */
+void uv__req_init(uv_loop_t* loop, uv_req_t*);
+
+/* stream */
+void uv__stream_init(uv_loop_t* loop, uv_stream_t* stream,
+    uv_handle_type type);
+int uv__stream_open(uv_stream_t*, int fd, int flags);
+void uv__stream_destroy(uv_stream_t* stream);
+void uv__stream_io(EV_P_ ev_io* watcher, int revents);
+void uv__server_io(EV_P_ ev_io* watcher, int revents);
+int uv__accept(int sockfd, struct sockaddr* saddr, socklen_t len);
+int uv__connect(uv_connect_t* req, uv_stream_t* stream, struct sockaddr* addr,
+    socklen_t addrlen, uv_connect_cb cb);
+
+/* tcp */
+int uv_tcp_listen(uv_tcp_t* tcp, int backlog, uv_connection_cb cb);
+int uv__tcp_nodelay(uv_tcp_t* handle, int enable);
+int uv__tcp_keepalive(uv_tcp_t* handle, int enable, unsigned int delay);
+
+/* pipe */
+int uv_pipe_listen(uv_pipe_t* handle, int backlog, uv_connection_cb cb);
+void uv__pipe_accept(EV_P_ ev_io* watcher, int revents);
+
+/* various */
+int uv__check_active(const uv_check_t* handle);
+int uv__idle_active(const uv_idle_t* handle);
+int uv__prepare_active(const uv_prepare_t* handle);
+int uv__timer_active(const uv_timer_t* handle);
+
+void uv__async_close(uv_async_t* handle);
+void uv__check_close(uv_check_t* handle);
+void uv__fs_event_close(uv_fs_event_t* handle);
+void uv__idle_close(uv_idle_t* handle);
+void uv__pipe_close(uv_pipe_t* handle);
+void uv__prepare_close(uv_prepare_t* handle);
+void uv__process_close(uv_process_t* handle);
+void uv__stream_close(uv_stream_t* handle);
+void uv__timer_close(uv_timer_t* handle);
+void uv__udp_close(uv_udp_t* handle);
+void uv__udp_finish_close(uv_udp_t* handle);
+
+#define UV__F_IPC        (1 << 0)
+#define UV__F_NONBLOCK   (1 << 1)
+int uv__make_socketpair(int fds[2], int flags);
+int uv__make_pipe(int fds[2], int flags);
+
+#endif /* UV_UNIX_INTERNAL_H_ */

data/ext/asyncengine_ext/libuv/src/unix/kqueue.c

@@ -0,0 +1,127 @@
+/* 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 "internal.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include <sys/sysctl.h>
+#include <sys/types.h>
+#include <sys/event.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <time.h>
+
+static void uv__fs_event(EV_P_ ev_io* w, int revents);
+
+
+static void uv__fs_event_start(uv_fs_event_t* handle) {
+  ev_io_init(&handle->event_watcher,
+             uv__fs_event,
+             handle->fd,
+             EV_LIBUV_KQUEUE_HACK);
+  ev_io_start(handle->loop->ev, &handle->event_watcher);
+  ev_unref(handle->loop->ev);
+}
+
+
+static void uv__fs_event_stop(uv_fs_event_t* handle) {
+  ev_ref(handle->loop->ev);
+  ev_io_stop(handle->loop->ev, &handle->event_watcher);
+}
+
+
+static void uv__fs_event(EV_P_ ev_io* w, int revents) {
+  uv_fs_event_t* handle;
+  int events;
+
+  assert(revents == EV_LIBUV_KQUEUE_HACK);
+
+  handle = container_of(w, uv_fs_event_t, event_watcher);
+
+  if (handle->fflags & (NOTE_ATTRIB | NOTE_EXTEND))
+    events = UV_CHANGE;
+  else
+    events = UV_RENAME;
+
+  handle->cb(handle, NULL, events, 0);
+
+  if (handle->fd == -1)
+    return;
+
+  /* File watcher operates in one-shot mode, re-arm it. */
+  uv__fs_event_stop(handle);
+  uv__fs_event_start(handle);
+}
+
+
+/* Called by libev, don't touch. */
+void uv__kqueue_hack(EV_P_ int fflags, ev_io *w) {
+  uv_fs_event_t* handle;
+
+  handle = container_of(w, uv_fs_event_t, event_watcher);
+  handle->fflags = fflags;
+}
+
+
+int uv_fs_event_init(uv_loop_t* loop,
+                     uv_fs_event_t* handle,
+                     const char* filename,
+                     uv_fs_event_cb cb,
+                     int flags) {
+  int fd;
+
+  loop->counters.fs_event_init++;
+
+  /* We don't support any flags yet. */
+  assert(!flags);
+
+  if (cb == NULL) {
+    uv__set_sys_error(loop, EINVAL);
+    return -1;
+  }
+
+  /* TODO open asynchronously - but how do we report back errors? */
+  if ((fd = open(filename, O_RDONLY)) == -1) {
+    uv__set_sys_error(loop, errno);
+    return -1;
+  }
+
+  uv__handle_init(loop, (uv_handle_t*)handle, UV_FS_EVENT);
+  handle->filename = strdup(filename);
+  handle->fflags = 0;
+  handle->cb = cb;
+  handle->fd = fd;
+  uv__fs_event_start(handle);
+
+  return 0;
+}
+
+
+void uv__fs_event_close(uv_fs_event_t* handle) {
+  uv__fs_event_stop(handle);
+  free(handle->filename);
+  close(handle->fd);
+  handle->fd = -1;
+}