rage-iodine 4.4.0 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 303b190ec5ec7b3f67818e9c1a3b3b87352547c338685e3af8a319588652e945
-  data.tar.gz: 9060a19940097808b32b0d210a11c2bcc9fc1354d123be5fd6c61f2a9d5f18fa
+  metadata.gz: 5780b0bd483cbceaee368b8416a0fc6cdfc7fcf155f67eaa5715a3748790e032
+  data.tar.gz: 3191054adbffcac948151b9cb1367033819b3639ffc027bc052313bb216a7d20
 SHA512:
-  metadata.gz: e98de1cdf973e91d5b2401f112fdc9487625ba90e985399914cf4ce387040255e35c4073d80ad89e6337800777f2d5bc3b89d7909cb4dfdd582afc89d8071309
-  data.tar.gz: b1e68feee5ba155887c7ea7ab9c372bacc3724a79c83849b19f20bdb701b7e4412a90ea90a5e7858566248dd0c01903c2f9e6f7e6272522f9e13e803c031dcfb
+  metadata.gz: 6e07a2923d319c9e561216101dd59a31a13bb2a85f370e89d40718ed99fd1293990ecf033bd8ca23ccb65e1ea5395500529503a59d208a01c4d96a36cab90ee4
+  data.tar.gz: 2b57180029bf202fb8b825304b96e7f4307220576920c05e052b79ed2292d3780437ba7056876222bf33f3d120692794b182bab816f6c3ffedda2d3d987e3b38

data/CHANGELOG.md

@@ -6,6 +6,17 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.5.1.0 (2026-03-04)
+
+**Update**: Verify SSE connection are open before calling the protocol object
+**Update**: Invert upgrade flow to move the upgrade decisions to the framework level
+
+#### Change log v.5.0.0 (2026-02-25)
+
+**Update**: Stop formatting SSE events
+**Update**: Update accept header check for SSE
+**Update**: Support fiber pauses during upgrades
+
 #### Change log v.4.4.0 (2025-11-28)
 
 **Update**: Update the `rackup` interface.

data/ext/iodine/http_internal.c

@@ -12,12 +12,12 @@ Feel free to copy, use and enjoy according to the license provided.
 Internal Request / Response Handlers
 ***************************************************************************** */
 
+/* Used by HTTP client response handler for WebSocket upgrade detection */
 static uint64_t http_upgrade_hash = 0;
+
 /** Use this function to handle HTTP requests.*/
 void http_on_request_handler______internal(http_s *h,
                                            http_settings_s *settings) {
-  if (!http_upgrade_hash)
-    http_upgrade_hash = fiobj_hash_string("upgrade", 7);
   h->udata = settings->udata;
 
   static uint64_t host_hash = 0;
@@ -34,14 +34,7 @@ void http_on_request_handler______internal(http_s *h,
     }
   }
 
-  FIOBJ t = fiobj_hash_get2(h->headers, http_upgrade_hash);
-  if (t)
-    goto upgrade;
-
-  if (fiobj_iseq(
-          fiobj_hash_get2(h->headers, fiobj_obj2hash(HTTP_HEADER_ACCEPT)),
-          HTTP_HVALUE_SSE_MIME))
-    goto eventsource;
+  /* Static file handling */
   if (settings->public_folder &&
       (fiobj_obj2cstr(h->method).len != 4 || strncasecmp("post", fiobj_obj2cstr(h->method).data, 4))) {
     fio_str_info_s path_str = fiobj_obj2cstr(h->path);
@@ -51,24 +44,11 @@ void http_on_request_handler______internal(http_s *h,
       return;
     }
   }
+
+  /* Always call on_request - let the framework decide upgrades */
   settings->on_request(h);
   return;
 
-upgrade:
-  if (1) {
-    fiobj_dup(t); /* allow upgrade name access after http_finish */
-    fio_str_info_s val = fiobj_obj2cstr(t);
-    if (val.data[0] == 'h' && val.data[1] == '2') {
-      http_send_error(h, 400);
-    } else {
-      settings->on_upgrade(h, val.data, val.len);
-    }
-    fiobj_free(t);
-    return;
-  }
-eventsource:
-  settings->on_upgrade(h, (char *)"sse", 3);
-  return;
 missing_host:
   FIO_LOG_DEBUG("missing Host header");
   http_send_error(h, 400);

data/ext/iodine/iodine_connection.c

@@ -197,24 +197,7 @@ static VALUE iodine_connection_write(VALUE self, VALUE data) {
                     rb_enc_get(data) == IodineUTF8Encoding);
     return Qtrue;
     break;
-  case IODINE_CONNECTION_SSE:
-/* SSE */
-#if 1
-    http_sse_write(c->info.arg, .data = IODINE_RSTRINFO(data));
-    return Qtrue;
-#else
-    if (rb_enc_get(data) == IodineUTF8Encoding) {
-      http_sse_write(c->info.arg, .data = {.data = RSTRING_PTR(data),
-                                           .len = RSTRING_LEN(data)});
-      return Qtrue;
-    }
-    fprintf(stderr, "WARNING: ignoring an attept to write binary data to "
-                    "non-binary protocol (SSE).\n");
-    return Qfalse;
-// rb_raise(rb_eEncodingError,
-//          "This Connection type requires data to be UTF-8 encoded.");
-#endif
-    break;
+  case IODINE_CONNECTION_SSE: /* SSE - raw bytes, framework handles formatting */
   case IODINE_CONNECTION_RAW: /* fallthrough */
   default: {
     fio_write(c->info.uuid, RSTRING_PTR(data), RSTRING_LEN(data));
@@ -447,9 +430,7 @@ static void iodine_on_pubsub(fio_msg_s *msg) {
       }
       return;
     }
-    case IODINE_CONNECTION_SSE:
-      http_sse_write(data->info.arg, .data = msg->msg);
-      return;
+    case IODINE_CONNECTION_SSE: /* SSE - raw bytes, framework handles formatting */
     default:
       fio_write(data->info.uuid, msg->msg.data, msg->msg.len);
       return;

data/ext/iodine/iodine_http.c

@@ -62,10 +62,9 @@ static ID iodine_call_proc_id;
 static ID fiber_result_var_id;
 static VALUE http_wait_directive;
 static ID fiber_id_method_id;
+static ID iodine_env_var_id;
 
-static VALUE env_template_no_upgrade;
-static VALUE env_template_websockets;
-static VALUE env_template_sse;
+static VALUE env_template;
 
 static rb_encoding *IodineUTF8Encoding;
 static rb_encoding *IodineBinaryEncoding;
@@ -122,11 +121,6 @@ typedef struct {
     IODINE_HTTP_WAIT,
     IODINE_HTTP_DEFERRED,
   } type;
-  enum iodine_upgrade_type_enum {
-    IODINE_UPGRADE_NONE = 0,
-    IODINE_UPGRADE_WEBSOCKET,
-    IODINE_UPGRADE_SSE,
-  } upgrade;
 } iodine_http_request_handle_s;
 
 /* *****************************************************************************
@@ -233,15 +227,24 @@ static void iodine_sse_on_shutdown(http_sse_s *sse) {
                                Qnil);
 }
 static void iodine_sse_on_close(http_sse_s *sse) {
+  if (http_sse2uuid(sse) == -1) {
+    // Connection was already closed, skip silently
+    return;
+  }
   iodine_connection_fire_event((VALUE)sse->udata, IODINE_CONNECTION_ON_CLOSE,
                                Qnil);
 }
 
 static void iodine_sse_on_open(http_sse_s *sse) {
+  intptr_t uuid = http_sse2uuid(sse);
+  if (uuid == -1) {
+    // Connection was closed before on_open could fire, skip silently
+    return;
+  }
   VALUE h = (VALUE)sse->udata;
   iodine_connection_s *c = iodine_connection_CData(h);
   c->arg = sse;
-  c->uuid = http_sse2uuid(sse);
+  c->uuid = uuid;
   iodine_connection_fire_event(h, IODINE_CONNECTION_ON_OPEN, Qnil);
   sse->on_ready = iodine_sse_on_ready;
   fio_force_event(c->uuid, FIO_EVENT_ON_READY);
@@ -321,18 +324,7 @@ static int iodine_copy2env_task(FIOBJ o, void *env_) {
 static inline VALUE copy2env(iodine_http_request_handle_s *handle) {
   VALUE env;
   http_s *h = handle->h;
-  switch (handle->upgrade) {
-  case IODINE_UPGRADE_WEBSOCKET:
-    env = rb_hash_dup(env_template_websockets);
-    break;
-  case IODINE_UPGRADE_SSE:
-    env = rb_hash_dup(env_template_sse);
-    break;
-  case IODINE_UPGRADE_NONE: /* fallthrough */
-  default:
-    env = rb_hash_dup(env_template_no_upgrade);
-    break;
-  }
+  env = rb_hash_dup(env_template);
   IodineStore.add(env);
 
   fio_str_info_s tmp;
@@ -612,6 +604,8 @@ static inline int ruby2c_review_upgrade(iodine_http_request_handle_s *req,
                                         VALUE rbresponse, VALUE env) {
   http_s *h = req->h;
   VALUE handler;
+  VALUE upgrade_type;
+
   if ((handler = rb_hash_aref(env, IODINE_R_HIJACK_CB)) != Qnil) {
     // send headers
     http_finish(h);
@@ -625,37 +619,29 @@ static inline int ruby2c_review_upgrade(iodine_http_request_handle_s *req,
     goto upgraded;
   } else if ((handler = rb_hash_aref(env, UPGRADE_TCP)) != Qnil) {
     goto tcp_ip_upgrade;
-  } else {
-    switch (req->upgrade) {
-    case IODINE_UPGRADE_WEBSOCKET:
-      if ((handler = rb_hash_aref(env, RACK_UPGRADE)) != Qnil) {
-        // use response as existing base for native websocket upgrade
-        iodine_ws_attach(h, handler, env);
-        goto upgraded;
-      }
-      break;
-    case IODINE_UPGRADE_SSE:
-      if ((handler = rb_hash_aref(env, RACK_UPGRADE)) != Qnil) {
-        // use response as existing base for SSE upgrade
-        iodine_sse_attach(h, handler, env);
-        goto upgraded;
-      }
-      break;
-    default:
-      if ((handler = rb_hash_aref(env, RACK_UPGRADE)) != Qnil) {
-      tcp_ip_upgrade : {
-        // use response as existing base for raw TCP/IP upgrade
-        intptr_t uuid = http_hijack(h, NULL);
-        // send headers
-        http_finish(h);
-        // upgrade protocol to raw TCP/IP
-        iodine_tcp_attch_uuid(uuid, handler);
-        goto upgraded;
-      }
-      }
-      break;
+  }
+
+  handler = rb_hash_aref(env, RACK_UPGRADE);
+  if (handler == Qnil)
+    return 0;
+
+  upgrade_type = rb_hash_aref(env, RACK_UPGRADE_Q);
+
+  if (upgrade_type == RACK_UPGRADE_WEBSOCKET) {
+    iodine_ws_attach(h, handler, env);
+    goto upgraded;
+  } else if (upgrade_type == RACK_UPGRADE_SSE) {
+    iodine_sse_attach(h, handler, env);
+    goto upgraded;
+  } else if (RTEST(upgrade_type)) {
+  tcp_ip_upgrade : {
+      intptr_t uuid = http_hijack(h, NULL);
+      http_finish(h);
+      iodine_tcp_attch_uuid(uuid, handler);
+      goto upgraded;
     }
   }
+
   return 0;
 
 upgraded:
@@ -673,14 +659,15 @@ Handling HTTP requests
 
 static inline void *iodine_handle_request_in_GVL(void *handle_) {
   iodine_http_request_handle_s *handle = handle_;
-  VALUE rbresponse = 0;
-  VALUE env = 0, tmp;
+  VALUE rbresponse = Qnil;
+  VALUE env = Qnil, tmp;
   http_s *h = handle->h;
   if (!h->udata)
     goto err_not_found;
 
   if (handle->type == IODINE_HTTP_DEFERRED) {
     rbresponse = rb_ivar_get((VALUE)h->fiber, fiber_result_var_id);
+    env = rb_ivar_get((VALUE)h->fiber, iodine_env_var_id);
   } else {
     // create / register env variable
     env = copy2env(handle);
@@ -698,7 +685,9 @@ static inline void *iodine_handle_request_in_GVL(void *handle_) {
   tmp = rb_ary_entry(rbresponse, 0);
   // rack will return `[:__http_defer__, fiber_to_wait_on]` in case the request needs to be paused
   if (TYPE(tmp) == T_SYMBOL && tmp == http_wait_directive) {
-    h->fiber = (void *)IodineStore.add(rb_ary_entry(rbresponse, 1));
+    VALUE fiber = rb_ary_entry(rbresponse, 1);
+    rb_ivar_set(fiber, iodine_env_var_id, env);
+    h->fiber = (void *)IodineStore.add(fiber);
     goto defer;
   }
 
@@ -741,7 +730,7 @@ static inline void *iodine_handle_request_in_GVL(void *handle_) {
   // review each header and write it to the response.
   rb_hash_foreach(response_headers, for_each_header_data, (VALUE)(h));
   // review for upgrade.
-  if (handle->type != IODINE_HTTP_DEFERRED && (intptr_t)h->status < 300 &&
+  if ((intptr_t)h->status < 300 && env != Qnil &&
       ruby2c_review_upgrade(handle, rbresponse, env))
     goto external_done;
   // send the request body.
@@ -826,7 +815,6 @@ iodine_perform_handle_action(iodine_http_request_handle_s handle) {
 static inline void http_resume_deferred_request_handler(http_s *h) {
   iodine_http_request_handle_s handle = (iodine_http_request_handle_s){
     .h = h,
-    .upgrade = IODINE_UPGRADE_NONE,
     .type = IODINE_HTTP_DEFERRED,
   };
 
@@ -857,7 +845,6 @@ static inline void http_pause_request_handler(http_pause_handle_s *s) {
 static void on_rack_request(http_s *h) {
   iodine_http_request_handle_s handle = (iodine_http_request_handle_s){
       .h = h,
-      .upgrade = IODINE_UPGRADE_NONE,
   };
   IodineCaller.enterGVL((void *(*)(void *))iodine_handle_request_in_GVL,
                         &handle);
@@ -869,33 +856,15 @@ static void on_rack_request(http_s *h) {
   }
 }
 
-static void on_rack_upgrade(http_s *h, char *proto, size_t len) {
-  iodine_http_request_handle_s handle = (iodine_http_request_handle_s){.h = h};
-  if (len == 9 && (proto[1] == 'e' || proto[1] == 'E')) {
-    handle.upgrade = IODINE_UPGRADE_WEBSOCKET;
-  } else if (len == 3 && proto[0] == 's') {
-    handle.upgrade = IODINE_UPGRADE_SSE;
-  }
-  /* when we stop supporting custom Upgrade headers: */
-  // else {
-  //   http_send_error(h, 400);
-  //   return;
-  // }
-  IodineCaller.enterGVL(iodine_handle_request_in_GVL, &handle);
-  iodine_perform_handle_action(handle);
-  (void)proto;
-  (void)len;
-}
-
 /* *****************************************************************************
 Rack `env` Template Initialization
 ***************************************************************************** */
 
 static void initialize_env_template(void) {
-  if (env_template_no_upgrade)
+  if (env_template)
     return;
-  env_template_no_upgrade = rb_hash_new();
-  IodineStore.add(env_template_no_upgrade);
+  env_template = rb_hash_new();
+  IodineStore.add(env_template);
 
 #define add_str_to_env(env, key, value)                                        \
   {                                                                            \
@@ -912,9 +881,9 @@ static void initialize_env_template(void) {
     rb_hash_aset((env), k, value);                                             \
   }
 
-  /* Set global template */
-  rb_hash_aset(env_template_no_upgrade, RACK_UPGRADE_Q, Qnil);
-  rb_hash_aset(env_template_no_upgrade, RACK_UPGRADE, Qnil);
+  /* Set global template - framework will set rack.upgrade? if it wants an upgrade */
+  rb_hash_aset(env_template, RACK_UPGRADE_Q, Qnil);
+  rb_hash_aset(env_template, RACK_UPGRADE, Qnil);
   {
     /* add the rack.version */
     static VALUE rack_version = 0;
@@ -925,7 +894,7 @@ static void initialize_env_template(void) {
       rb_global_variable(&rack_version);
       rb_ary_freeze(rack_version);
     }
-    add_value_to_env(env_template_no_upgrade, "rack.version", rack_version);
+    add_value_to_env(env_template, "rack.version", rack_version);
   }
 
   {
@@ -933,37 +902,27 @@ static void initialize_env_template(void) {
     if (!sn || (sn[0] == '/' && sn[1] == 0)) {
       sn = "";
     }
-    add_str_to_env(env_template_no_upgrade, "SCRIPT_NAME", sn);
+    add_str_to_env(env_template, "SCRIPT_NAME", sn);
   }
-  rb_hash_aset(env_template_no_upgrade, IODINE_R_INPUT, IODINE_R_INPUT_DEFAULT);
-  add_value_to_env(env_template_no_upgrade, "rack.errors", rb_stderr);
-  add_value_to_env(env_template_no_upgrade, "rack.hijack?", Qtrue);
-  add_value_to_env(env_template_no_upgrade, "rack.multiprocess", Qtrue);
-  add_value_to_env(env_template_no_upgrade, "rack.multithread", Qtrue);
-  add_value_to_env(env_template_no_upgrade, "rack.run_once", Qfalse);
+  rb_hash_aset(env_template, IODINE_R_INPUT, IODINE_R_INPUT_DEFAULT);
+  add_value_to_env(env_template, "rack.errors", rb_stderr);
+  add_value_to_env(env_template, "rack.hijack?", Qtrue);
+  add_value_to_env(env_template, "rack.multiprocess", Qtrue);
+  add_value_to_env(env_template, "rack.multithread", Qtrue);
+  add_value_to_env(env_template, "rack.run_once", Qfalse);
   /* default schema to http, it might be updated later */
-  rb_hash_aset(env_template_no_upgrade, R_URL_SCHEME, HTTP_SCHEME);
+  rb_hash_aset(env_template, R_URL_SCHEME, HTTP_SCHEME);
   /* placeholders... minimize rehashing*/
-  rb_hash_aset(env_template_no_upgrade, HTTP_VERSION, QUERY_STRING);
-  rb_hash_aset(env_template_no_upgrade, IODINE_R_HIJACK, QUERY_STRING);
-  rb_hash_aset(env_template_no_upgrade, PATH_INFO, QUERY_STRING);
-  rb_hash_aset(env_template_no_upgrade, QUERY_STRING, QUERY_STRING);
-  rb_hash_aset(env_template_no_upgrade, REMOTE_ADDR, QUERY_STRING);
-  rb_hash_aset(env_template_no_upgrade, REQUEST_METHOD, QUERY_STRING);
-  rb_hash_aset(env_template_no_upgrade, SERVER_NAME, QUERY_STRING);
-  rb_hash_aset(env_template_no_upgrade, SERVER_PROTOCOL, QUERY_STRING);
-  rb_hash_aset(env_template_no_upgrade, IODINE_REQUEST_ID, QUERY_STRING);
-  rb_hash_aset(env_template_no_upgrade, IODINE_HAS_BODY, QUERY_STRING);
-
-  /* WebSocket upgrade support */
-  env_template_websockets = rb_hash_dup(env_template_no_upgrade);
-  IodineStore.add(env_template_websockets);
-  rb_hash_aset(env_template_websockets, RACK_UPGRADE_Q, RACK_UPGRADE_WEBSOCKET);
-
-  /* SSE upgrade support */
-  env_template_sse = rb_hash_dup(env_template_no_upgrade);
-  IodineStore.add(env_template_sse);
-  rb_hash_aset(env_template_sse, RACK_UPGRADE_Q, RACK_UPGRADE_SSE);
+  rb_hash_aset(env_template, HTTP_VERSION, QUERY_STRING);
+  rb_hash_aset(env_template, IODINE_R_HIJACK, QUERY_STRING);
+  rb_hash_aset(env_template, PATH_INFO, QUERY_STRING);
+  rb_hash_aset(env_template, QUERY_STRING, QUERY_STRING);
+  rb_hash_aset(env_template, REMOTE_ADDR, QUERY_STRING);
+  rb_hash_aset(env_template, REQUEST_METHOD, QUERY_STRING);
+  rb_hash_aset(env_template, SERVER_NAME, QUERY_STRING);
+  rb_hash_aset(env_template, SERVER_PROTOCOL, QUERY_STRING);
+  rb_hash_aset(env_template, IODINE_REQUEST_ID, QUERY_STRING);
+  rb_hash_aset(env_template, IODINE_HAS_BODY, QUERY_STRING);
 
 #undef add_value_to_env
 #undef add_str_to_env
@@ -1020,15 +979,15 @@ relevant to HTTP/1.x connections.
 intptr_t iodine_http_listen(iodine_connection_args_s args){
   // clang-format on
   if (args.public.data) {
-    rb_hash_aset(env_template_no_upgrade, XSENDFILE_TYPE, XSENDFILE);
-    rb_hash_aset(env_template_no_upgrade, XSENDFILE_TYPE_HEADER, XSENDFILE);
+    rb_hash_aset(env_template, XSENDFILE_TYPE, XSENDFILE);
+    rb_hash_aset(env_template, XSENDFILE_TYPE_HEADER, XSENDFILE);
     support_xsendfile = 1;
   }
   IodineStore.add(args.handler);
 #ifdef __MINGW32__
   intptr_t uuid = http_listen(
       args.port.data, args.address.data, .on_request = on_rack_request,
-      .on_upgrade = on_rack_upgrade, .udata = (void *)args.handler,
+      .udata = (void *)args.handler,
       .timeout = args.timeout, .ws_timeout = args.ping,
       .ws_max_msg_size = args.max_msg, .max_header_size = args.max_headers,
       .on_finish = free_iodine_http, .log = args.log, .max_clients = args.max_clients,
@@ -1036,7 +995,7 @@ intptr_t iodine_http_listen(iodine_connection_args_s args){
 #else
   intptr_t uuid = http_listen(
       args.port.data, args.address.data, .on_request = on_rack_request,
-      .on_upgrade = on_rack_upgrade, .udata = (void *)args.handler,
+      .udata = (void *)args.handler,
       .tls = args.tls, .timeout = args.timeout, .ws_timeout = args.ping,
       .ws_max_msg_size = args.max_msg, .max_header_size = args.max_headers,
       .on_finish = free_iodine_http, .log = args.log, .max_clients = args.max_clients,
@@ -1245,6 +1204,7 @@ void iodine_init_http(void) {
   fiber_result_var_id = rb_intern("@__result");
   http_wait_directive = ID2SYM(rb_intern("__http_defer__"));
   fiber_id_method_id = rb_intern("__get_id");
+  iodine_env_var_id = rb_intern("@__iodine_env");
 
   IodineUTF8Encoding = rb_enc_find("UTF-8");
   IodineBinaryEncoding = rb_enc_find("binary");

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '4.4.0'.freeze
+  VERSION = '5.1.0'.freeze
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rage-iodine
 version: !ruby/object:Gem::Version
-  version: 4.4.0
+  version: 5.1.0
 platform: ruby
 authors:
 - Boaz Segev
 bindir: exe
 cert_chain: []
-date: 2025-11-28 00:00:00.000000000 Z
+date: 2026-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake