iodine 0.4.11 → 0.4.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8def4f63c04685ba532ad67250a13099e9cc2a72
-  data.tar.gz: 9586665f6508a1fa66d2db4f62bfdd4fb5e20711
+  metadata.gz: aca722c23efafe6e1253f5ab4f9cea5157ded7eb
+  data.tar.gz: 3cd0891b931b59d0474a8dc0f4acdb67a1775923
 SHA512:
-  metadata.gz: b2c1d1a6e6fab1cc794ac8e8148b171fa774a7c7c06055b67ccd6cfbd58da83a005f9abb8b1726e555404fe1baee9031ad73c8d5aa9b7d4660e5e2de87a38102
-  data.tar.gz: 2126c8d8c4e370b042909b1e0c376bdbddf9d68a128894b1a2040652b96aac2e287714d755cb815b1dc0d2e0d52b50943af4ae40b75b06107c7586bf25d30a08
+  metadata.gz: fe7c754d170ec52fe96b77bcd2b18a79586e5d3cd6db4bff5f3ba834e32060b470fb3c5fce9799a9868af7cb832143d396ccc1216691f0a3a17887b06124b72a
+  data.tar.gz: '09be0eccb8cf2a065be75bb2ae96c4e4cc9ea79fc29a7864d122d59aa743ec709551fd345dbb6a79f0910685fc061edc8dee1e1c33649cd2992e931e0654eef4'

data/ext/iodine/fiobj_hash.c

