iodine 0.2.10 → 0.2.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 30444cc800decb8b3339bdbc34e499e8fa8d7d75
-  data.tar.gz: 6657c29ca28a5aa8ef3dd3f50e848020f256b674
+  metadata.gz: 1b66fc52e683d2179b50db49e0c3912b11465cfc
+  data.tar.gz: c52e3bcb4f88dc8134a6fd0cd8c933569a7feccf
 SHA512:
-  metadata.gz: be709de0f327815d3c8366f388395f8dc26c4a1789a25d5c80e04445efd9508c746a95df6538d34fcee405c0f7458d6fa9575b256483124e72db042e5c8ad907
-  data.tar.gz: f7d0fb12ed10468ffc2a1b3297d2a214da07753570873dc79224a1ae8279034a1abe72f2a78801850606921ae851874b91854380a4b0003d914c199dfbe08589
+  metadata.gz: ce2c2217e792f1cd6b4178e0a12cfc80bf5eb7fef89113ce232799be5fb2797da2c09e399c324c189019434ee566d4083ff68cdf288eacc846c4042e76709cc7
+  data.tar.gz: c7aae4d6787b9d1442a978f66d83610f2391819e1c643099ed2fad2c78ae36d484d66e122295044b90d6d8039ab9a7fb013ef7ef9e95fa037fad3843213c3565

data/CHANGELOG.md

@@ -8,7 +8,21 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ***
 
-Change log v.0.2.10 (next release)
+Change log v.0.2.12 (next release)
+
+***
+
+Change log v.0.2.11
+
+**Fix**: C layer memory pool had a race-condition that could have caused, in some unlikely events, memory allocation failure for Websocket protocol handlers. This had now been addressed and fixed.
+
+**Experimental feature**: added an `each_write` feature to allow direct `write` operations that write data to all open Websocket connections sharing the same process (worker). When this method is called without the optional block, the data will be sent without the need to acquire the Ruby GIL.
+
+**Update**: lessons learned from `facil.io` have been implemented for better compatibility of Iodine's core C layer.
+
+***
+
+Change log v.0.2.10
 
 **Update**: added documentation and an extra helper method to set a connection's timeout when using custom protocols (Iodine as an EventMachine alternative).
 

data/SPEC-Websocket-Draft.md

@@ -1,3 +1,10 @@
+### Draft Inactivity Notice
+
+This proposed draft is only implemented by Iodine and hadn't seen external activity in the last four months. It is unlikely that this initiative will grow to become a community convention.
+
+I still believe it's important to separate the Websocket server from the Websocket application (much like Rack did for HTTP).n I hope that in the future a community convention for this separation of concerns can be achieved.
+
+---
 ## Rack Websockets
 
 This is the proposed Websocket support extension for Rack servers.

data/bin/ws-shootout

@@ -0,0 +1,100 @@
+#!/usr/bin/env ruby
+
+Dir.chdir(File.expand_path(File.join('..', '..'), __FILE__))
+puts `rake clean`
+puts `rake compile`
+
+require 'benchmark'
+require 'json'
+$LOAD_PATH.unshift File.expand_path(File.join('..', '..', 'lib'), __FILE__)
+require 'bundler/setup'
+require 'iodine'
+require 'rack'
+
+
+class ShootoutApp
+  # the default HTTP response
+  def self.call(env)
+    if env['upgrade.websocket?'.freeze] # && env['HTTP_UPGRADE'.freeze] =~ /websocket/i
+      env['upgrade.websocket'.freeze] = ShootoutApp.new
+      return [0, {}, []]
+    end
+    out = "ENV:\r\n#{env.to_a.map { |h| "#{h[0]}: #{h[1]}" } .join "\n"}\n"
+    request = Rack::Request.new(env)
+    out += "\nRequest Path: #{request.path_info}\nParams:\r\n#{request.params.to_a.map { |h| "#{h[0]}: #{h[1]}" } .join "\n"}\n" unless request.params.empty?
+    [200, { 'Content-Length' => out.length, 'Content-Type' => 'text/plain; charset=UTF-8;' }, [out]]
+  end
+  # we won't be using AutoDispatch, but directly using the `on_message` callback.
+  def on_message data
+    cmd, payload = JSON(data).values_at('type', 'payload')
+    if cmd == 'echo'
+      write({type: 'echo', payload: payload}.to_json)
+    else
+      msg = {type: 'broadcast', payload: payload}.to_json
+      # Iodine::Websocket.each {|ws| ws.write msg}
+      Iodine::Websocket.multiwrite(msg) # {|ws| true }
+      write({type: "broadcastResult", payload: payload}.to_json)
+    end
+  end
+end
+
+
+# create the server object and setup any settings we might need.
+Iodine.threads ||= 4
+Iodine.processes ||= 1
+Iodine::Rack.public = nil
+Iodine::Rack.app = ShootoutApp
+Iodine.start
+
+# server.on_http= Proc.new do |env|
+#   # [200, {"Content-Length".freeze => "12".freeze}, ["Hello World!".freeze]];
+#   if env["HTTP_UPGRADE".freeze] =~ /websocket/i.freeze
+#     env['iodine.websocket'.freeze] = WSEcho.new
+#     [0,{}, []]
+#   else
+#     req = Rack::Request.new env
+#     res = Rack::Response.new
+#     res.write "Hello World!".freeze
+#     res.to_a
+#   end
+# end
+
+# server.on_start do
+#   server.run_every(1000) {puts "#{server.connection_count} clients connected."}
+# end
+
+# puts "Press enter to start (#{Process.pid})"
+# gets
+
+# def nag
+#   puts `ab -n 200000 -c 2000 -k http://127.0.0.1:3000/`
+#   sleep 2
+# end
+#
+# nag while true
+#
+# def nag
+#   puts `wrk -c2000 -d10 -t4 http://localhost:3000/`
+#   sleep 3
+# end
+#
+# nag while true
+
+# ab -n 100000 -c 200 -k http://127.0.0.1:3000/
+# ab -n 100000 -c 4000 -k http://127.0.0.1:3000/
+# ab -n 1000000 -c 20000 -k http://127.0.0.1:3000/
+# ~/ruby/wrk/wrk -c400 -d10 -t12 http://localhost:3000/
+# wrk -c200 -d4 -t12 http://localhost:3000/
+# ab -n 2000 -c 20 -H "Connection: close" http://127.0.0.1:3000/
+# RACK_ENV="production" rackup -p 3000 -s iodine
+
+# thor --amount 5000 ws://localhost:3000/echo
+# thor --amount 5000 ws://localhost:3000/broadcast
+
+# ws = new WebSocket("ws://localhost:3000"); ws.onmessage = function(e) {console.log("Got message!"); console.log(e.data);}; ws.onclose = function(e) {console.log("closed")}; ws.onopen = function(e) {ws.send("hi");};
+# for(i = 0; i< 256; i++) {
+#   ws = new WebSocket("ws://localhost:3000");
+#   ws.onmessage = function(e) {console.log("Got message!"); console.log(e.data); e.target.close(); };
+#   ws.onclose = function(e) {console.log("closed")};
+#   ws.onopen = function(e) {e.target.send("hi");};
+# };

data/ext/iodine/iodine_core.h

@@ -24,8 +24,8 @@ Feel free to copy, use and enjoy according to the license provided.
 #include <stdlib.h>
 #include <string.h>
 
-#ifndef __unused
-#define __unused __attribute__((unused))
+#ifndef UNUSED_FUNC
+#define UNUSED_FUNC __attribute__((unused))
 #endif
 
 extern rb_encoding *BinaryEncoding;
@@ -52,10 +52,10 @@ extern ID fd_var_id;
 extern ID timeout_var_id;
 extern ID to_s_method_id;
 
-__unused static inline void iodine_set_fd(VALUE handler, intptr_t fd) {
+UNUSED_FUNC static inline void iodine_set_fd(VALUE handler, intptr_t fd) {
   rb_ivar_set(handler, fd_var_id, LONG2NUM((long)fd));
 }
-__unused static inline intptr_t iodine_get_fd(VALUE handler) {
+UNUSED_FUNC static inline intptr_t iodine_get_fd(VALUE handler) {
   return ((intptr_t)NUM2LONG(rb_ivar_get(handler, fd_var_id)));
 }
 /* *****************************************************************************

data/ext/iodine/iodine_websocket.c

@@ -193,10 +193,11 @@ static void iodine_perform_defer(intptr_t uuid, protocol_s *protocol,
   RubyCaller.call2((VALUE)arg, call_proc_id, 1, &obj);
   Registry.remove((VALUE)arg);
 }
+
 static void iodine_defer_fallback(intptr_t uuid, void *arg) {
   (void)(uuid);
   Registry.remove((VALUE)arg);
-};
+}
 
 /**
 Schedules a block of code to execute at a later time, **if** the connection is
@@ -239,6 +240,49 @@ static VALUE iodine_defer(int argc, VALUE *argv, VALUE self) {
   return block;
 }
 
+/* *****************************************************************************
+Websocket Multi-Write
+*/
+
+static uint8_t iodine_ws_if_callback(ws_s *ws, void *block) {
+  VALUE handler = get_handler(ws);
+  uint8_t ret = 0;
+  if (handler)
+    ret = RubyCaller.call2((VALUE)block, call_proc_id, 1, &handler);
+  return ret && ret != Qnil && ret != Qfalse;
+}
+
+/**
+ * Writes data to all the Websocket connections sharing the same process
+ * (worker) except `self`.
+ *
+ * If a block is given, it will be passed each Websocket connection in turn
+ * (much like `each`) and send the data only if the block returns a "truthy"
+ * value (i.e. NOT `false` or `nil`).
+ *
+ * See both {#write} and {#each} for more details.
+ */
+static VALUE iodine_ws_multiwrite(VALUE self, VALUE data) {
+  Check_Type(data, T_STRING);
+  ws_s *ws = get_ws(self);
+  // if ((void *)ws == (void *)0x04 || (void *)data == (void *)0x04 ||
+  //     RSTRING_PTR(data) == (void *)0x04)
+  //   fprintf(stderr, "iodine_ws_write: self = %p ; data = %p\n"
+  //                   "\t\tString ptr: %p, String length: %lu\n",
+  //           (void *)ws, (void *)data, RSTRING_PTR(data), RSTRING_LEN(data));
+  if (!ws || ((protocol_s *)ws)->service != WEBSOCKET_ID_STR)
+    ws = NULL;
+
+  VALUE block = Qnil;
+  if (rb_block_given_p())
+    block = rb_block_proc();
+  websocket_write_each(ws, RSTRING_PTR(data), RSTRING_LEN(data),
+                       rb_enc_get(data) == UTF8Encoding, 0,
+                       ((block == Qnil) ? NULL : iodine_ws_if_callback),
+                       (void *)block);
+  return Qtrue;
+}
+
 /* *****************************************************************************
 Websocket task performance
 */
@@ -472,6 +516,7 @@ void Init_iodine_websocket(void) {
   rb_define_method(rWebsocket, "on_close", empty_func, 0);
   rb_define_method(rWebsocket, "on_ready", empty_func, 0);
   rb_define_method(rWebsocket, "write", iodine_ws_write, 1);
+  rb_define_method(rWebsocket, "each_write", iodine_ws_multiwrite, 1);
   rb_define_method(rWebsocket, "close", iodine_ws_close, 0);
 
   rb_define_method(rWebsocket, "uuid", iodine_ws_uuid, 0);
@@ -483,6 +528,7 @@ void Init_iodine_websocket(void) {
 
   rb_define_singleton_method(rWebsocket, "each", iodine_ws_class_each, 0);
   rb_define_singleton_method(rWebsocket, "defer", iodine_class_defer, 1);
+  rb_define_singleton_method(rWebsocket, "each_write", iodine_ws_multiwrite, 1);
 
   rWebsocketClass = rb_define_module_under(IodineBase, "WebsocketClass");
   rb_define_method(rWebsocketClass, "each", iodine_ws_class_each, 0);

data/ext/iodine/mempool.h

@@ -204,7 +204,7 @@ static UNUSED_FUNC void *mempool_malloc(size_t size) {
   if (!size)
     return NULL;
   if (size & 15) {
-    size = (size & (~16)) + 16;
+    size = (size & (~15)) + 16;
   }
 
   size += sizeof(struct mempool_reserved_slice_s_offset);
@@ -213,8 +213,9 @@ static UNUSED_FUNC void *mempool_malloc(size_t size) {
 
   if (size > (MEMPOOL_BLOCK_SIZE - (sizeof(mempool_reserved_slice_s) << 1)))
     goto alloc_indi;
-  slice = mempool_reserved_pool.available;
+
   MEMPOOL_LOCK();
+  slice = mempool_reserved_pool.available;
   while (slice && slice->offset.ahead < size)
     slice = slice->next;
   if (slice) {
@@ -249,6 +250,9 @@ static UNUSED_FUNC void *mempool_malloc(size_t size) {
   }
 
   if (slice->offset.ahead > (size + sizeof(mempool_reserved_slice_s))) {
+    if (slice->offset.ahead & MEMPOOL_USED_MARKER) {
+      fprintf(stderr, "mempool ERROR: allocating an allocated slice!\n");
+    }
     /* cut the slice in two */
     mempool_reserved_slice_s *tmp =
         (mempool_reserved_slice_s *)(((uintptr_t)slice) + size);
@@ -432,9 +436,9 @@ static UNUSED_FUNC void *mempool_realloc(void *ptr, size_t size) {
   if ((slice->offset.ahead & MEMPOOL_USED_MARKER) != MEMPOOL_USED_MARKER)
     goto error;
 
-  slice->offset.ahead &= MEMPOOL_SIZE_MASK;
-
   MEMPOOL_LOCK();
+
+  slice->offset.ahead &= MEMPOOL_SIZE_MASK;
   /* merge slice with upper boundry */
   while ((tmp = (mempool_reserved_slice_s *)(((uintptr_t)slice) +
                                              slice->offset.ahead))
@@ -704,7 +708,7 @@ static void mempool_speedtest(size_t memtest_repeats, void *(*mlk)(size_t),
   fr_time = end - start;
   fprintf(stderr, "* Freeing %lu consecutive blocks %d each: %lu CPU cycles.\n",
           memtest_repeats, MEMTEST_SLICE, fr_time);
-  fprintf(stderr, "* Freeing pointer array %p.\n", pntrs);
+  fprintf(stderr, "* Freeing pointer array %p.\n", (void *)pntrs);
   fr(pntrs);
 
   clock_gettime(CLOCK_MONOTONIC, &end_test);

data/ext/iodine/rb-libasync.h

@@ -24,8 +24,8 @@ Portability - used to help port this to different frameworks (i.e. Ruby).
 #endif
 
 /* The unused directive */
-#ifndef __unused
-#define __unused __attribute__((unused))
+#ifndef UNUSED_FUNC
+#define UNUSED_FUNC __attribute__((unused))
 #endif
 
 /* used here but declared elsewhere */
@@ -40,7 +40,7 @@ static void *_inner_join_with_rbthread(void *rbt) {
 }
 
 /* join a ruby thread */
-__unused static void *join_thread(THREAD_TYPE thr) {
+UNUSED_FUNC static void *join_thread(THREAD_TYPE thr) {
   void *ret = rb_thread_call_with_gvl(_inner_join_with_rbthread, (void *)thr);
   Registry.remove(thr);
   return ret;
@@ -68,7 +68,7 @@ static void *create_ruby_thread_gvl(void *_args) {
 }
 
 /* create a ruby thread */
-__unused static int create_thread(THREAD_TYPE *thr,
+UNUSED_FUNC static int create_thread(THREAD_TYPE *thr,
                                   void *(*thread_func)(void *), void *arg) {
   struct CreateThreadArgs *data = malloc(sizeof(*data));
   if (!data)

data/ext/iodine/websockets.c

@@ -192,6 +192,8 @@ static void on_shutdown(intptr_t fd, protocol_s *ws) {
 /* later */
 static void websocket_write_impl(intptr_t fd, void *data, size_t len, char text,
                                  char first, char last, char client);
+static size_t websocket_encode(void *buff, void *data, size_t len, char text,
+                               char first, char last, char client);
 
 /* read data from the socket, parse it and invoke the websocket events. */
 static void on_data(intptr_t sockfd, protocol_s *_ws) {
@@ -333,7 +335,7 @@ static void on_data(intptr_t sockfd, protocol_s *_ws) {
           }
         }
         // copy here
-        memcpy(ws->buffer.data + ws->length,
+        memcpy((uint8_t *)ws->buffer.data + ws->length,
                read_buffer.buffer + read_buffer.pos, ws->parser.data_len);
         ws->length += ws->parser.data_len;
       }
@@ -446,12 +448,52 @@ static void destroy_ws(ws_s *ws) {
 /*******************************************************************************
 Writing to the Websocket
 */
-
 #define WS_MAX_FRAME_SIZE 65532 // should be less then `unsigned short`
 
-static void websocket_write_impl(intptr_t fd, void *data, size_t len,
-                                 char text, /* TODO: add client masking */
-                                 char first, char last, char client) {
+// clang-format off
+#if !defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)
+#   if defined(__has_include)
+#     if __has_include(<endian.h>)
+#      include <endian.h>
+#     elif __has_include(<sys/endian.h>)
+#      include <sys/endian.h>
+#     endif
+#   endif
+#   if !defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__) && \
+                __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#      define __BIG_ENDIAN__
+#   endif
+#endif
+// clang-format on
+
+#ifdef __BIG_ENDIAN__
+/** byte swap 64 bit integer */
+#define bswap64(i) (i)
+
+#else
+// TODO: check for __builtin_bswap64
+/** byte swap 64 bit integer */
+#define bswap64(i)                                                             \
+  ((((i)&0xFFULL) << 56) | (((i)&0xFF00ULL) << 40) |                           \
+   (((i)&0xFF0000ULL) << 24) | (((i)&0xFF000000ULL) << 8) |                    \
+   (((i)&0xFF00000000ULL) >> 8) | (((i)&0xFF0000000000ULL) >> 24) |            \
+   (((i)&0xFF000000000000ULL) >> 40) | (((i)&0xFF00000000000000ULL) >> 56))
+
+#endif
+
+static void websocket_mask(void *dest, void *data, size_t len) {
+  /* a semi-random 4 byte mask */
+  uint32_t mask = ((rand() << 7) ^ ((uintptr_t)dest >> 13));
+  /* place mask at head of data */
+  dest = (uint8_t *)dest + 4;
+  memcpy(dest, &mask, 4);
+  /* TODO: optimize this */
+  for (size_t i = 0; i < len; i++) {
+    ((uint8_t *)dest)[i] = ((uint8_t *)data)[i] ^ ((uint8_t *)(&mask))[i & 3];
+  }
+}
+static size_t websocket_encode(void *buff, void *data, size_t len, char text,
+                               char first, char last, char client) {
   if (len < 126) {
     struct {
       unsigned op_code : 4;
@@ -465,11 +507,13 @@ static void websocket_write_impl(intptr_t fd, void *data, size_t len,
               .fin = last,
               .size = len,
               .masked = client};
-    char buff[len + (client ? 6 : 2)];
     memcpy(buff, &head, 2);
-    memcpy(buff + (client ? 6 : 2), data, len);
-    sock_write(fd, buff, len + 2);
-  } else if (len <= WS_MAX_FRAME_SIZE) {
+    if (client)
+      websocket_mask((uint8_t *)buff + 2, data, len);
+    else
+      memcpy((uint8_t *)buff + 2, data, len);
+    return len + 2 + (client ? 4 : 0);
+  } else if (len < (1UL << 16)) {
     /* head is 4 bytes */
     struct {
       unsigned op_code : 4;
@@ -483,26 +527,64 @@ static void websocket_write_impl(intptr_t fd, void *data, size_t len,
     } head = {.op_code = (first ? (text ? 1 : 2) : 0),
               .fin = last,
               .size = 126,
-              .masked = 0,
+              .masked = client,
               .length = htons(len)};
-    if (len >> 15) { // if len is larger then 32,767 Bytes.
+    memcpy(buff, &head, 4);
+    if (client)
+      websocket_mask((uint8_t *)buff + 4, data, len);
+    else
+      memcpy((uint8_t *)buff + 4, data, len);
+    return len + 4 + (client ? 4 : 0);
+  }
+  /* Really Long Message  */
+  struct {
+    unsigned op_code : 4;
+    unsigned rsv3 : 1;
+    unsigned rsv2 : 1;
+    unsigned rsv1 : 1;
+    unsigned fin : 1;
+    unsigned size : 7;
+    unsigned masked : 1;
+  } head = {
+      .op_code = (first ? (text ? 1 : 2) : 0),
+      .fin = last,
+      .size = 127,
+      .masked = client,
+  };
+  memcpy(buff, &head, 2);
+  ((size_t *)((uint8_t *)buff + 2))[0] = bswap64(len);
+  if (client)
+    websocket_mask((uint8_t *)buff + 10, data, len);
+  else
+    memcpy((uint8_t *)buff + 10, data, len);
+  return len + 10 + (client ? 4 : 0);
+}
+
+static void websocket_write_impl(intptr_t fd, void *data, size_t len,
+                                 char text, /* TODO: add client masking */
+                                 char first, char last, char client) {
+  if (len < 126) {
+    char buff[len + (client ? 6 : 2)];
+    len = websocket_encode(buff, data, len, text, first, last, client);
+    sock_write(fd, buff, len);
+  } else if (len <= WS_MAX_FRAME_SIZE) {
+    if (len >= BUFFER_PACKET_SIZE) { // if len is larger then a single packet.
       /* head MUST be 4 bytes */
-      void *buff = malloc(len + (client ? 8 : 4));
-      memcpy(buff, &head, 4);
-      memcpy(buff + (client ? 8 : 4), data, len);
-      sock_write2(.fduuid = fd, .buffer = buff, .length = len + 4, .move = 1);
+      void *buff = malloc(len + 4);
+      len = websocket_encode(buff, data, len, text, first, last, client);
+      sock_write2(.fduuid = fd, .buffer = buff, .length = len, .move = 1);
     } else {
-      /* head MUST be 4 bytes */
-      char buff[len + (client ? 8 : 4)];
-      memcpy(buff, &head, 4);
-      memcpy(buff + (client ? 8 : 4), data, len);
-      sock_write(fd, buff, len + 4);
+      sock_packet_s *packet = sock_checkout_packet();
+      packet->length = websocket_encode(packet->buffer, data, len, text, first,
+                                        last, client);
+      packet->metadata.can_interrupt = 1;
+      sock_send_packet(fd, packet);
     }
   } else {
     /* frame fragmentation is better for large data then large frames */
     while (len > WS_MAX_FRAME_SIZE) {
       websocket_write_impl(fd, data, WS_MAX_FRAME_SIZE, text, first, 0, client);
-      data += WS_MAX_FRAME_SIZE;
+      data = ((uint8_t *)data) + WS_MAX_FRAME_SIZE;
       first = 0;
       len -= WS_MAX_FRAME_SIZE;
     }
@@ -604,7 +686,8 @@ ssize_t websocket_upgrade(websocket_settings_s settings) {
   recv_str = http_request_find_header(settings.request,
                                       "sec-websocket-extensions", 24);
   // if (recv_str != NULL)
-  //   http_response_write_header(response, .name = "Sec-Websocket-Extensions",
+  //   http_response_write_header(response, .name =
+  //   "Sec-Websocket-Extensions",
   //                              .name_length = 24);
 
   goto cleanup;
@@ -626,7 +709,7 @@ cleanup:
     server_set_timeout(ws->fd, settings.timeout);
     // call the on_open callback
     if (settings.on_open)
-      server_task(ws->fd, on_open, settings.on_open, NULL);
+      server_task(ws->fd, on_open, (void *)settings.on_open, NULL);
     spn_unlock(&ws->protocol.callback_lock);
     return 0;
   }
@@ -688,7 +771,8 @@ struct WSTask {
   void (*on_finish)(ws_s *, void *);
   void *arg;
 };
-/** Performs a task on each websocket connection that shares the same process */
+/** Performs a task on each websocket connection that shares the same process
+ */
 static void perform_ws_task(intptr_t fd, protocol_s *_ws, void *_arg) {
   (void)(fd);
   struct WSTask *tsk = _arg;
@@ -717,3 +801,44 @@ void websocket_each(ws_s *ws_originator,
   server_each((ws_originator ? ws_originator->fd : -1), WEBSOCKET_ID_STR,
               perform_ws_task, tsk, finish_ws_task);
 }
+/*******************************************************************************
+Multi-Write (direct broadcast) Implementation
+*/
+struct websocket_multi_write {
+  uint8_t (*if_callback)(ws_s *ws_to, void *arg);
+  void *arg;
+  size_t length;
+  uint8_t buffer[];
+};
+
+static void ws_finish_multi_write(intptr_t fd, protocol_s *_ws, void *arg) {
+  (void)(fd);
+  (void)(_ws);
+  mempool_free(arg);
+}
+static void ws_check_multi_write(intptr_t fd, protocol_s *_ws, void *arg) {
+  struct websocket_multi_write *multi = arg;
+  if (multi->if_callback((void *)_ws, multi->arg))
+    sock_write(fd, multi->buffer, multi->length);
+}
+
+static void ws_direct_multi_write(intptr_t fd, protocol_s *_ws, void *arg) {
+  struct websocket_multi_write *multi = arg;
+  (void)(_ws);
+  sock_write(fd, multi->buffer, multi->length);
+}
+
+void websocket_write_each(ws_s *ws_originator, void *data, size_t len,
+                          uint8_t is_text, uint8_t as_client,
+                          uint8_t (*if_callback)(ws_s *ws_to, void *arg),
+                          void *arg) {
+  struct websocket_multi_write *multi =
+      mempool_malloc(len + 14 /* max head size */ + sizeof(*multi));
+  multi->length =
+      websocket_encode(multi->buffer, data, len, is_text, 1, 1, as_client);
+  multi->if_callback = if_callback;
+  multi->arg = arg;
+  server_each((ws_originator ? ws_originator->fd : -1), WEBSOCKET_ID_STR,
+              (if_callback ? ws_check_multi_write : ws_direct_multi_write),
+              multi, ws_finish_multi_write);
+}

data/ext/iodine/websockets.h

@@ -129,6 +129,21 @@ void websocket_each(ws_s *ws_originator,
                     void (*task)(ws_s *ws_target, void *arg), void *arg,
                     void (*on_finish)(ws_s *ws_originator, void *arg));
 /**
+Writes data to each websocket connection that shares the same process
+(except the originating `ws_s` connection which is allowed to be NULL).
+
+If an `if_callback` is provided, the data will be written to the connection only
+if the `if_callback` returns TRUE (a non zero value).
+
+The `as_client` is a boolean value indicating if the data should be masked (sent
+to a server, in client mode) or not. If some data should be sent in client mode
+and other in server mode, consider using the `if_callback` to make sure the data
+is encoded properly.
+ */
+void websocket_write_each(ws_s *ws_originator, void *data, size_t len,
+                          uint8_t is_text, uint8_t as_client,
+                          uint8_t (*if_callback)(ws_s *ws_to, void *arg),
+                          void *arg); /**
 Counts the number of websocket connections.
 */
 size_t websocket_count(ws_s *ws);

data/iodine.gemspec

@@ -40,7 +40,7 @@ Gem::Specification.new do |spec|
   spec.requirements << 'Ruby >= 2.3.0 is recommended.'
 
   spec.add_development_dependency 'bundler', '~> 1.10'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake', '~> 12.0'
   spec.add_development_dependency 'minitest'
 
   # spec.post_install_message = "** WARNING!\n" \

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.2.10'.freeze
+  VERSION = '0.2.11'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.2.10
+  version: 0.2.11
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-01-24 00:00:00.000000000 Z
+date: 2017-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -114,6 +114,7 @@ files:
 - bin/test_with_faye
 - bin/ws-broadcast
 - bin/ws-echo
+- bin/ws-shootout
 - exe/iodine
 - ext/iodine/base64.c
 - ext/iodine/base64.h
@@ -202,7 +203,7 @@ requirements:
 - Ruby >= 2.2.2
 - Ruby >= 2.3.0 is recommended.
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Iodine - leveraging C for Ruby servers.