iodine 0.2.17 → 0.3.0

data/ext/iodine/http_response.h

@@ -1,211 +1,78 @@
-/*
-Copyright: Boaz segev, 2016-2017
-License: MIT
+#ifndef H_HTTP_RESPONSE_H
+#define H_HTTP_RESPONSE_H
 
-Feel free to copy, use and enjoy according to the license provided.
-*/
-#ifndef HTTP_RESPONSE
-/**
-The HttpResponse library
-========================
-
-This library helps us to write HTTP valid responses, even when we do not know
-the internals of the HTTP protocol.
-
-The response object allows us to easily update the response status (all
-responses start with the default 200 "OK" status code), write headers and cookie
-data to the header buffer and send the response's body.
-
-The response object also allows us to easily update the body size and send body
-data or open files (which will be automatically closed once sending is done).
-
-As example flow for the response could be:
-
-     ; // get an initialized HttpRequest object
-     struct HttpRequest * response = HttpResponse.create(request);
-     ; // ... write headers and body, i.e.
-     HttpResponse.write_header_cstr(response, "X-Data", "my data");
-     HttpResponse.write_body(response, "Hello World!\r\n", 14);
-     ; // release the object
-     HttpResponse.destroy(response);
-
-
---
-Thread-safety:
-
-The response object and it's API are NOT thread-safe (it is assumed that no two
-threads handle the same response at the same time).
-
-Also, the response object will link itself to a libsock buffer packet, so it
-should be created and dispatched during the same event - `sock_packet_s` objects
-shouldn't be held across events or for a period of time... In other words:
-
-**Create the response object only when you are ready to send a response**.
-
----
-Misc notes:
-The response header's buffer size is limited and too many headers will fail the
-response.
-
-The response object allows us to easily update the response status (all
-responses start with the default 200 "OK" status code), write headers and write
-cookie data to the header buffer.
-
-The response object also allows us to easily update the body size and send body
-data or open files (which will be automatically closed once sending is done).
-
-The response does NOT support chuncked encoding.
-
-The following is the response API container, use:
-
-     struct HttpRequest * response = HttpResponse.create(request);
-
-
----
-Performance:
-
-A note about using this library with the HTTP/1 protocol family (if this library
-supports HTTP/2, in the future, the use of the response object will be required,
-as it might not be possible to handle the response manually):
-
-Since this library safeguards against certain mistakes and manages an
-internal header buffer, it comes at a performance cost (it adds a layer of data
-copying to the headers).
-
-This cost is mitigated by the optional use of a response object pool, so that it
-actually saves us from using `malloc` for the headers - for some cases this is
-faster.
-
-In my performance tests, the greatest issue is this: spliting the headers from
-the body means that the socket's buffer is under-utilized on the first call to
-`send`, while sending the headers. While other operations incure minor costs,
-this is the actual reason for degraded performance when using this library.
-
-The order of performance should be considered as follows:
-
-1. Destructive: Overwriting the request's header buffer with both the response
-headers and the response data (small responses). Sending the data through the
-socket using the `Server.write` function.
-
-2. Using malloc to allocate enough memory for both the response's headers AND
-it's body.  Sending the data through the socket using the `Server.write_move`
-function.
-
-3. Using the HttpResponse object to send the response.
-
-Network issues and response properties might influence the order of performant
-solutions.
-*/
-#define HTTP_RESPONSE
-#include "http.h"
 #include "http_request.h"
+#include <stdio.h>
+#include <time.h>
 
 typedef struct {
-  /**
-The body's response length.
-
-If this isn't set manually, the first call to
-`HttpResponse.write_body` (and friends) will set the length to the length
-being written (which might be less then the total data sent, if the sending is
-fragmented).
-
-Set the value to -1 to force the HttpResponse not to write the
-`Content-Length` header.
-*/
+  /** The protocol version family (HTTP/1.1 / HTTP/2 etc'). */
+  enum HTTP_VERSION http_version;
+  /** Will be set to TRUE (1) once the headers were sent. */
+  unsigned headers_sent : 1;
+  /** Set to true when the "Date" header is written to the buffer. */
+  unsigned date_written : 1;
+  /** Set to true when the "Connection" header is written to the buffer. */
+  unsigned connection_written : 1;
+  /** Set to true when the "Content-Length" header is written to the buffer. */
+  unsigned content_length_written : 1;
+  /** Set to true in order to close the connection once the response was sent.
+   */
+  unsigned should_close : 1;
+  /** Internally used by the logging API. */
+  unsigned logged : 1;
+  /** Set this value to TRUE to indicate the request pointer should be freed. */
+  unsigned request_dupped : 1;
+  /** The response status */
+  uint16_t status;
+  /** The socket UUID for the response. */
+  intptr_t fd;
+  /** The originating request. */
+  http_request_s *request;
+  /** The body's response length.
+   *
+   * If this isn't set manually, the first call to `http_response_write_body`
+   * (and friends) will set the length to the length being written (which might
+   * be less then the total data sent, if the sending is fragmented).
+   *
+   * The value to -1 to prevents `http_response_s` from sending the
+   * `Content-Length` header.
+   */
   ssize_t content_length;
-  /**
-  The HTTP date for the response (in seconds since epoche).
-
-  Defaults to now (approximately, not exactly, uses cached data).
-
-  The date will be automatically formatted to match the HTTP protocol
-  specifications. It is better to avoid setting the "Date" header manualy.
-  */
+  /** The HTTP Date for the response (in seconds since epoche).
+   *
+   * Defaults to now (approximately, not exactly, uses cached time data).
+   *
+   * The date will be automatically formatted to match the HTTP protocol
+   * specifications.
+   *
+   * It is better to avoid setting the "Date" header manualy.
+   */
   time_t date;
-  /**
-  The HTTP date for the response (in seconds since epoche).
-
-  Defaults to now (approximately, not exactly, uses cached data).
-
-  The date will be automatically formatted to match the HTTP protocol
-  specifications. It is better to avoid setting the "Date" header manualy.
-  */
+  /** The HTTP Last-Modified date for the response (in seconds since epoche).
+   *
+   * Defaults to now (approximately, not exactly, uses cached time data).
+   *
+   * The date will be automatically formatted to match the HTTP protocol
+   * specifications.
+   *
+   * It is better to avoid setting the "Last-Modified" header manualy.
+   */
   time_t last_modified;
   /**
-  The response status
+  Internally used by the logging API.
   */
-  uint16_t status;
-  /**
-  Metadata about the response's state - don't edit this data (except the opaque
-  data, if needed).
-  */
-  struct {
-    /**
-    The request object to which this response is "responding".
-    */
-    http_request_s *request;
-    /**
-    The libsock fd UUID.
-    */
-    intptr_t fd;
-    /**
-    A `libsock` buffer packet used for header data (to avoid double copy).
-    */
-    sock_packet_s *packet;
-    /**
-    A pointer to the header's writing position.
-    */
-    char *headers_pos;
-    /**
-    Internally used by the logging API.
-    */
-    clock_t clock_start;
-    /**
-    HTTP protocol version identifier.
-    */
-    uint8_t version;
-    /**
-    Set to true once the headers were sent.
-    */
-    unsigned headers_sent : 1;
-    /**
-    Set to true when the "Date" header is written to the buffer.
-    */
-    unsigned date_written : 1;
-    /**
-    Set to true when the "Connection" header is written to the buffer.
-    */
-    unsigned connection_written : 1;
-    /**
-    Set to true when the "Content-Length" header is written to the buffer.
-    */
-    unsigned content_length_written : 1;
-    /**
-    Set to true in order to close the connection once the response was sent.
-    */
-    unsigned should_close : 1;
-    /**
-    Internally used by the logging API.
-    */
-    unsigned logged : 1;
-    /**
-    Reserved for future use.
-    */
-    unsigned rsrv : 2;
-
-  } metadata;
-
+  clock_t clock_start;
 } http_response_s;
 
 /**
 The struct HttpCookie is a helper for seting cookie data.
 
-This struct is used together with the `HttpResponse.set_cookie`. i.e.:
+This struct is used together with the `http_response_set_cookie`. i.e.:
 
-      HttpResponse.set_cookie(response, (struct HttpCookie){
+      http_response_set_cookie(response,
         .name = "my_cookie",
-        .value = "data"
-      });
+        .value = "data" );
 
 */
 typedef struct {
@@ -233,28 +100,21 @@ typedef struct {
   unsigned http_only : 1;
 } http_cookie_s;
 
-/**
-Initializes a response object with the request object. This function assumes the
-response object memory is garbage and might have been stack-allocated.
+/* *****************************************************************************
+Initialization
+***************************************************************************** */
 
-Notice that the `http_request_s` pointer must point at a valid request object
-and that the request object must remain valid until the response had been
-completed.
+/** Creates / allocates a protocol version's response object. */
+http_response_s *http_response_create(http_request_s *request);
+/** Destroys the response object. No data is sent.*/
+void http_response_destroy(http_response_s *);
+/** Sends the data and destroys the response object.*/
+void http_response_finish(http_response_s *);
 
-Hangs on failuer (waits for available resources).
-*/
-http_response_s http_response_init(http_request_s *request);
-/**
-Releases any resources held by the response object (doesn't release the response
-object itself, which might have been allocated on the stack).
+/* *****************************************************************************
+Writing data to the response object
+***************************************************************************** */
 
-This function assumes the response object might have been stack-allocated.
-*/
-void http_response_destroy(http_response_s *response);
-/** Gets a response status, as a string. */
-const char *http_response_status_str(uint16_t status);
-/** Gets the mime-type string (C string) associated with the file extension. */
-const char *http_response_ext2mime(const char *ext);
 /**
 Writes a header to the response. This function writes only the requested
 number of bytes from the header name and the requested number of bytes from
@@ -267,9 +127,9 @@ cannot be sent), the function will return -1.
 
 On success, the function returns 0.
 */
-int http_response_write_header(http_response_s *, http_headers_s header);
+int http_response_write_header_fn(http_response_s *, http_header_s header);
 #define http_response_write_header(response, ...)                              \
-  http_response_write_header(response, (http_headers_s){__VA_ARGS__})
+  http_response_write_header_fn(response, (http_header_s){__VA_ARGS__})
 
 /**
 Set / Delete a cookie using this helper function.
@@ -303,18 +163,6 @@ int http_response_set_cookie(http_response_s *, http_cookie_s);
 #define http_response_set_cookie(response, ...)                                \
   http_response_set_cookie(response, (http_cookie_s){__VA_ARGS__})
 
-/**
-Indicates that any pending data (i.e. unsent headers) should be sent and that no
-more use of the response object will be made. This will also release any
-resources aquired when the response object was initialized, similar to the
-`http_response_destroy` function.
-
-If logging was initiated and hadn't been performed, it will be performed.
-
-If the connection was already closed, the function will return -1. On success,
-the function returns 0.
-*/
-void http_response_finish(http_response_s *);
 /**
 Sends the headers (if they weren't previously sent) and writes the data to the
 underlying socket.
@@ -327,33 +175,19 @@ the function returns 0.
 int http_response_write_body(http_response_s *, const char *body,
                              size_t length);
 
-// /**
-// REVIEW: IS THIS APPLICABLE FOR HTTP/2 AS WELL? this must be a unified API.
-//
-// Sends the headers (if they weren't previously sent) and writes the data to
-// the
-// underlying socket.
-//
-// The server's outgoing buffer will take ownership of the body and free it's
-// memory using `free` once the data was sent.
-//
-// If the connection was already closed, the function will return -1. On
-// success,
-// the function returns 0.
-// */
-// int http_response_write_body_move(http_response_s*,
-//                                   const char* body,
-//                                   size_t length);
-
 /**
 Sends the headers (if they weren't previously sent) and writes the data to the
 underlying socket.
 
 The server's outgoing buffer will take ownership of the file and close it
-using `fclose` once the data was sent.
+using `close` once the data was sent.
 
 If the connection was already closed, the function will return -1. On success,
-the function returns 0.
+the function returns 0. The file is alsways closed by the function.
+
+If should be possible to destroy the response object and send an error response
+if an error is detected. The function will avoid sending any data before it
+knows the likelyhood of error is small enough.
 */
 int http_response_sendfile(http_response_s *, int source_fd, off_t offset,
                            size_t length);
@@ -387,13 +221,16 @@ int http_response_sendfile2(http_response_s *response, http_request_s *request,
                             const char *file_path_safe, size_t path_safe_len,
                             const char *file_path_unsafe,
                             size_t path_unsafe_len, uint8_t log);
-/**
-Starts counting miliseconds for log results.
-*/
+/* *****************************************************************************
+Helpers and common tasks
+***************************************************************************** */
+
+/** Gets a response status, as a string. */
+const char *http_response_status_str(uint16_t status);
+/** Gets the mime-type string (C string) associated with the file extension. */
+const char *http_response_ext2mime(const char *ext);
+
+/** Starts counting miliseconds for log results. */
 void http_response_log_start(http_response_s *);
-/**
-prints out the log to stderr.
-*/
-void http_response_log_finish(http_response_s *);
 
 #endif

data/ext/iodine/iodine_core.c

@@ -133,7 +133,7 @@ Returns `false` on error and `self` on success.
 */
 static VALUE dyn_write_urgent(VALUE self, VALUE data) {
   intptr_t fd = iodine_get_fd(self);
-  if (sock_write2(.fduuid = fd, .buffer = RSTRING(data),
+  if (sock_write2(.uuid = fd, .buffer = RSTRING(data),
                   .length = RSTRING_LEN(data), .urgent = 1))
     return Qfalse;
   return self;
@@ -149,7 +149,7 @@ static VALUE dyn_set_timeout(VALUE self, VALUE timeout) {
   unsigned int tout = FIX2UINT(timeout);
   if (tout > 255)
     tout = 255;
-  server_set_timeout(fd, tout);
+  facil_set_timeout(fd, tout);
   return self;
 }
 
@@ -158,7 +158,7 @@ Returns the connection's timeout.
 */
 static VALUE dyn_get_timeout(VALUE self) {
   intptr_t fd = iodine_get_fd(self);
-  uint8_t tout = server_get_timeout(fd);
+  uint8_t tout = facil_get_timeout(fd);
   unsigned int tout_int = tout;
   return UINT2NUM(tout_int);
 }
@@ -211,7 +211,8 @@ static VALUE dyn_defer(VALUE self) {
     return Qfalse;
   Registry.add(block);
   intptr_t fd = iodine_get_fd(self);
-  server_task(fd, dyn_perform_defer, (void *)block, dyn_defer_fallback);
+  facil_defer(.uuid = fd, .task = dyn_perform_defer, .arg = (void *)block,
+              .fallback = dyn_defer_fallback);
   return self;
 }
 
@@ -221,16 +222,15 @@ static void dyn_perform_each_task(intptr_t fd, protocol_s *protocol,
   RubyCaller.call2((VALUE)data, call_proc_id, 1,
                    &(dyn_prot(protocol)->handler));
 }
-static void dyn_finish_each_task(intptr_t fd, protocol_s *protocol,
-                                 void *data) {
-  (void)(protocol);
+static void dyn_finish_each_task(intptr_t fd, void *data) {
   (void)(fd);
   Registry.remove((VALUE)data);
 }
 
 void iodine_run_each(intptr_t origin, const char *service, VALUE block) {
-  server_each(origin, service, dyn_perform_each_task, (void *)block,
-              dyn_finish_each_task);
+  facil_each(.origin = origin, .service = service,
+             .task = dyn_perform_each_task, .arg = (void *)block,
+             .on_complete = dyn_finish_each_task);
 }
 
 /**
@@ -252,8 +252,9 @@ static VALUE dyn_each(VALUE self) {
     return Qfalse;
   Registry.add(block);
   intptr_t fd = iodine_get_fd(self);
-  server_each(fd, iodine_protocol_service, dyn_perform_each_task, (void *)block,
-              dyn_finish_each_task);
+  facil_each(.origin = fd, .service = iodine_protocol_service,
+             .task = dyn_perform_each_task, .arg = (void *)block,
+             .on_complete = dyn_finish_each_task);
   return self;
 }
 
@@ -275,8 +276,9 @@ static VALUE dyn_class_each(VALUE self) {
   if (block == Qnil)
     return Qfalse;
   Registry.add(block);
-  server_each(-1, iodine_protocol_service, dyn_perform_each_task, (void *)block,
-              dyn_finish_each_task);
+  facil_each(.origin = -1, .service = iodine_protocol_service,
+             .task = dyn_perform_each_task, .arg = (void *)block,
+             .on_complete = dyn_finish_each_task);
   return self;
 }
 
@@ -367,7 +369,7 @@ static inline protocol_s *dyn_set_protocol(intptr_t fduuid, VALUE handler,
     Registry.remove(handler);
     return NULL;
   }
-  server_set_timeout(fduuid, timeout);
+  facil_set_timeout(fduuid, timeout);
   *protocol = (dyn_protocol_s){
       .handler = handler,
       .protocol.on_data = dyn_protocol_on_data,
@@ -456,11 +458,12 @@ static VALUE iodine_listen_dyn_protocol(VALUE self, VALUE port, VALUE handler) {
     rb_raise(rb_eTypeError, "The port variable must be a Fixnum or a String.");
   if (TYPE(port) == T_FIXNUM)
     port = rb_funcall2(port, to_s_method_id, 0, NULL);
+  rb_ivar_set(self, rb_intern("_port"), port);
   // listen
-  server_listen(.port = StringValueCStr(port), .udata = (void *)handler,
-                .on_open = on_open_dyn_protocol,
-                .on_start = on_server_start_for_handler,
-                .on_finish = on_server_on_finish_for_handler);
+  facil_listen(.port = StringValueCStr(port), .udata = (void *)handler,
+               .on_open = on_open_dyn_protocol,
+               .on_start = on_server_start_for_handler,
+               .on_finish = on_server_on_finish_for_handler);
   return self;
 }
 
@@ -489,7 +492,7 @@ VALUE iodine_upgrade2basic(intptr_t fduuid, VALUE handler) {
   }
   protocol_s *protocol = dyn_set_protocol(fduuid, handler, timeout);
   if (protocol) {
-    if (server_switch_protocol(fduuid, protocol))
+    if (facil_attach(fduuid, protocol))
       dyn_protocol_on_close(protocol);
     return handler;
   }
@@ -500,6 +503,11 @@ VALUE iodine_upgrade2basic(intptr_t fduuid, VALUE handler) {
 Iodine Task Management
 */
 
+static void iodine_run_once2(void *block, void *ignr) {
+  (void)ignr;
+  RubyCaller.call((VALUE)block, call_proc_id);
+  Registry.remove((VALUE)block);
+}
 static void iodine_run_once(void *block) {
   RubyCaller.call((VALUE)block, call_proc_id);
   Registry.remove((VALUE)block);
@@ -525,10 +533,8 @@ static VALUE iodine_run_async(VALUE self) {
   if (block == Qnil)
     return Qfalse;
   Registry.add(block);
-  if (async_run(iodine_run_once, (void *)block)) {
-    server_run_after(1, iodine_run_once, (void *)block);
-    ;
-  }
+  if (defer(iodine_run_once2, (void *)block, NULL))
+    perror("ERROR: dropped defered task");
   return block;
 }
 
@@ -551,7 +557,7 @@ static VALUE iodine_run_after(VALUE self, VALUE milliseconds) {
   if (block == Qnil)
     return Qfalse;
   Registry.add(block);
-  server_run_after(milli, iodine_run_once, (void *)block);
+  facil_run_every(milli, 1, iodine_run_once, (void *)block, NULL);
   return block;
 }
 /**
@@ -591,19 +597,23 @@ static VALUE iodine_run_every(int argc, VALUE *argv, VALUE self) {
   // requires a block to be passed
   rb_need_block();
   Registry.add(block);
-  server_run_every(milli, repeat, iodine_run_always, (void *)block,
-                   (void (*)(void *))Registry.remove);
+  facil_run_every(milli, repeat, iodine_run_always, (void *)block,
+                  (void (*)(void *))Registry.remove);
   return block;
 }
 
 static VALUE iodine_count(VALUE self) {
   (void)(self);
-  return ULONG2NUM(server_count(NULL));
+  return ULONG2NUM(facil_count(NULL));
 }
 /* *****************************************************************************
 Running the server
 */
-static int sock_io_thread = 0;
+#include <pthread.h>
+
+static volatile int sock_io_thread = 0;
+static pthread_t sock_io_pthread;
+
 static void *iodine_io_thread(void *arg) {
   (void)arg;
   static const struct timespec tm = {.tv_nsec = 16777216UL};
@@ -613,10 +623,14 @@ static void *iodine_io_thread(void *arg) {
   }
   return NULL;
 }
-
-static void iodine_start_io_thread(void) {
-  pthread_t io_thread;
-  pthread_create(&io_thread, NULL, iodine_io_thread, NULL);
+static void iodine_start_io_thread(void *a1, void *a2) {
+  (void)a1;
+  (void)a2;
+  pthread_create(&sock_io_pthread, NULL, iodine_io_thread, NULL);
+}
+static void iodine_join_io_thread(void) {
+  sock_io_thread = 0;
+  pthread_join(sock_io_pthread, NULL);
 }
 
 static void *srv_start_no_gvl(void *_) {
@@ -630,12 +644,13 @@ static void *srv_start_no_gvl(void *_) {
 #ifdef _SC_NPROCESSORS_ONLN
   size_t cpu_count = sysconf(_SC_NPROCESSORS_ONLN);
   if (processes <= 0)
-    processes = (cpu_count >> 1) ? (cpu_count >> 1) : 1;
+    processes = 0;
   if (threads <= 0)
-    threads = (cpu_count >> 1) ? (cpu_count >> 1) : 1;
+    threads = 0;
 
-  if (cpu_count > 0 && (((size_t)processes << 1) < cpu_count ||
-                        (size_t)processes > (cpu_count << 1)))
+  if (processes && threads && cpu_count > 0 &&
+      (((size_t)processes << 1) < cpu_count ||
+       (size_t)processes > (cpu_count << 1)))
     fprintf(
         stderr,
         "* Performance warnning:\n"
@@ -650,21 +665,17 @@ static void *srv_start_no_gvl(void *_) {
         cpu_count, cpu_count);
 #else
   if (processes <= 0)
-    processes = 1;
+    processes = 0;
   if (threads <= 0)
-    threads = 1;
+    threads = 0;
 #endif
   sock_io_thread = 1;
-  server_run(.threads = threads, .processes = processes,
-             .on_init = iodine_start_io_thread);
-  sock_io_thread = 0;
+  defer(iodine_start_io_thread, NULL, NULL);
+  facil_run(.threads = threads, .processes = processes,
+            .on_finish = iodine_join_io_thread);
   return NULL;
 }
 
-static void unblck(void *_) {
-  (void)(_);
-  server_stop();
-}
 /**
 Starts the Iodine event loop. This will hang the thread until an interrupt
 (`^C`) signal is received.
@@ -676,7 +687,7 @@ static VALUE iodine_start(VALUE self) {
     perror("Iodine couldn't start HTTP service... port busy? ");
     return Qnil;
   }
-  rb_thread_call_without_gvl2(srv_start_no_gvl, (void *)self, unblck, NULL);
+  rb_thread_call_without_gvl2(srv_start_no_gvl, (void *)self, NULL, NULL);
 
   return self;
 }