All Versions
125
Latest Version
Avg Release Cycle
63 days
Latest Release
-

Changelog History
Page 11

  • v0.2.2 Changes

    ⚡️ Update The static file service now supports ETag caching, sending a 304 (not changed) response for valid ETags.

    ⚡️ Update: A performance warning now shows if the CPUs are significantly under-utilized (less than half are used) of if too many are utilized (more than double the amount of CPUs), warning against under-utilization or excessive context switching (respectively).

  • v0.2.1 Changes

    🔔 Notice: The Rack Websocket Draft does not support the each and defer methods. Although I tried to maintain these as part of the draft, the community preferred to leave the implementation of these to the client (rather then the server). If collisions occur, these methods might be removed in the future.

    ⚡️ Update: Websockets now support the has_pending? method and on_ready callback, as suggested by the Rack Websocket Draft.

    ⚡️ Update: deprecated the Websocket method uuid in favor of conn_id, as suggested by the Rack Websocket Draft.

    🛠 Fix: fixed an issue were the server would crash when attempting to send a long enough websocket message.

  • v0.2.0 Changes

    This version is a total rewrite. The API is totally changed, nothing stayed.

    💎 Iodine is now written in C, as a C extension for Ruby. The little, if any, ruby code written is just the fluff and feathers.

  • v0.1.21 Changes

    Optimization: Minor optimizations. i.e. - creates 1 less Time object per request (The logging still creates a Time object unless disabled using Iodine.logger = nil).

    🔒 Security: HTTP/1 now reviews the Body's size as it grows (similar to HTTP/2), mitigating any potential attacks related to the size of the data sent.

    🔊 Logs: Log the number of threads utilized when starting up the server.

  • v0.1.20 Changes

    ⚡️ Update/Fix: Updated the x-forwarded-for header recognition, to accommodate an Array formatting sometimes used (["ip1", "ip2", ...]).

    ⚡️ Update: native support for the Forwarded header HTTP.

    API Changes: Iodine::HTTP.max_http_buffer was replaced with Iodine::HTTP.max_body_size, for a better understanding of the method's result.

  • v0.1.19 Changes

    ⚡️ Update: added the go_away method to the HTTP/1 protocol, for seamless connection closeing across HTTP/2, HTTP/1 and Websockets.

  • v0.1.18 Changes

    ⚡️ Update: The request now has the shortcut method Request#host_name for accessing the host's name (without the port part of the string).

  • v0.1.17 Changes

    Credit: thanks you @frozenfoxx for going through the readme and fixing my broken grammar.

    🛠 Fix: fixed an issue where multiple Pings might get sent when pinging takes time. Now pings are exclusive (run within their own Mutex).

    🛠 Fix: HTTP/2 is back... sorry about breaking it in the 0.1.16 version. When I updated the write buffer I forgot to write the status of the response, causing a protocol error related with the headers. It's now working again.

    ⚡️ Update: by default and for security reasons, session id's created through a secure connection (SSL) will NOT be available on a non secure connection (SSL/TLS). However, while upgrading to the encrypted connection, the non_encrypted session storage is now available for review using the Response#session_old method.

    • Remember that sessions are never really safe, no matter how much we guard them. Session hijacking is far too easy. This is why Iodine stores the session data locally and not within the session cookie. This is also why you should review any authentication before performing sensitive tasks based on session stored authentication data.

  • v0.1.16 Changes

    🐎 Performance: HTTP/1 and HTTP/2 connections now share and recycle their write buffer when while reading the response body and writing it to the IO. This (hopefully) prevents excess malloc calls by the interpreter.

  • v0.1.15 Changes

    ⚡️ Update: IO reactor will now update IO status even when tasks are pending. IO will still be read only when there are no more tasks to handle, but this allows chained tasks to relate to the updated IO status. i.e. this should improve Websocket availability for broadcasting (delay from connection to availability might occur until IO is registered).

    ⚡️ Update: Websockets now support the on_ping callback, which will be called whenever a ping was sent without error.