iodine 0.4.3 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 56640878e0c4cc4794f8cf3747a398a51847b0ae
-  data.tar.gz: 0c58b292c6002ea03e068eba06f5aa75c449d236
+  metadata.gz: b38604622998dd86c23390d22f206cd77e235437
+  data.tar.gz: d82068cbc80b9ccd7aa0838efbc50e9fdfadc1f1
 SHA512:
-  metadata.gz: 193156a5098163d096af9c182ed20b7a6977234575d4fd49a81ba07d1f44dc677f8772bd6c873f79f0466b28037290463d070473eb057e4c522127e0a51d5e8a
-  data.tar.gz: ab58390cfd148cd7fa481cec9f3db47ccbe64188e993e9c34baaaab2b0eaaf51cb65c459d6a9ec0ee1315a0dcf0536d8931b72aae0d1fd2c0dd743216788aab0
+  metadata.gz: 15be0353bd34deb982497787ff2c79bff9a504410a364ba46a4fa23aebf66e1d28441b2cf6103773b02cedcb598a7c2e091d533eaff5b5acc6ce41cdfea7b695
+  data.tar.gz: 96652525a23cbd5fa0e88c69cd490502f857bb609fc3b40db073b1ccac3da3f25879213385a5d732df0b89a09c038c46f531034834cb6b1491c5ae4ac3340e3d

data/CHANGELOG.md

@@ -8,12 +8,15 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ***
 
