iodine 0.2.9 → 0.2.10

data/ext/iodine/iodine_http.c

@@ -240,6 +240,8 @@ static int for_each_header_data(VALUE key, VALUE val, VALUE _res) {
 
 // writes the body to the response object
 static VALUE for_each_body_string(VALUE str, VALUE _res, int argc, VALUE argv) {
+  (void)(argv);
+  (void)(argc);
   // fprintf(stderr, "For_each - body\n");
   // write body
   if (TYPE(str) != T_STRING) {
@@ -264,6 +266,7 @@ static VALUE for_each_body_string(VALUE str, VALUE _res, int argc, VALUE argv) {
 
 static inline int ruby2c_response_send(http_response_s *response,
                                        VALUE rbresponse, VALUE env) {
+  (void)(env);
   VALUE body = rb_ary_entry(rbresponse, 2);
   if (response->status < 200 || response->status == 204 ||
       response->status == 304) {
@@ -551,7 +554,7 @@ int iodine_http_review(void) {
     VALUE iodine_version = rb_const_get(Iodine, rb_intern("VERSION"));
     VALUE ruby_version = rb_const_get(Iodine, rb_intern("RUBY_VERSION"));
     if (public_folder)
-      fprintf(stderr, "Starting up Iodine Http Server:\n"
+      fprintf(stderr, "Starting up Iodine HTTP Server:\n"
                       " * Ruby v.%s\n * Iodine v.%s \n"
                       " * %lu max concurrent connections / open files\n"
                       " * Serving static files from:\n"
@@ -559,7 +562,7 @@ int iodine_http_review(void) {
               StringValueCStr(ruby_version), StringValueCStr(iodine_version),
               (size_t)sock_max_capacity(), public_folder);
     else
-      fprintf(stderr, "Starting up Iodine Http Server:\n"
+      fprintf(stderr, "Starting up Iodine HTTP Server:\n"
                       " * Ruby v.%s\n * Iodine v.%s \n"
                       " * %lu max concurrent connections / open files\n"
                       "\n",

data/ext/iodine/libasync.c

@@ -1,12 +1,12 @@
 /*
-copyright: Boaz segev, 2016-2017
+copyright: Boaz Segev, 2016-2017
 license: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
 */
-// clang-format off
-#include "rb-libasync.h"
-// clang-format on
+
+#include "rb-libasync.h" // enable this line for Iodine's Ruby
+
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
 #endif
@@ -30,7 +30,7 @@ Performance options.
 */
 
 #ifndef ASYNC_TASK_POOL_SIZE
-#define ASYNC_TASK_POOL_SIZE 170
+#define ASYNC_TASK_POOL_SIZE 1024
 #endif
 
 /* Spinlock vs. Mutex data protection. */
@@ -40,7 +40,7 @@ Performance options.
 
 /* use pipe for wakeup if == 0 else, use nanosleep when no tasks. */
 #ifndef ASYNC_NANO_SLEEP
-#define ASYNC_NANO_SLEEP 16777216 // 8388608  // 1048576  // 524288
+#define ASYNC_NANO_SLEEP 8388608 // 1048576  // 524288 // 16777216
 #endif
 
 /* Sentinal thread to respawn crashed threads - limited crash resistance. */
@@ -253,7 +253,9 @@ static inline void pause_thread() {
     read(async->io.in, &tmp, 1);
   }
 #else
-  struct timespec act, tm = {.tv_sec = 0, .tv_nsec = ASYNC_NANO_SLEEP};
+  struct timespec act,
+      tm = {.tv_sec = 0,
+            .tv_nsec = ASYNC_NANO_SLEEP * (async ? async->thread_count : 1)};
   nanosleep(&tm, &act);
 // sched_yield();
 #endif
@@ -298,7 +300,8 @@ static void on_err_signal(int sig) {
 }
 
 // The worker cycle
-static void *worker_thread_cycle(void *_) {
+static void *worker_thread_cycle(void *unused) {
+  (void)(unused);
   // register error signals when using a sentinal
   if (ASYNC_USE_SENTINEL) {
     signal(SIGSEGV, on_err_signal);
@@ -385,6 +388,11 @@ Use:
 */
 void async_perform() { perform_tasks(); }
 
+/**
+Returns TRUE (not 0) if there are any pending tasks.
+*/
+int async_any(void) { return (async && async->tasks); }
+
 /**
 Schedules a task to be performed by the thread pool.
 
@@ -462,19 +470,22 @@ Test
 static spn_lock_i i_lock = SPN_LOCK_INIT;
 static size_t i_count = 0;
 
-static void sample_task(void *_) {
+static void sample_task(void *unused) {
+  (void)(unused);
   spn_lock(&i_lock);
   i_count++;
   spn_unlock(&i_lock);
 }
 
-static void sched_sample_task(void *_) {
+static void sched_sample_task(void *unused) {
+  (void)(unused);
   for (size_t i = 0; i < 1024; i++) {
     async_run(sample_task, async);
   }
 }
 
-static void text_task_text(void *_) {
+static void text_task_text(void *unused) {
+  (void)(unused);
   spn_lock(&i_lock);
   fprintf(stderr, "this text should print before async_finish returns\n");
   spn_unlock(&i_lock);

data/ext/iodine/libasync.h

@@ -1,5 +1,5 @@
 /*
-Copyright: Boaz segev, 2016-2017
+Copyright: Boaz Segev, 2016-2017
 License: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
@@ -57,6 +57,11 @@ Use:
 */
 void async_perform();
 
+/**
+Returns TRUE (not 0) if there are any pending tasks.
+*/
+int async_any(void);
+
 /**
 Waits for all the present tasks to complete and threads to exist.
 

data/ext/iodine/libreact.c

@@ -1,5 +1,5 @@
 /*
-Copyright: Boaz segev, 2016-2017
+Copyright: Boaz Segev, 2016-2017
 License: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
@@ -34,7 +34,7 @@ Callbacks
 */
 
 #pragma weak reactor_on_close
-void reactor_on_close(intptr_t uuid) {}
+void reactor_on_close(intptr_t uuid) { (void)(uuid); }
 
 #pragma weak reactor_on_data
 void reactor_on_data(intptr_t uuid) {
@@ -44,14 +44,17 @@ void reactor_on_data(intptr_t uuid) {
 }
 
 #pragma weak reactor_on_ready
-void reactor_on_ready(intptr_t uuid) {}
+void reactor_on_ready(intptr_t uuid) { (void)(uuid); }
 
 /* *****************************************************************************
 Integrate the `libsock` library if exists.
 */
 
 #pragma weak sock_flush
-ssize_t sock_flush(intptr_t uuid) { return 0; }
+ssize_t sock_flush(intptr_t uuid) {
+  (void)(uuid);
+  return 0;
+}
 
 #pragma weak sock_close
 void sock_close(intptr_t uuid) {
@@ -118,7 +121,7 @@ thing.
 This method promises that the timer will be repeated when running on epoll. This
 method is redundent on kqueue.
 */
-void reactor_reset_timer(intptr_t uuid) {} /* EPoll only */
+void reactor_reset_timer(intptr_t uuid) { (void)(uuid); } /* EPoll only */
 
 /**
 Creates a timer file descriptor, system dependent.

data/ext/iodine/libreact.h

@@ -1,5 +1,5 @@
 /*
-Copyright: Boaz segev, 2016-2017
+Copyright: Boaz Segev, 2016-2017
 License: MIT
 
 Feel free to copy, use and enjoy according to the license provided.

data/ext/iodine/libserver.c

@@ -1,5 +1,5 @@
 /*
-Copyright: Boaz segev, 2016-2017
+Copyright: Boaz Segev, 2016-2017
 License: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
@@ -101,8 +101,8 @@ static void server_cleanup(void) {
   server_on_shutdown();
   // free any lock objects (no need to change code if changing locking systems)
   for (size_t i = 0; i < server_data.capacity - 1; i++) {
-    server_data.fds[i] = (fd_data_s){0};
     lock_fd_destroy(server_data.fds + i);
+    server_data.fds[i] = (fd_data_s){.protocol = NULL};
   }
   // free memory
   if (server_data.fds) {
@@ -121,7 +121,7 @@ static void init_server(void) {
                            PROT_READ | PROT_WRITE | PROT_EXEC,
                            MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
     for (size_t i = 0; i < server_data.capacity - 1; i++) {
-      server_data.fds[i] = (fd_data_s){0};
+      server_data.fds[i] = (fd_data_s){.protocol = NULL};
       lock_fd_init(server_data.fds + i);
     }
   }
@@ -219,6 +219,7 @@ http://www.microhowto.info/howto/reap_zombie_processes_using_a_sigchld_handler.h
 */
 
 void reap_child_handler(int sig) {
+  (void)(sig);
   int old_errno = errno;
   while (waitpid(-1, NULL, WNOHANG) > 0)
     ;
@@ -278,11 +279,11 @@ static void listener_on_data(intptr_t uuid, protocol_s *_listener) {
   intptr_t new_client;
   struct ListenerProtocol *listener = (void *)_listener;
   while ((new_client = sock_accept(uuid)) != -1) {
-    // make sure it's a clean slate... although it should be assumed to be.
-    lock_uuid(new_client);
-    clear_uuid(new_client);
-    unlock_uuid(new_client);
-    // assume that sock_accept calls reactor_on_close if needed
+    // assume that sock_accept calls  if needed
+    // it's a clean slate in reactor_on_close ...
+    // lock_uuid(new_client);
+    // clear_uuid(new_client);
+    // unlock_uuid(new_client);
     protocol_uuid(new_client) = listener->on_open(new_client, listener->udata);
     if (protocol_uuid(new_client)) {
       uuid_data(new_client).active = server_data.last_tick;
@@ -442,8 +443,17 @@ static inline void timeout_review(void) {
   }
 }
 
-static void server_cycle(void *_) {
+static void server_cycle(void *unused) {
+  (void)(unused);
   static int8_t perform_idle = 1;
+
+#if SERVER_DELAY_IO
+  if (async_any()) {
+    async_run(server_cycle, NULL);
+    return;
+  }
+#endif
+
   time(&server_data.last_tick);
   if (server_data.running) {
     timeout_review();
@@ -458,9 +468,6 @@ static void server_cycle(void *_) {
     } else {
       perform_idle = 1;
     }
-#if SERVER_DELAY_IO
-    async_perform();
-#endif
     async_run(server_cycle, NULL);
   }
 }
@@ -531,7 +538,7 @@ ssize_t server_run(struct ServerSettings settings) {
   pid_t *children = NULL;
   if (settings.processes > 1) {
     children = malloc(sizeof(*children) * settings.processes);
-    for (size_t i = 0; i < settings.processes - 1; i++) {
+    for (size_t i = 0; i < (size_t)(settings.processes - 1); i++) {
       if (fork() == 0)
         break;
     }
@@ -647,6 +654,17 @@ void server_set_timeout(intptr_t fd, uint8_t timeout) {
   uuid_data(fd).timeout = timeout;
   unlock_uuid(fd);
 }
+/**
+Gets a connection's timeout, type of uint8_t.
+
+A value of 0 might mean that no timeout was set OR that the connection inquired
+about was invalid.
+*/
+uint8_t server_get_timeout(intptr_t fd) {
+  if (valid_uuid(fd) == 0)
+    return 0;
+  return uuid_data(fd).timeout;
+}
 
 /** Attaches an existing connection (fd) to the server's reactor and protocol
 management system, so that the server can be used also to manage connection
@@ -770,7 +788,7 @@ static void perform_single_task(void *task) {
 static void perform_each_task(void *task) {
   intptr_t uuid;
   protocol_s *protocol;
-  while (p2task(task).target < server_data.capacity) {
+  while (p2task(task).target < (intptr_t)server_data.capacity) {
     uuid = sock_fd2uuid(p2task(task).target);
     if (uuid == -1 || uuid == p2task(task).origin) {
       ++p2task(task).target;

data/ext/iodine/libserver.h

@@ -1,5 +1,5 @@
 /*
-Copyright: Boaz segev, 2016-2017
+Copyright: Boaz Segev, 2016-2017
 License: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
@@ -45,10 +45,9 @@ messages regarding the server state (start / finish / listen messages).
 #warning Lib-Server dependency versions are not in sync. Please review API versions.
 #endif
 
-#ifndef __unused
-#define __unused __attribute__((unused))
+#ifndef UNUSED_FUNC
+#define UNUSED_FUNC __attribute__((unused))
 #endif
-
 /** \file
 ## LibServer - a dynamic protocol network services library
 
@@ -366,6 +365,13 @@ Sets a connection's timeout.
 Returns -1 on error (i.e. connection closed), otherwise returns 0.
 */
 void server_set_timeout(intptr_t uuid, uint8_t timeout);
+/**
+Returns a connection's timeout, as a `uint8_t` value.
+
+A value of 0 might mean that no timeout was set OR that the connection inquired
+about was invalid.
+*/
+uint8_t server_get_timeout(intptr_t uuid);
 
 /** Attaches an existing connection (fd) to the server's reactor and protocol
 management system, so that the server can be used also to manage connection
@@ -467,8 +473,8 @@ int server_run_every(size_t milliseconds, size_t repetitions,
 /** Creates a system timer (at the cost of 1 file descriptor) and pushes the
 timer to the reactor. The task will NOT repeat. Returns -1 on error or the
 new file descriptor on succeess. */
-__unused static inline int server_run_after(size_t milliseconds,
-                                            void task(void *), void *arg) {
+UNUSED_FUNC static inline int server_run_after(size_t milliseconds,
+                                               void task(void *), void *arg) {
   return server_run_every(milliseconds, 1, task, arg, NULL);
 }
 

data/ext/iodine/libsock.c

@@ -1,5 +1,5 @@
 /*
-Copyright: Boaz segev, 2016-2017
+Copyright: Boaz Segev, 2016-2017
 License: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
@@ -35,21 +35,28 @@ Support `libreact` on_close callback, if exist.
 */
 
 #pragma weak reactor_on_close
-void reactor_on_close(intptr_t uuid) {}
+void reactor_on_close(intptr_t uuid) { (void)(uuid); }
 #pragma weak reactor_remove
-int reactor_remove(intptr_t uuid) { return -1; }
+int reactor_remove(intptr_t uuid) {
+  (void)(uuid);
+  return -1;
+}
 
 /* *****************************************************************************
 Support timeout setting.
 */
 #pragma weak sock_touch
-void sock_touch(intptr_t uuid) {}
+void sock_touch(intptr_t uuid) { (void)(uuid); }
 
 /* *****************************************************************************
 Support event based `write` scheduling.
 */
 #pragma weak async_run
-int async_run(void (*task)(void *), void *arg) { return -1; }
+int async_run(void (*task)(void *), void *arg) {
+  (void)(task);
+  (void)(arg);
+  return -1;
+}
 
 /* *****************************************************************************
 OS Sendfile settings.
@@ -131,7 +138,7 @@ ssize_t sock_max_capacity(void) {
   flim = OPEN_MAX;
 #endif
   // try to maximize limits - collect max and set to max
-  struct rlimit rlim = {0};
+  struct rlimit rlim = {.rlim_max = 0};
   getrlimit(RLIMIT_NOFILE, &rlim);
 // printf("Meximum open files are %llu out of %llu\n", rlim.rlim_cur,
 //        rlim.rlim_max);
@@ -146,7 +153,7 @@ ssize_t sock_max_capacity(void) {
   // printf("Meximum open files are %llu out of %llu\n", rlim.rlim_cur,
   //        rlim.rlim_max);
   // if the current limit is higher than it was, update
-  if (flim < rlim.rlim_cur)
+  if (flim < ((ssize_t)rlim.rlim_cur))
     flim = rlim.rlim_cur;
   // return what we have
   return flim;
@@ -344,7 +351,7 @@ static inline int sock_flush_fd_failed(int fd) {
 
 #if defined(__linux__) /* linux sendfile API */
 static inline int sock_flush_os_sendfile(int fd) {
-  size_t sent;
+  ssize_t sent;
   sock_packet_s *packet = fd_info[fd].packet;
   sent =
       sendfile64(fd, (int)((ssize_t)packet->buffer), &packet->metadata.offset,
@@ -765,7 +772,7 @@ Returns TRUE (non 0) if there is data waiting to be written to the socket in
 the
 user-land buffer.
 */
-_Bool sock_packets_pending(intptr_t uuid) {
+int sock_packets_pending(intptr_t uuid) {
   return fd_info && uuid2info(uuid).packet != NULL;
 }
 

data/ext/iodine/libsock.h

@@ -1,5 +1,5 @@
 /*
-Copyright: Boaz segev, 2016-2017
+Copyright: Boaz Segev, 2016-2017
 License: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
@@ -25,8 +25,8 @@ The library is designed to be thread safe, but not fork safe.
 #include <sys/types.h>
 #include <unistd.h>
 
-#ifndef __unused
-#define __unused __attribute__((unused))
+#ifndef UNUSED_FUNC
+#define UNUSED_FUNC __attribute__((unused))
 #endif
 
 /* *****************************************************************************
@@ -36,7 +36,7 @@ This information is also useful when implementing read / write hooks.
 */
 #ifndef BUFFER_PACKET_SIZE
 #define BUFFER_PACKET_SIZE                                                     \
-  (1024 * 16) /* Use 32 Kb. With sendfile, 16 Kb might be better. */
+  (1024 * 16) /* Use 32 Kb. With sendfile, 16 Kb appears to work better. */
 #endif
 #ifndef BUFFER_FILE_READ_SIZE
 #define BUFFER_FILE_READ_SIZE BUFFER_PACKET_SIZE
@@ -297,8 +297,8 @@ the maximum amount of data to be sent.
 
 Returns -1 and closes the file on error. Returns 0 on success.
 */
-__unused static inline ssize_t sock_sendfile(intptr_t uuid, int source_fd,
-                                             off_t offset, size_t length) {
+UNUSED_FUNC static inline ssize_t sock_sendfile(intptr_t uuid, int source_fd,
+                                                off_t offset, size_t length) {
   return sock_write2(.fduuid = uuid, .buffer = (void *)((intptr_t)source_fd),
                      .length = length, .is_fd = 1, .offset = offset);
 }
@@ -415,7 +415,7 @@ ssize_t sock_send_packet(intptr_t uuid, sock_packet_s *packet);
 Returns TRUE (non 0) if there is data waiting to be written to the socket in the
 user-land buffer.
 */
-_Bool sock_packets_pending(intptr_t uuid);
+int sock_packets_pending(intptr_t uuid);
 
 /**
 Use `sock_free_packet` to free unused packets that were checked-out using