@@ -13,7 +13,7 @@ Feel free to copy, use and enjoy according to the license provided.
 #include <errno.h>
 /* *****************************************************************************
 Internal Map Array
-We avoid the fiobj_ary_s to prevent entanglement
+We avoid the fiobj_ary_s to prevent code entanglement
 ***************************************************************************** */
 
 static inline void fio_map_reset(fio_map_s *map, uintptr_t capa) {

data/ext/iodine/iodine.c

@@ -321,12 +321,18 @@ static VALUE iodine_start(VALUE self) {
 Debug
 ***************************************************************************** */
 
+/** Used for debugging purpuses. Lists GC protected objects */
 VALUE iodine_print_registry(VALUE self) {
   Registry.print();
   return Qnil;
   (void)self;
 }
 
+/* *****************************************************************************
+Library Initialization
+***************************************************************************** */
+
+/** Any patches required by the running environment for consistent behavior */
 static void patch_env(void) {
 #ifdef __APPLE__
   /* patch for dealing with the High Sierra `fork` limitations */
@@ -334,10 +340,6 @@ static void patch_env(void) {
 #endif
 }
 
-/* *****************************************************************************
-Library Initialization
-***************************************************************************** */
-
 ////////////////////////////////////////////////////////////////////////
 // Ruby loads the library and invokes the Init_<lib_name> function...
 //

data/ext/iodine/websocket_parser.h

@@ -194,9 +194,29 @@ Message wrapping
 // clang-format on
 
 #ifdef __BIG_ENDIAN__
-/** stub byte swap 64 bit integer */
+/** stub byte swap 64 bit integer from pointer */
+static inline uint64_t netpiswap64(uint8_t *i) {
+  uint64_t ret = 0;
+  uint8_t *const pret = &ret;
+  pret[7] = i[7];
+  pret[6] = i[6];
+  pret[5] = i[5];
+  pret[4] = i[4];
+  pret[3] = i[3];
+  pret[2] = i[2];
+  pret[1] = i[1];
+  pret[0] = i[0];
+  return ret;
+}
+/** stub byte swap 16 bit integer from pointer */
+static inline uint16_t netpiswap16(uint8_t *i) {
+  uint16_t ret = 0;
+  uint8_t *const pret = (uint8_t *)&ret;
+  pret[1] = i[1];
+  pret[0] = i[0];
+  return ret;
+}
 #define netiswap64(i) (i)
-/** stub byte swap 16 bit integer */
 #define netiswap16(i) (i)
 
 #else
@@ -209,6 +229,28 @@ Message wrapping
    (((i)&0xFF000000000000ULL) >> 40) | (((i)&0xFF00000000000000ULL) >> 56))
 /** byte swap 16 bit integer */
 #define netiswap16(i) ((((i)&0x00ff) << 8) | (((i)&0xff00) >> 8))
+/** byte swap 64 bit integer from pointer */
+static inline uint64_t netpiswap64(uint8_t *i) {
+  uint64_t ret = 0;
+  uint8_t *const pret = (uint8_t *)&ret;
+  pret[0] = i[7];
+  pret[1] = i[6];
+  pret[2] = i[5];
+  pret[3] = i[4];
+  pret[4] = i[3];
+  pret[5] = i[2];
+  pret[6] = i[1];
+  pret[7] = i[0];
+  return ret;
+}
+/** byte swap 16 bit integer from pointer */
+static inline uint16_t netpiswap16(uint8_t *i) {
+  uint16_t ret = 0;
+  uint8_t *const pret = (uint8_t *)&ret;
+  pret[0] = i[1];
+  pret[1] = i[0];
+  return ret;
+}
 
 #endif
 
@@ -260,13 +302,23 @@ static uint64_t websocket_server_wrap(void *target, void *msg, uint64_t len,
   } else if (len < (1UL << 16)) {
     /* head is 4 bytes */
     ((uint8_t *)target)[1] = 126;
-    ((uint16_t *)target)[1] = netiswap16(len);
+    const uint16_t net_len = netiswap16(len);
+    ((uint8_t *)target)[2] = ((uint8_t *)(&net_len))[0];
+    ((uint8_t *)target)[3] = ((uint8_t *)(&net_len))[1];
     memcpy((uint8_t *)target + 4, msg, len);
     return len + 4;
   }
   /* Really Long Message  */
   ((uint8_t *)target)[1] = 127;
-  ((uint64_t *)((uint8_t *)target + 2))[0] = netiswap64(len);
+  const uint64_t net_len = netiswap16(len);
+  ((uint8_t *)target)[2] = ((uint8_t *)(&net_len))[0];
+  ((uint8_t *)target)[3] = ((uint8_t *)(&net_len))[1];
+  ((uint8_t *)target)[4] = ((uint8_t *)(&net_len))[2];
+  ((uint8_t *)target)[5] = ((uint8_t *)(&net_len))[3];
+  ((uint8_t *)target)[6] = ((uint8_t *)(&net_len))[4];
+  ((uint8_t *)target)[7] = ((uint8_t *)(&net_len))[5];
+  ((uint8_t *)target)[8] = ((uint8_t *)(&net_len))[6];
+  ((uint8_t *)target)[9] = ((uint8_t *)(&net_len))[7];
   memcpy((uint8_t *)target + 10, msg, len);
   return len + 10;
 }
@@ -295,23 +347,42 @@ static uint64_t websocket_client_wrap(void *target, void *msg, uint64_t len,
                            /*fin*/ ((last & 1) << 7);
   if (len < 126) {
     ((uint8_t *)target)[1] = len | 128;
-    ((uint32_t *)((uint8_t *)target + 2))[0] = mask;
+    ((uint8_t *)target)[2] = ((uint8_t *)(&mask))[0];
+    ((uint8_t *)target)[3] = ((uint8_t *)(&mask))[1];
+    ((uint8_t *)target)[4] = ((uint8_t *)(&mask))[2];
+    ((uint8_t *)target)[5] = ((uint8_t *)(&mask))[3];
     memcpy(((uint8_t *)target) + 6, msg, len);
     websocket_xmask((uint8_t *)target + 6, len, mask);
     return len + 6;
   } else if (len < (1UL << 16)) {
     /* head is 4 bytes */
     ((uint8_t *)target)[1] = 126 | 128;
-    ((uint16_t *)target)[1] = netiswap16(len);
-    ((uint32_t *)((uint8_t *)target + 4))[0] = mask;
+    const uint16_t net_len = netiswap16(len);
+    ((uint8_t *)target)[2] = ((uint8_t *)(&net_len))[0];
+    ((uint8_t *)target)[3] = ((uint8_t *)(&net_len))[1];
+    ((uint8_t *)target)[4] = ((uint8_t *)(&mask))[0];
+    ((uint8_t *)target)[5] = ((uint8_t *)(&mask))[1];
+    ((uint8_t *)target)[6] = ((uint8_t *)(&mask))[2];
+    ((uint8_t *)target)[7] = ((uint8_t *)(&mask))[3];
     memcpy((uint8_t *)target + 8, msg, len);
     websocket_xmask((uint8_t *)target + 8, len, mask);
     return len + 8;
   }
   /* Really Long Message  */
   ((uint8_t *)target)[1] = 255;
-  ((uint64_t *)((uint8_t *)target + 2))[0] = netiswap64(len);
-  ((uint32_t *)((uint8_t *)target + 10))[0] = mask;
+  const uint64_t net_len = netiswap16(len);
+  ((uint8_t *)target)[2] = ((uint8_t *)(&net_len))[0];
+  ((uint8_t *)target)[3] = ((uint8_t *)(&net_len))[1];
+  ((uint8_t *)target)[4] = ((uint8_t *)(&net_len))[2];
+  ((uint8_t *)target)[5] = ((uint8_t *)(&net_len))[3];
+  ((uint8_t *)target)[6] = ((uint8_t *)(&net_len))[4];
+  ((uint8_t *)target)[7] = ((uint8_t *)(&net_len))[5];
+  ((uint8_t *)target)[8] = ((uint8_t *)(&net_len))[6];
+  ((uint8_t *)target)[9] = ((uint8_t *)(&net_len))[7];
+  ((uint8_t *)target)[10] = ((uint8_t *)(&mask))[0];
+  ((uint8_t *)target)[11] = ((uint8_t *)(&mask))[1];
+  ((uint8_t *)target)[12] = ((uint8_t *)(&mask))[2];
+  ((uint8_t *)target)[13] = ((uint8_t *)(&mask))[3];
   memcpy((uint8_t *)target + 14, msg, len);
   websocket_xmask((uint8_t *)target + 14, len, mask);
   return len + 14;
@@ -331,31 +402,28 @@ Message unwrapping
 inline static struct websocket_packet_info_s
 websocket_buffer_peek(void *buffer, uint64_t len) {
   if (len < 2) {
-    return (struct websocket_packet_info_s){0, 2, 0};
+    return (struct websocket_packet_info_s){0 /* packet */, 2 /* head */,
+                                            0 /* masked? */};
   }
   const uint8_t mask_f = (((uint8_t *)buffer)[1] >> 7) & 1;
   const uint8_t mask_l = (mask_f << 2);
-  uint8_t len_indicator = (((uint8_t *)buffer)[1] & 127);
-  if (len < 126) {
-    return (struct websocket_packet_info_s){len_indicator,
-                                            (uint8_t)(2 + mask_l), mask_f};
-  }
+  uint8_t len_indicator = ((((uint8_t *)buffer)[1]) & 127);
   switch (len_indicator) {
   case 126:
     if (len < 4)
       return (struct websocket_packet_info_s){0, (uint8_t)(4 + mask_l), mask_f};
     return (struct websocket_packet_info_s){
-        (uint64_t)netiswap16(((uint16_t *)buffer)[1]), (uint8_t)(4 + mask_l),
+        (uint64_t)netpiswap16(((uint8_t *)buffer) + 2), (uint8_t)(4 + mask_l),
         mask_f};
   case 127:
     if (len < 10)
       return (struct websocket_packet_info_s){0, (uint8_t)(10 + mask_l),
                                               mask_f};
     return (struct websocket_packet_info_s){
-        netiswap64(((uint64_t *)((uint8_t *)buffer + 2))[0]),
-        (uint8_t)(10 + mask_l), mask_f};
+        netpiswap64(((uint8_t *)buffer) + 2), (uint8_t)(10 + mask_l), mask_f};
   default:
-    return (struct websocket_packet_info_s){0, 0, 0};
+    return (struct websocket_packet_info_s){len_indicator,
+                                            (uint8_t)(2 + mask_l), mask_f};
   }
 }
 
@@ -416,13 +484,13 @@ static uint64_t websocket_consume(void *buffer, uint64_t len, void *udata,
       websocket_on_protocol_error(udata);
     }
     /* step forward */
-    reminder -= info.head_length + info.packet_length;
+    reminder = reminder - (info.head_length + info.packet_length);
+    if (!reminder)
+      return 0;
     pos += info.head_length + info.packet_length;
     info = websocket_buffer_peek(pos, reminder);
   }
   /* reset buffer state - support pipelining */
