iodine 0.2.9 → 0.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ba4e058f674e3984cdee2cff5cb107c1b2563ecf
-  data.tar.gz: 6d733dd6ab5daea3464b2a2f2e1567e9781361a8
+  metadata.gz: 30444cc800decb8b3339bdbc34e499e8fa8d7d75
+  data.tar.gz: 6657c29ca28a5aa8ef3dd3f50e848020f256b674
 SHA512:
-  metadata.gz: 2acca1d13ceb9bfa682fe1f7aa1175349d3d092c15747b700785f9ad5117f7714ee851ac5e61cebf93c31bee793f4af38ecff504d780fdd65c575c42ab3c04a7
-  data.tar.gz: 8f182b7d745804676f2f7837f36f92419fdd7c1c740cd1a3f9fbfc66c25dbf16eb0c2f11b8454d6ecc30e4be5992c7a0c77f707e3c6f2a52962dbf4979f16fe2
+  metadata.gz: be709de0f327815d3c8366f388395f8dc26c4a1789a25d5c80e04445efd9508c746a95df6538d34fcee405c0f7458d6fa9575b256483124e72db042e5c8ad907
+  data.tar.gz: f7d0fb12ed10468ffc2a1b3297d2a214da07753570873dc79224a1ae8279034a1abe72f2a78801850606921ae851874b91854380a4b0003d914c199dfbe08589

data/CHANGELOG.md

@@ -6,6 +6,33 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+***
+
+Change log v.0.2.10 (next release)
+
+**Update**: added documentation and an extra helper method to set a connection's timeout when using custom protocols (Iodine as an EventMachine alternative).
+
+**C Layer Update** updated the [`facil.io`](http://facil.io) library used, to incorporate the following fixes / update:
+
+* Better cross platform compilation by avoiding some name-space clashes. i.e, fixes a name clash with the `__used` directive / macro, where some OSs (i.e. CentOS) used a similar directive with different semantics.
+
+* Reviewed and fixed some signed vs. unsigned integer comparisons.
+
+* Smoother event scheduling by increasing the event-node's pool size.
+
+* Smoother thread concurrency growth by managing thread `nanosleep` times as thread count dependent.
+
+* Cleared out "unused variable" warnings.
+
+* Streamlined the `accept` process to remove a double socket's data clean-up.
+
+* `SERVER_DELAY_IO` is now implemented as an event instead of a stack frame.
+
+* Fixed a possible Linux `sendfile` implementation issue where sometimes errors wouldn't be caught or `sendfile` would be called past a file's limit (edge case handling).
+
+* `bscrypt` random generator (where `dev/random` is unavailable) should now provide more entropy.
+
+
 ***
 
 Change log v.0.2.9

data/README.md

@@ -6,7 +6,9 @@
 [![Inline docs](http://inch-ci.org/github/boazsegev/iodine.svg?branch=master)](http://www.rubydoc.info/github/boazsegev/iodine/master/frames)
 [![GitHub](https://img.shields.io/badge/GitHub-Open%20Source-blue.svg)](https://github.com/boazsegev/iodine)
 
-Iodine makes writing Object Oriented **Network Services** easy to write.
+Iodine is a fast concurrent web server for real-time Ruby applications, with native support for Websockets, static file service and HTTP/1.1.
+
+Iodine also supports custom protocol authoring, making Object Oriented **Network Services** easy to write.
 
 Iodine is an **evented** framework with a simple API that builds off the low level [C code library facil.io](https://github.com/boazsegev/facil.io) with support for **epoll** and **kqueue** - this means that:
 
@@ -63,7 +65,7 @@ This means that even a Gigabyte long response will use ~32Kb of memory, as long
 
 Iodine supports static file serving that allows the server to serve static files directly, with no Ruby layer (all from C-land).
 
-This means that Iodine won't lock Ruby's GVL when sending static files (nor log these requests). The files will be sent directly, allowing for true native concurrency.
+This means that Iodine won't lock Ruby's GVL when sending static files. The files will be sent directly, allowing for true native concurrency. Since the Ruby layer is unaware of these requests, logging can be performed by turning iodine's logger on.
 
 To setup native static file service, setup the public folder's address **before** starting the server.
 
@@ -83,9 +85,17 @@ app = Proc.new { out }
 run app
 ```
 
+To enable logging from the command line, use the `-v` (verbose) option:
+
+```bash
+bundler exec iodine -p $PORT -t 16 -w 4 -www /my/public/folder -v
+```
+
 #### X-Sendfile
 
-Sending can be performed by using the `X-Sendfile` header in the Ruby application response.
+Ruby can leverage static file support (if enabled) by using the `X-Sendfile` header in the Ruby application response.
+
+This allows Ruby to send very large files using a very small memory footprint, as well as (when possible) leveraging the `sendfile` system call.
 
 i.e. (example `config.ru` for Iodine):
 
@@ -95,7 +105,7 @@ app = proc do |env|
   if request.path_info == '/source'.freeze
     [200, { 'X-Sendfile' => File.expand_path(__FILE__) }, []]
   elsif request.path_info == '/file'.freeze
-    [200, { 'X-Header' => 'This was a Rack::Sendfile response sent as text' }, File.open(__FILE__)]
+    [200, { 'X-Header' => 'This was a Rack::Sendfile response sent as text.' }, File.open(__FILE__)]
   else
     [200, { 'Content-Type'.freeze => 'text/html'.freeze,
             'Content-Length'.freeze => request.path_info.length.to_s },

data/bin/raw-rbhttp

@@ -15,21 +15,19 @@ require 'bundler/setup'
 require 'iodine'
 
 class HttpProtocol
-  @timeout = 5
+  @timeout = 10
   # `on_message` is an optional alternative to the `on_data` callback.
   # `on_message` has a 1Kb buffer that recycles itself for memory optimization.
   def on_data
     # writing will never block and will use a buffer written in C when needed.
-    data = nil
-    while (data = read)
-      write "HTTP/1.1 200 OK\r\nConnection: keep-alive\r\nKeep-Alive: timeout=1\r\nContent-Length: 12\r\n\r\nHello World!"
-    end
+    write "HTTP/1.1 200 OK\r\nConnection: keep-alive\r\nKeep-Alive: timeout=1\r\nContent-Length: 12\r\n\r\nHello World!"
   end
 end
 
 puts "thread #{Iodine.threads}"
 # Listen
 Iodine.listen '3000', HttpProtocol
-Iodine.threads = 7
+Iodine.threads = 8
+Iodine.processes = 1
 puts "now, thread #{Iodine.threads}"
 Iodine.start

data/bin/raw-rbhttp-em

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+# this will compile Iodine and run a raw sockets server that emulates HTTP (without parsing any incoming requests).
+
+# # test using:
+# ab -n 100000 -c 200 -k http://127.0.0.1:3000/
+# wrk -c200 -d4 -t12 http://localhost:3000/
+
+Dir.chdir(File.expand_path(File.join('..', '..'), __FILE__))
+# puts `rake clean`
+# puts `rake compile`
+
+require 'benchmark'
+# $LOAD_PATH.unshift File.expand_path(File.join('..', '..', 'lib'), __FILE__)
+# require 'bundler/setup'
+
+require 'eventmachine'
+
+module HttpProtocol
+  def receive_data data
+    send_data "HTTP/1.1 200 OK\r\nConnection: keep-alive\r\nKeep-Alive: timeout=1\r\nContent-Length: 12\r\n\r\nHello World!"
+  end
+end
+
+puts "Running EM emulating HTTP."
+
+if EventMachine.kqueue?
+  EventMachine.kqueue = true
+  puts "using Kqueue."
+end
+if EventMachine.epoll?
+  EventMachine.epoll = true
+  puts "using epoll."
+end
+
+# Note that this will block current thread.
+EventMachine.run {
+ EventMachine.start_server "127.0.0.1", 3030, HttpProtocol
+}
+
+#
+# require 'iodine'
+#
+# class HttpProtocol
+#   @timeout = 5
+#   # `on_message` is an optional alternative to the `on_data` callback.
+#   # `on_message` has a 1Kb buffer that recycles itself for memory optimization.
+#   def on_data
+#     # writing will never block and will use a buffer written in C when needed.
+#     data = nil
+#     while (data = read)
+#       write "HTTP/1.1 200 OK\r\nConnection: keep-alive\r\nKeep-Alive: timeout=1\r\nContent-Length: 12\r\n\r\nHello World!"
+#     end
+#   end
+# end
+#
+# puts "thread #{Iodine.threads}"
+# # Listen
+# Iodine.listen '3000', HttpProtocol
+# Iodine.threads = 7
+# Iodine.processes = 1
+# puts "now, thread #{Iodine.threads}"
+# Iodine.start

data/ext/iodine/bscrypt-common.h

@@ -57,8 +57,8 @@ and: https://software.intel.com/sites/landingpage/IntrinsicsGuide/
 #   endif
 #endif
 
-#ifndef __unused
-#   define __unused __attribute__((unused))
+#ifndef UNUSED_FUNC
+#   define UNUSED_FUNC __attribute__((unused))
 #endif
 // clang-format on
 

data/ext/iodine/http1.c

@@ -47,7 +47,7 @@ struct {
   void *memory;
   http1_protocol_s *pool;
   spn_lock_i lock;
-} http1_pool = {0};
+} http1_pool = {.memory = NULL};
 
 inline static http1_protocol_s *pool_pop() {
   http1_protocol_s *prot;
@@ -184,7 +184,7 @@ is_busy:
     p_len = 94 + http_ul2a(packet->buffer + 94, file_data.st_size);
     memcpy(packet->buffer + p_len, "\r\n\r\n", 4);
     p_len += 4;
-    if (BUFFER_PACKET_SIZE - p_len > file_data.st_size) {
+    if ((off_t)(BUFFER_PACKET_SIZE - p_len) > file_data.st_size) {
       if (read(file, packet->buffer + p_len, file_data.st_size) < 0) {
         close(file);
         sock_free_packet(packet);

data/ext/iodine/http1_simple_parser.c

@@ -297,7 +297,8 @@ ssize_t http1_parse_request_headers(void *buffer, size_t len,
   }
   // check if the body is contained within the buffer
   EAT_EOL();
-  if (request->content_length && (end - pos) >= request->content_length) {
+  if (request->content_length &&
+      (end - pos) >= (ssize_t)request->content_length) {
     request->body_str = (void *)pos;
     // fprintf(stderr,
     //         "assigning body to string. content-length %lu, buffer left: "

data/ext/iodine/http_request.h

@@ -18,8 +18,8 @@ Feel free to copy, use and enjoy according to the license provided.
 #include <strings.h>
 #include <unistd.h>
 
-#ifndef __unused
-#define __unused __attribute__((unused))
+#ifndef UNUSED_FUNC
+#define UNUSED_FUNC __attribute__((unused))
 #endif
 
 typedef struct {
@@ -97,7 +97,7 @@ typedef struct {
   http_headers_s headers[];
 } http_request_s;
 
-__unused static inline void http_request_clear(http_request_s *request) {
+UNUSED_FUNC static inline void http_request_clear(http_request_s *request) {
   if (request->body_file > 0) /* assumes no tempfile with fd 0 */
     close(request->body_file);
   *request = (http_request_s){
@@ -109,7 +109,7 @@ __unused static inline void http_request_clear(http_request_s *request) {
 
 /** searches for a header in the header array, both reaturnning it's value and
  * setting it's position in the `request->metadata.header_pos` variable.*/
-__unused static inline const char *
+UNUSED_FUNC static inline const char *
 http_request_find_header(http_request_s *request, const char *header,
                          size_t header_len) {
   if (header == NULL || request == NULL)

data/ext/iodine/http_response.c

@@ -24,6 +24,7 @@ Feel free to copy, use and enjoy according to the license provided.
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <time.h>
+#include <unistd.h>
 
 /* *****************************************************************************
 Helpers
@@ -340,7 +341,7 @@ int http_response_sendfile2(http_response_s *response, http_request_s *request,
       ext++;
     }
     // fprintf(stderr, "Start: %lu / %lld\n", start, file_data.st_size);
-    if (start >= file_data.st_size - 1)
+    if ((off_t)start >= file_data.st_size - 1)
       goto invalid_range;
     ext++;
     while (is_num(*ext)) {
@@ -349,7 +350,7 @@ int http_response_sendfile2(http_response_s *response, http_request_s *request,
       ext++;
     }
     // going to the EOF (big chunk or EOL requested) - send as file
-    if (finish >= file_data.st_size)
+    if ((off_t)finish >= file_data.st_size)
       finish = file_data.st_size;
     char *pos = buffer + 6;
     memcpy(buffer, "bytes ", 6);
@@ -405,7 +406,7 @@ no_file:
 }
 
 #ifdef RUSAGE_SELF
-const static size_t CLOCK_RESOLUTION = 1000; /* in miliseconds */
+static const size_t CLOCK_RESOLUTION = 1000; /* in miliseconds */
 static size_t get_clock_mili(void) {
   struct rusage rusage;
   getrusage(RUSAGE_SELF, &rusage);

data/ext/iodine/http_response_http1.h

@@ -12,8 +12,8 @@ Feel free to copy, use and enjoy according to the license provided.
 #include "http_response.h"
 // clang-format on
 
-#ifndef __unused
-#define __unused __attribute__((unused))
+#ifndef UNUSED_FUNC
+#define UNUSED_FUNC __attribute__((unused))
 #endif
 
 /* *****************************************************************************
@@ -63,7 +63,7 @@ static inline int h1p_protected_copy(http_response_s *response,
 
 /* this function assume the padding in `h1p_protected_copy` saved enough room
  * for the data to be safely written.*/
-__unused static inline sock_packet_s *
+UNUSED_FUNC static inline sock_packet_s *
 h1p_finalize_headers(http_response_s *response) {
   if (HEADERS_FINISHED(response))
     return NULL;
@@ -157,7 +157,7 @@ static int h1p_send_headers(http_response_s *response, sock_packet_s *packet) {
 Implementation
 ***************************************************************************** */
 
-__unused static inline int h1p_response_write_header(http_response_s *response,
+UNUSED_FUNC static inline int h1p_response_write_header(http_response_s *response,
                                                      http_headers_s header) {
   if (HEADERS_FINISHED(response) || header.name == NULL)
     return -1;
@@ -179,7 +179,7 @@ __unused static inline int h1p_response_write_header(http_response_s *response,
 /**
 Set / Delete a cookie using this helper function.
 */
-__unused static int h1p_response_set_cookie(http_response_s *response,
+UNUSED_FUNC static int h1p_response_set_cookie(http_response_s *response,
                                             http_cookie_s cookie) {
   if (HEADERS_FINISHED(response) || cookie.name == NULL ||
       overflowing(response))
@@ -287,7 +287,7 @@ __unused static int h1p_response_set_cookie(http_response_s *response,
 /**
 Sends the headers (if unsent) and sends the body.
 */
-__unused static inline int h1p_response_write_body(http_response_s *response,
+UNUSED_FUNC static inline int h1p_response_write_body(http_response_s *response,
                                                    const char *body,
                                                    size_t length) {
   if (!response->content_length)
@@ -298,7 +298,7 @@ __unused static inline int h1p_response_write_body(http_response_s *response,
         ((BUFFER_PACKET_SIZE - H1P_HEADER_START) - headers->length);
     if (i_read > 1024) {
       /* we can fit at least some of the data inside the response buffer. */
-      if (i_read > length) {
+      if ((size_t)i_read > length) {
         i_read = length;
         /* we can fit the data inside the response buffer. */
         memcpy(response->metadata.headers_pos, body, i_read);
@@ -322,7 +322,7 @@ __unused static inline int h1p_response_write_body(http_response_s *response,
 /**
 Sends the headers (if unsent) and schedules the file to be sent.
 */
-__unused static inline int h1p_response_sendfile(http_response_s *response,
+UNUSED_FUNC static inline int h1p_response_sendfile(http_response_s *response,
                                                  int source_fd, off_t offset,
                                                  size_t length) {
   if (!response->content_length)
@@ -337,7 +337,7 @@ __unused static inline int h1p_response_sendfile(http_response_s *response,
           source_fd, response->metadata.headers_pos,
           ((BUFFER_PACKET_SIZE - H1P_HEADER_START) - headers->length), offset);
       if (i_read > 0) {
-        if (i_read >= length) {
+        if ((size_t)i_read >= length) {
           headers->length += length;
           close(source_fd);
           return h1p_send_headers(response, headers);
@@ -358,7 +358,7 @@ __unused static inline int h1p_response_sendfile(http_response_s *response,
   return sock_sendfile(response->metadata.fd, source_fd, offset, length);
 }
 
-__unused static inline int h1p_response_finish(http_response_s *response) {
+UNUSED_FUNC static inline int h1p_response_finish(http_response_s *response) {
   sock_packet_s *headers = h1p_finalize_headers(response);
   if (headers) {
     return h1p_send_headers(response, headers);

data/ext/iodine/iodine_core.c

@@ -96,7 +96,7 @@ static VALUE dyn_read(int argc, VALUE *argv, VALUE self) {
     len = rb_str_capacity(buffer);
     // make sure the string is modifiable
     rb_str_modify(buffer);
-    // resize te string if needed.
+    // resize the string if needed.
     if (len < 1024)
       rb_str_resize(buffer, (len = 1024));
     str = buffer;
@@ -139,6 +139,30 @@ static VALUE dyn_write_urgent(VALUE self, VALUE data) {
   return self;
 }
 
+/**
+Update's a connection's timeout.
+
+Returns self.
+*/
+static VALUE dyn_set_timeout(VALUE self, VALUE timeout) {
+  intptr_t fd = iodine_get_fd(self);
+  unsigned int tout = FIX2UINT(timeout);
+  if (tout > 255)
+    tout = 255;
+  server_set_timeout(fd, tout);
+  return self;
+}
+
+/**
+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);
+  unsigned int tout_int = tout;
+  return UINT2NUM(tout_int);
+}
+
 /**
 Closes a connection.
 
@@ -157,10 +181,13 @@ The Core dynamic Iodine protocol task implementation
 */
 
 static void dyn_perform_defer(intptr_t uuid, protocol_s *protocol, void *arg) {
+  (void)(uuid);
+  (void)(protocol);
   RubyCaller.call((VALUE)arg, call_proc_id);
   Registry.remove((VALUE)arg);
 }
 static void dyn_defer_fallback(intptr_t uuid, void *arg) {
+  (void)(uuid);
   Registry.remove((VALUE)arg);
 };
 
@@ -190,11 +217,14 @@ static VALUE dyn_defer(VALUE self) {
 
 static void dyn_perform_each_task(intptr_t fd, protocol_s *protocol,
                                   void *data) {
+  (void)(fd);
   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);
+  (void)(fd);
   Registry.remove((VALUE)data);
 }
 
@@ -268,9 +298,16 @@ static VALUE not_implemented_ping(VALUE self) {
   return Qnil;
 }
 /** implement this callback to handle the event. */
-static VALUE not_implemented(VALUE self) { return Qnil; }
+static VALUE not_implemented(VALUE self) {
+  (void)(self);
+  return Qnil;
+}
 /** implement this callback to handle the event. */
-static VALUE not_implemented2(VALUE self, VALUE data) { return Qnil; }
+static VALUE not_implemented2(VALUE self, VALUE data) {
+  (void)(self);
+  (void)(data);
+  return Qnil;
+}
 
 /**
 A default on_data implementation will read up to 1Kb into a reusable buffer from
@@ -295,15 +332,18 @@ static VALUE default_on_data(VALUE self) {
 
 /** called when a data is available, but will not run concurrently */
 static void dyn_protocol_on_data(intptr_t fduuid, protocol_s *protocol) {
+  (void)(fduuid);
   RubyCaller.call(dyn_prot(protocol)->handler, on_data_func_id);
 }
 /** called when the socket is ready to be written to. */
 static void dyn_protocol_on_ready(intptr_t fduuid, protocol_s *protocol) {
+  (void)(fduuid);
   RubyCaller.call(dyn_prot(protocol)->handler, on_ready_func_id);
 }
 /** called when the server is shutting down,
  * but before closing the connection. */
 static void dyn_protocol_on_shutdown(intptr_t fduuid, protocol_s *protocol) {
+  (void)(fduuid);
   RubyCaller.call(dyn_prot(protocol)->handler, on_shutdown_func_id);
 }
 /** called when the connection was closed, but will not run concurrently */
@@ -314,9 +354,10 @@ static void dyn_protocol_on_close(protocol_s *protocol) {
 }
 /** called when a connection's timeout was reached */
 static void dyn_protocol_ping(intptr_t fduuid, protocol_s *protocol) {
+  (void)(fduuid);
   RubyCaller.call(dyn_prot(protocol)->handler, ping_func_id);
 }
-
+/** Update's a connection's handler and timeout. */
 static inline protocol_s *dyn_set_protocol(intptr_t fduuid, VALUE handler,
                                            uint8_t timeout) {
   Registry.add(handler);
@@ -339,6 +380,7 @@ static inline protocol_s *dyn_set_protocol(intptr_t fduuid, VALUE handler,
   RubyCaller.call(handler, on_open_func_id);
   return (protocol_s *)protocol;
 }
+
 static protocol_s *on_open_dyn_protocol(intptr_t fduuid, void *udata) {
   VALUE rb_tout = rb_ivar_get((VALUE)udata, timeout_var_id);
   uint8_t timeout = (TYPE(rb_tout) == T_FIXNUM) ? FIX2UINT(rb_tout) : 0;
@@ -385,6 +427,8 @@ void Init_DynamicProtocol(void) {
   rb_define_method(DynamicProtocol, "defer", dyn_defer, 0);
   rb_define_method(DynamicProtocol, "each", dyn_each, 0);
   rb_define_method(DynamicProtocol, "upgrade", dyn_upgrade, 1);
+  rb_define_method(DynamicProtocol, "timeout=", dyn_set_timeout, 1);
+  rb_define_method(DynamicProtocol, "timeout", dyn_get_timeout, 0);
 }
 
 /* *****************************************************************************
@@ -474,6 +518,7 @@ will be delayed until Iodine.start is called, unless Iodine's event loop is
 active).
 */
 static VALUE iodine_run_async(VALUE self) {
+  (void)(self);
   // requires a block to be passed
   rb_need_block();
   VALUE block = rb_block_proc();
@@ -494,6 +539,7 @@ Time is counted only once Iodine started running (using {Iodine.start}).
 Always returns a copy of the block object.
 */
 static VALUE iodine_run_after(VALUE self, VALUE milliseconds) {
+  (void)(self);
   if (TYPE(milliseconds) != T_FIXNUM) {
     rb_raise(rb_eTypeError, "milliseconds must be a number");
     return Qnil;
@@ -526,6 +572,7 @@ The event will repeat itself until the number of repetitions had been delpeted.
 Always returns a copy of the block object.
 */
 static VALUE iodine_run_every(int argc, VALUE *argv, VALUE self) {
+  (void)(self);
   VALUE milliseconds, repetitions, block;
 
   rb_scan_args(argc, argv, "11&", &milliseconds, &repetitions, &block);
@@ -549,12 +596,16 @@ static VALUE iodine_run_every(int argc, VALUE *argv, VALUE self) {
   return block;
 }
 
-static VALUE iodine_count(VALUE self) { return ULONG2NUM(server_count(NULL)); }
+static VALUE iodine_count(VALUE self) {
+  (void)(self);
+  return ULONG2NUM(server_count(NULL));
+}
 /* *****************************************************************************
 Running the server
 */
 
 static void *srv_start_no_gvl(void *_) {
+  (void)(_);
   // collect requested settings
   VALUE rb_th_i = rb_iv_get(Iodine, "@threads");
   VALUE rb_pr_i = rb_iv_get(Iodine, "@processes");
@@ -591,7 +642,10 @@ static void *srv_start_no_gvl(void *_) {
   return NULL;
 }
 
-static void unblck(void *_) { server_stop(); }
+static void unblck(void *_) {
+  (void)(_);
+  server_stop();
+}
 /**
 Starts the Iodine event loop. This will hang the thread until an interrupt
 (`^C`) signal is received.