-#### Change log v.0.4.3
+#### Change log v.0.4.4
+
+**Fix**: fixed an issue related to Ruby 2.3 optimizations of String management (an issue that didn't seem to effect Ruby 2.4). This fix disables the recyclable buffer implemented for the `on_message` Websocket callback. The callback will now receive a copy of the buffer (not the buffer itself), so there is no risk of collisions between the network buffer (managed in C) and the `on_message(data)` String (managed by Ruby).
 
-This release is a ghost hunt release, attempting to find an issue noticed only during when deploying in the Heroku production environment.
+***
 
-**Fix**: fixed a possible issue in fragmented pipelined Websocket messages. This
+#### Change log v.0.4.3
 
+**Fix**: fixed a possible issue in fragmented pipelined Websocket messages.
 
 ***
 

data/SPEC-Websocket-Draft.md

@@ -23,10 +23,12 @@ The Websocket Callback Object should be a class (or an instance of such class) w
 
 * `on_open()` WILL be called once the upgrade had completed.
 
-* `on_message(data)` WILL be called when incoming Websocket data is received. `data` will be a String with an encoding of UTF-8 for text messages and `binary` encoding for non-text messages (as specified by the Websocket Protocol).
+* `on_message(data)` (REQUIRED) WILL be called when incoming Websocket data is received. `data` will be a String with an encoding of UTF-8 for text messages and `binary` encoding for non-text messages (as specified by the Websocket Protocol).
 
     The *client* **MUST** assume that the `data` String will be a **recyclable buffer** and that it's content will be corrupted the moment the `on_message` callback returns.
 
+    Servers MAY, optionally, implement a **recyclable buffer** for the `on_message` callback. However, this is optional and it is *not* required.
+
 * `on_ready()` **MAY** be called when the state of the out-going socket buffer changes from full to not full (data can be sent to the socket). **If** `has_pending?` returns `true`, the `on_ready` callback **MUST** be called once the buffer state changes.
 
 * `on_shutdown()` MAY be called during the server's graceful shutdown process, _before_ the connection is closed and in addition to the `on_close` function (which is called _after_ the connection is closed.
@@ -67,6 +69,8 @@ Connection `ping` / `pong`, timeouts and network considerations should be implem
 
 Server settings **MAY** (not required) be provided to allow for customization and adaptation for different network environments or websocket extensions. It is **RECOMMENDED** that any settings be available as command line arguments and **not** incorporated into the application's logic.
 
+The requirement that the server extends the class of the Websocket Callback Object (instead of the client application doing so explicitly) is designed to allow the client application to be more server agnostic.
+
 ## Upgrading
 
 * **Server**: When an upgrade request is received, the server will set the `env['upgrade.websocket?']` flag to `true`, indicating that: 1. this specific request is upgradable; and 2. this server supports this specification.

data/ext/iodine/http1.c

@@ -111,12 +111,6 @@ static void http1_on_header_found(http_request_s *request,
   ((http1_request_s *)request)->header_pos += 1;
 }
 
-static void http1_on_data(intptr_t uuid, http1_protocol_s *pr);
-static void http1_on_data_def(intptr_t uuid, protocol_s *pr, void *ignr) {
-  sock_touch(uuid);
-  http1_on_data(uuid, (http1_protocol_s *)pr);
-  (void)ignr;
-}
 /* parse and call callback */
 static void http1_on_data(intptr_t uuid, http1_protocol_s *pr) {
   ssize_t result;
@@ -230,8 +224,7 @@ static void http1_on_data(intptr_t uuid, http1_protocol_s *pr) {
       /* prevent this connection from hogging the thread by pipelining endless
        * requests.
        */
-      facil_defer(.task = http1_on_data_def, .task_type = FIO_PR_LOCK_TASK,
-                  .uuid = uuid);
+      facil_force_event(uuid, FIO_EVENT_ON_DATA);
       return;
     }
   }

data/ext/iodine/iodine_websockets.c

@@ -54,70 +54,70 @@ inline static ws_s *get_ws(VALUE obj) {
 Buffer management - Rubyfy the way the buffer is handled.
 ***************************************************************************** */
 
-struct buffer_s {
-  void *data;
-  size_t size;
-};
-
-/** returns a buffer_s struct, with a buffer (at least) `size` long. */
-struct buffer_s create_ws_buffer(ws_s *owner);
-
-/** returns a buffer_s struct, with a buffer (at least) `size` long. */
-struct buffer_s resize_ws_buffer(ws_s *owner, struct buffer_s);
-
-/** releases an existing buffer. */
-void free_ws_buffer(ws_s *owner, struct buffer_s);
-
-/** Sets the initial buffer size. (4Kb)*/
-#define WS_INITIAL_BUFFER_SIZE 4096
-
-// buffer increments by 4,096 Bytes (4Kb)
-#define round_up_buffer_size(size) ((((size) >> 12) + 1) << 12)
-
-struct buffer_args {
-  struct buffer_s buffer;
-  ws_s *ws;
-};
-
-void *ruby_land_buffer(void *_buf) {
-#define args ((struct buffer_args *)(_buf))
-  if (args->buffer.data == NULL) {
-    VALUE rbbuff = rb_str_buf_new(WS_INITIAL_BUFFER_SIZE);
-    rb_ivar_set(get_handler(args->ws), iodine_buff_var_id, rbbuff);
-    rb_str_set_len(rbbuff, 0);
-    rb_enc_associate(rbbuff, IodineBinaryEncoding);
-    args->buffer.data = RSTRING_PTR(rbbuff);
-    args->buffer.size = WS_INITIAL_BUFFER_SIZE;
-
-  } else {
-    VALUE rbbuff = rb_ivar_get(get_handler(args->ws), iodine_buff_var_id);
-    rb_str_modify(rbbuff);
-    rb_str_resize(rbbuff, args->buffer.size);
-    args->buffer.data = RSTRING_PTR(rbbuff);
-    args->buffer.size = rb_str_capacity(rbbuff);
-  }
-  return NULL;
-#undef args
-}
-
-struct buffer_s create_ws_buffer(ws_s *owner) {
-  struct buffer_args args = {.ws = owner};
-  RubyCaller.call_c(ruby_land_buffer, &args);
-  return args.buffer;
-}
-
-struct buffer_s resize_ws_buffer(ws_s *owner, struct buffer_s buffer) {
-  buffer.size = round_up_buffer_size(buffer.size);
-  struct buffer_args args = {.ws = owner, .buffer = buffer};
-  RubyCaller.call_c(ruby_land_buffer, &args);
-  return args.buffer;
-}
-void free_ws_buffer(ws_s *owner, struct buffer_s buff) {
-  (void)(owner);
-  (void)(buff);
-}
-
-#undef round_up_buffer_size
+// struct buffer_s {
+//   void *data;
+//   size_t size;
+// };
+//
+// /** returns a buffer_s struct, with a buffer (at least) `size` long. */
+// struct buffer_s create_ws_buffer(ws_s *owner);
+//
+// /** returns a buffer_s struct, with a buffer (at least) `size` long. */
+// struct buffer_s resize_ws_buffer(ws_s *owner, struct buffer_s);
+//
+// /** releases an existing buffer. */
+// void free_ws_buffer(ws_s *owner, struct buffer_s);
+//
+// /** Sets the initial buffer size. (4Kb)*/
+// #define WS_INITIAL_BUFFER_SIZE 4096
+//
+// // buffer increments by 4,096 Bytes (4Kb)
+// #define round_up_buffer_size(size) ((((size) >> 12) + 1) << 12)
+//
+// struct buffer_args {
+//   struct buffer_s buffer;
+//   ws_s *ws;
+// };
+//
+// void *ruby_land_buffer(void *_buf) {
+// #define args ((struct buffer_args *)(_buf))
+//   if (args->buffer.data == NULL) {
+//     VALUE rbbuff = rb_str_buf_new(WS_INITIAL_BUFFER_SIZE);
+//     rb_ivar_set(get_handler(args->ws), iodine_buff_var_id, rbbuff);
+//     rb_str_set_len(rbbuff, 0);
+//     rb_enc_associate(rbbuff, IodineBinaryEncoding);
+//     args->buffer.data = RSTRING_PTR(rbbuff);
+//     args->buffer.size = WS_INITIAL_BUFFER_SIZE;
+//
+//   } else {
+//     VALUE rbbuff = rb_ivar_get(get_handler(args->ws), iodine_buff_var_id);
+//     rb_str_modify(rbbuff);
+//     rb_str_resize(rbbuff, args->buffer.size);
+//     args->buffer.data = RSTRING_PTR(rbbuff);
+//     args->buffer.size = rb_str_capacity(rbbuff);
+//   }
+//   return NULL;
+// #undef args
+// }
+//
+// struct buffer_s create_ws_buffer(ws_s *owner) {
+//   struct buffer_args args = {.ws = owner};
+//   RubyCaller.call_c(ruby_land_buffer, &args);
+//   return args.buffer;
+// }
+//
+// struct buffer_s resize_ws_buffer(ws_s *owner, struct buffer_s buffer) {
+//   buffer.size = round_up_buffer_size(buffer.size);
+//   struct buffer_args args = {.ws = owner, .buffer = buffer};
+//   RubyCaller.call_c(ruby_land_buffer, &args);
+//   return args.buffer;
+// }
+// void free_ws_buffer(ws_s *owner, struct buffer_s buff) {
+//   (void)(owner);
+//   (void)(buff);
+// }
+//
+// #undef round_up_buffer_size
 
 /* *****************************************************************************
 Websocket Ruby API
@@ -641,7 +641,8 @@ void ws_on_open(ws_s *ws) {
 void ws_on_close(ws_s *ws) {
   VALUE handler = get_handler(ws);
   if (!handler) {
-    fprintf(stderr, "Closing a handlerless websocket?!\n");
+    fprintf(stderr,
+            "ERROR: (iodine websockets) Closing a handlerless websocket?!\n");
     return;
   }
   RubyCaller.call(handler, iodine_on_close_func_id);
@@ -660,51 +661,43 @@ void ws_on_ready(ws_s *ws) {
     return;
   RubyCaller.call(handler, iodine_on_ready_func_id);
 }
-void ws_on_data(ws_s *ws, char *data, size_t length, uint8_t is_text) {
-  (void)(data);
-  VALUE handler = get_handler(ws);
-  if (!handler)
-    return;
-  VALUE buffer = rb_ivar_get(handler, iodine_buff_var_id);
-  if (is_text)
+
+struct ws_on_data_args_s {
+  ws_s *ws;
+  void *data;
+  size_t length;
+  uint8_t is_text;
+};
+void *ws_on_data_inGIL(void *args_) {
+  struct ws_on_data_args_s *a = args_;
+  VALUE handler = get_handler(a->ws);
+  if (!handler) {
+    fprintf(stderr, "ERROR: iodine can't find Websocket handler!\n");
+    return NULL;
+  }
+  VALUE buffer = rb_str_new(a->data, a->length);
+  if (a->is_text)
     rb_enc_associate(buffer, IodineUTF8Encoding);
   else
     rb_enc_associate(buffer, IodineBinaryEncoding);
-  rb_str_set_len(buffer, length);
-  RubyCaller.call2(handler, iodine_on_message_func_id, 1, &buffer);
+  rb_funcallv(handler, iodine_on_message_func_id, 1, &buffer);
+  return NULL;
+}
+void ws_on_data(ws_s *ws, char *data, size_t length, uint8_t is_text) {
+  struct ws_on_data_args_s a = {
+      .ws = ws, .data = data, .length = length, .is_text = is_text};
+  RubyCaller.call_c(ws_on_data_inGIL, &a);
+  (void)(data);
 }
 
 //////////////
 // Empty callbacks for default implementations.
 
-/**  Please implement your own callback for this event.
- */
+/**  Please implement your own callback for this event. */
 static VALUE empty_func(VALUE self) {
   (void)(self);
   return Qnil;
 }
-// /* The `on_message(data)` callback is the main method for any websocket
-// implementation. It is the only required callback for a websocket handler
-// (without this handler, errors will occur).
-//
-// <b>NOTICE</b>: the data passed to the `on_message` callback is the actual
-// recycble network buffer, not a copy! <b>Use `data.dup` before moving the data
-// out of the function's scope</b> to prevent data corruption (i.e. when
-// using the data within an `each` block). For example (broadcasting):
-//
-//       def on_message data
-//         msg = data.dup; # data will be overwritten once the function exists.
-//         each {|ws| ws.write msg}
-//       end
-//
-// Please override this method and implement your own callback.
-// */
-// static VALUE def_dyn_message(VALUE self, VALUE data) {
-//   fprintf(stderr,
-//           "WARNING: websocket handler on_message override missing or "
-//           "bypassed.\n");
-//   return Qnil;
-// }
 
 /* *****************************************************************************
 Upgrading
@@ -771,7 +764,7 @@ void Iodine_init_websocket(void) {
     fprintf(stderr, "WTF?!\n"), exit(-1);
   // // callbacks and handlers
   rb_define_method(IodineWebsocket, "on_open", empty_func, 0);
-  // rb_define_method(IodineWebsocket, "on_message", def_dyn_message, 1);
+  // rb_define_method(IodineWebsocket, "on_message", empty_func_message, 1);
   rb_define_method(IodineWebsocket, "on_shutdown", empty_func, 0);
   rb_define_method(IodineWebsocket, "on_close", empty_func, 0);
   rb_define_method(IodineWebsocket, "on_ready", empty_func, 0);

data/ext/iodine/sock.c

@@ -862,9 +862,10 @@ ssize_t sock_read(intptr_t uuid, void *buf, size_t count) {
     return rw->read(uuid, buf, count);
   int old_errno = errno;
   ssize_t ret = rw->read(uuid, buf, count);
-  sock_touch(uuid);
-  if (ret > 0)
+  if (ret > 0) {
+    sock_touch(uuid);
     return ret;
+  }
   if (ret < 0 && (errno == EWOULDBLOCK || errno == EAGAIN || errno == EINTR ||
                   errno == ENOTCONN)) {
     errno = old_errno;

data/ext/iodine/websockets.c

@@ -115,8 +115,6 @@ struct Websocket {
   struct buffer_s buffer;
   /** message length (how much of the buffer actually used). */
   size_t length;
-  /** for fragmenting the `on_data` parsing and message handling. */
-  size_t resume_from;
   /** parser. */
   struct {
     union {
@@ -233,12 +231,6 @@ static void websocket_write_impl(intptr_t fd, void *data, size_t len, char text,
 static size_t websocket_encode(void *buff, void *data, size_t len, char text,
                                char first, char last, char client);
 
-static void on_data(intptr_t sockfd, protocol_s *_ws);
-static void on_data_def(intptr_t sockfd, protocol_s *_ws, void *arg) {
-  on_data(sockfd, _ws);
-  (void)arg;
-}
-
 /* read data from the socket, parse it and invoke the websocket events. */
 static void on_data(intptr_t sockfd, protocol_s *_ws) {
 #define ws ((ws_s *)_ws)
@@ -246,10 +238,11 @@ static void on_data(intptr_t sockfd, protocol_s *_ws) {
     return;
   ssize_t len = 0;
   ssize_t data_len = 0;
+  read_buffer.pos = 0;
+
   if ((len = sock_read(sockfd, read_buffer.buffer, WEBSOCKET_READ_MAX)) <= 0)
     return;
-  data_len = 0;
-  read_buffer.pos = 0;
+
   while (read_buffer.pos < len) {
     // collect the frame's head
     if (!ws->parser.state.has_head) {

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.4.3'.freeze
+  VERSION = '0.4.4'.freeze
 end

data/lib/iodine/websocket.rb

@@ -7,6 +7,8 @@ module Iodine
   # * Server <=> Client relations ({Iodine::Websocket#write}, {Iodine::Websocket#close} etc')
   # * Client <=> Server <=> Client relations ({Iodine::Websocket#subscribe}, {Iodine::Websocket#publish}, etc').
   # * Task scheduling ({Iodine::Websocket.defer}, {Iodine::Websocket#defer}, {Iodine::Websocket.each}).
+  #
+  # Notice that Websocket callback objects (as specified by the {file:SPEC-Websocket-Draft.md proposed Rack specification} *MUST* provide an `on_message(data)` callback.
   module Websocket
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.4.4
 platform: ruby
 authors:
 - Boaz Segev