-  if (!reminder)
-    return 0;
   memmove(buffer, (uint8_t *)buffer + len - reminder, reminder);
   return reminder;
 }

data/ext/iodine/websockets.c

@@ -267,13 +267,12 @@ static void on_data(intptr_t sockfd, protocol_s *ws_) {
     }
   }
 
-  ssize_t len = sock_read(sockfd, (uint8_t *)ws->buffer.data + ws->length,
-                          ws->buffer.size - ws->length);
+  const ssize_t len = sock_read(sockfd, (uint8_t *)ws->buffer.data + ws->length,
+                                ws->buffer.size - ws->length);
   if (len <= 0) {
     return;
   }
-  ws->length += len;
-  ws->length = websocket_consume(ws->buffer.data, ws->length, ws, 1);
+  ws->length = websocket_consume(ws->buffer.data, ws->length + len, ws, 1);
 
   facil_force_event(sockfd, FIO_EVENT_ON_DATA);
 }

data/lib/iodine.rb

@@ -57,7 +57,7 @@ require 'iodine/iodine'
 # * {Iodine.connect} creates a new TCP/IP connection using the specified Protocol.
 # * {Iodine.listen} listens to new TCP/IP connections using the specified Protocol.
 # * {Iodine.listen2http} listens to new TCP/IP connections using the buildin HTTP / Websocket Protocol.
-# * {Iodine.warmup} warms up and HTTP Rack applications.
+# * {Iodine.warmup} warms up any HTTP Rack applications.
 # * {Iodine.count} counts the number of connections (including HTTP / Websocket connections).
 # * {Iodine::Protocol.each} runs a code of block for every connection sharing the process (except HTTP / Websocket connections).
 # * {Iodine::Websocket.each} runs a code of block for every existing websocket sharing the process.
@@ -74,7 +74,7 @@ require 'iodine/iodine'
 # * {Iodine.publish} publishes a message to a Pub/Sub channel. The message will be sent to all subscribers - connections, other processes in the cluster and even other machines (when using the {Iodine::PubSub::RedisEngine}).
 # * {Iodine.default_pubsub=}, {Iodine.default_pubsub} sets or gets the default Pub/Sub {Iodine::PubSub::Engine}. i.e., when set to a new {Iodine::PubSub::RedisEngine} instance, all Pub/Sub method calls will use the Redis engine (unless explicitly requiring a different engine).
 #
-# {Iodine::Websocket} objects have a seperate Pub/Sub implementation that manages the subscription's lifetime to match the connection's lifetime and allows direct client Pub/Sub (forwards the message to the client directly).
+# {Iodine::Websocket} objects have a seperate Pub/Sub implementation that manages the subscription's lifetime to match the connection's lifetime and allows direct client Pub/Sub (forwards the message to the client directly without invoking the Ruby interpreter).
 #
 # == Patching Rack
 #
@@ -149,7 +149,9 @@ module Iodine
   # Runs the warmup sequence. {warmup} attempts to get every "autoloaded" (lazy loaded)
   # file to load now instead of waiting for "first access". This allows multi-threaded safety and better memory utilization during forking.
   #
-  # Use {warmup} when either {processes} or {threads} are set to more then 1.
+  # However, `warmup` might cause undefined behavior and should be avoided when using gems that initiate network / database connections or gems that spawn threads (i.e., ActiveRecord / ActiveCable).
+  #
+  # Use {warmup} when either {processes} or {threads} are set to more then 1 and gems don't spawn threads or initialize network connections.
   def self.warmup app
     # load anything marked with `autoload`, since autoload isn't thread safe nor fork friendly.
     Iodine.run do

data/lib/iodine/cli.rb

@@ -2,8 +2,9 @@ require 'iodine'
 require 'rack'
 
 module Iodine
+  # The Iodine::Base namespace is reserved for internal use and is NOT part of the public API.
   module Base
-    # Command line interface
+    # Command line interface. The Ruby CLI might be changed in future versions.
     module CLI
 
       def print_help

data/lib/iodine/monkeypatch.rb

@@ -1,4 +1,5 @@
 module Iodine
+  # The Iodine::Base namespace is reserved for internal use and is NOT part of the public API.
   module Base
     # Iodine does NOT monkey patch automatically at this time.
     #

data/lib/iodine/pubsub.rb

@@ -1,9 +1,7 @@
 module Iodine
    # Iodine is equiped with an internal pub/sub service that allows improved resource management from a deployment perspective.
    #
-   # As described by [Wikipedia](https://en.wikipedia.org/wiki/Publish–subscribe_pattern):
-   #
-   #    publish–subscribe is a messaging pattern where senders of messages, called publishers, do not program the messages to be sent directly to specific receivers, called subscribers, but instead characterize published messages into classes without knowledge of which subscribers, if any, there may be. Similarly, subscribers express interest in one or more classes and only receive messages that are of interest, without knowledge of which publishers, if any, there are.
+   # @note From {https://en.wikipedia.org/wiki/Publish–subscribe_pattern Wikipedia}: publish–subscribe is a messaging pattern where senders of messages, called publishers, do not program the messages to be sent directly to specific receivers, called subscribers, but instead characterize published messages into classes without knowledge of which subscribers, if any, there may be. Similarly, subscribers express interest in one or more classes and only receive messages that are of interest, without knowledge of which publishers, if any, there are.
    #
    # The common paradigm, which is implemented by pub/sub services like Redis,
    # is for a "client" to "subscribe" to one or more "channels". Messages are streamed

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.4.11'.freeze
+  VERSION = '0.4.12'.freeze
 end

data/lib/rack/handler/iodine.rb

@@ -135,7 +135,7 @@ module Iodine
         @app = app
       end
       @port = options[:Port].to_s if options[:Port]
-      @port = options[:Address].to_s if options[:Address]
+      @address = options[:Address].to_s if options[:Address]
 
       # # provide Websocket features using Rack::Websocket
       # Rack.send :remove_const, :Websocket if defined?(Rack::Websocket)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.4.11
+  version: 0.4.12
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-10-21 00:00:00.000000000 Z
+date: 2017-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack