iodine 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c633ef1f40df47f2edefcd78b2bd3fc2a896ab7a704b298f42765d605b375947
-  data.tar.gz: e810cccda11b73c2c4881fd90e4e0132efbf62c11857edee457381cb700c6302
+  metadata.gz: 3223346c9846721cd2c6c5ef4c49e6abd9e43b28921ba1413d0b8c09c7372375
+  data.tar.gz: 20fde29985c40d22743f77eae4ad5a981e8f3e033798539436e54995ee9fade5
 SHA512:
-  metadata.gz: 1e376b5ca69fb98da82062508687cd2bdaf7bb55b2071559d23c2f5eb330cd7fc9f7856865a86cb382357106835027e5296a8f0c67113a0522dd1a6ac9323bbf
-  data.tar.gz: ecd04e8c645961e8df5e4bfa7e2666a71a81dfda1647fe7e43c27894abb9431010663821d36a99bca23727cb0077f6f00144e0cd563a2a34ba9426ab80bb24cb
+  metadata.gz: b76b9b6abbf1df98c1bcb02df5efb5e138f8f529391f9d566a42f270ea99c7915d44c12096b663b008f8f62892ef6b58f2d4a138c67b39cf12b71e2c65047c6f
+  data.tar.gz: a1ab694050056c0bc848c17b121d0b239a0845137ed70b918a2ca4bc067d6f8c956a5430466205299e6122520fce677380c662eb7f72de5b5cf626bcb78584d4

data/CHANGELOG.md

@@ -6,6 +6,12 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.0.6.1
+
+**Fix**: (`Iodine::PubSub`) fixed typo, `Iodine::PubSub.detach` is now correctly spelled.
+
+**Fix**: (`Iodine::PubSub`) fix issue #37 where iodine would crash after the server's shutdown process due to Ruby Pub/Sub engines still being attached (or set as default) even after the Ruby interpreter freed all the Ruby objects. Credit to @sj26 (Samuel Cochran) for reporting the issue.
+
 #### Change log v.0.6.0
 
 I apologize to all my amazing early adopters for the rapid changes in the API for connection objects (SSE / WebSockets) and Pub/Sub. This was a result of an attempt to create a de-facto standard with other server authors. Hopefully the API in the 0.6.0 release will see the last of the changes.

data/SPEC-Websocket-Draft.md

@@ -33,33 +33,30 @@ WebSocket and EventSource connection upgrade and handling is performed using a C
 
 The Callback Object should be a class (or an instance of such class) where **instances** implement any of the following callbacks:
 
-* `on_open()` WILL be called once the connection had been established.
+* `on_open(client)` WILL be called once the connection had been established.
 
-* `on_message(data)` WILL be called when incoming WebSocket data is received.
+* `on_message(client, data)` WILL be called when incoming WebSocket data is received.
 
     This callback is ignored for EventSource connections.
 
     `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.
+    The *callback object* **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_drained()` **MAY** be called when the the `write` buffer becomes empty. **If** `pending` returns a non-zero value, the `on_drained` callback **MUST** be called once the write buffer becomes empty.
+* `on_drained(client)` **MAY** be called when the the `write` buffer becomes empty. **If** `pending` returns a non-zero value, the `on_drained` callback **MUST** be called once the write buffer becomes empty.
 
-* `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.
+* `on_shutdown(client)` **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.
 
-* `on_close()` **MUST** be called _after_ the connection was closed for whatever reason (socket errors, parsing errors, timeouts, client disconnection, `close` being called, etc').
+* `on_close(client)` **MUST** be called _after_ the connection was closed for whatever reason (socket errors, parsing errors, timeouts, client disconnection, `close` being called, etc').
 
-* `on_open`, `on_drained`, `on_shutdown` and `on_close` shouldn't expect any arguments (`arity == 0`).
 
-The following method names are reserved for the network implementation: `write`, `close`, `open?` and `pending`.
+The server **MUST** provide the Callback Object with a `client` object, that supports the following methods (this approach promises applications could be server agnostic):
 
-The server **MUST** extend the Callback Object's *class* using `extend`, so the Callback Object **inherits** the following methods (this approach promises applications could be server agnostic\*):
+* `write(data)` will schedule the data to be sent. `data` **MUST** be a String.
 
-* `write(data)` will attempt to send the data through the connection. `data` **MUST** be a String.
-
-    `write` has the same delivery promise as `Socket#write` (a successful `write` does **not** mean any of the data will reach the other side).
+    A call to `write` only promises that the data is scheduled to be sent. Servers are encouraged to avoid blocking and return immediately, deferring the actual `write` operation for later.
 
     `write` shall return `true` on success and `false` if the connection is closed.
 
@@ -69,15 +66,15 @@ The server **MUST** extend the Callback Object's *class* using `extend`, so the
 
     * If `data` is binary encoded it will be sent as non-text (as specified by the WebSocket Protocol).
 
-    A server **SHOULD** document whether `write` will block or return immediately. It is **RECOMMENDED** that servers implement buffered IO, allowing `write` to return immediately when resources allow and block (or, possibly, disconnect) when the IO buffer is full.
+    A server **SHOULD** document whether `write` will block. It is **RECOMMENDED** that servers implement buffered IO, allowing `write` to return immediately when resources allow and block (or, possibly, disconnect) when the IO buffer is full.
 
 * `close` closes the connection once all the data in the outgoing queue was sent. If `close` is called while there is still data to be sent, `close` will only take effect once the data was sent.
 
     `close` shall always return `nil`.
 
-* `open?` returns the state of the connection. Servers **MUST** set the method to return `true` if the connection is open and `false` if the connection is closed or marked to be closed.
+* `open?` returns `true` if the connection isn't known to have been closed and `false` if the connection is known to be closed or marked to be closed.
 
-* `pending` **MUST** return -1 if the connection is closed or the number of pending writes (calls to `write`) that need to be processed before the next time the `on_drained` callback is called\*.
+* `pending` **MUST** return -1 if the connection is closed. Otherwise, `pending` **SHOULD** return the number of pending writes (messages in the `write` queue\*) that need to be processed before the next time the `on_drained` callback is called.
 
     Servers **MAY** choose to always return the value `0` if they never call the `on_drained` callback and the connection is open.
 
@@ -85,7 +82,6 @@ The server **MUST** extend the Callback Object's *class* using `extend`, so the
 
     \*Servers that divide large messages into a number of smaller messages (implement message fragmentation) MAY count each fragment separately, as if the fragmentation was performed by the user and `write` was called more than once per message.
 
-The following keyword(s) (both as method names and instance variable names) is reserved for the internal server implementations: `_sock`, `_cid`.
 
 WebSocket `ping` / `pong`, timeouts and network considerations should be implemented by the server. It is **RECOMMENDED** (but not required) that the server send `ping`s to prevent connection timeouts and detect network failure.
 
@@ -139,20 +135,20 @@ The following is an example WebSocket echo server implemented using this specifi
 
 ```ruby
 class WSConnection
-    def on_open
+    def on_open(client)
         puts "WebSocket connection established."
     end
-    def on_message(data)
-        write data
+    def on_message(client, data)
+        client.write data
         puts "on_drained MUST be implemented if #{ pending } != 0."
     end
-    def on_drained
+    def on_drained(client)
         puts "Yap,on_drained is implemented."
     end
-    def on_shutdown
-        write "The server is going away. Goodbye."
+    def on_shutdown(client)
+        client.write "The server is going away. Goodbye."
     end
-    def on_close
+    def on_close(client)
         puts "WebSocket connection closed."
     end
 end
@@ -170,22 +166,22 @@ end
 run App
 ```
 
-The following is uses Push notifications for both WebSocket and SSE connections. The Pub/Sub API isn't part of this specification:
+The following example uses Push notifications for both WebSocket and SSE connections. The Pub/Sub API isn't part of this specification but it is supported by iodine:
 
 ```ruby
 class Chat
     def initialize(nickname)
         @nickname = nickname
     end
-    def on_open
-        subscribe "chat"
-        publish "chat", "#{@nickname} joined the chat."
+    def on_open(client)
+        client.subscribe "chat"
+        client.publish "chat", "#{@nickname} joined the chat."
     end
-    def on_message(data)
-        publish "chat", "#{@nickname}: #{data}"
+    def on_message(client, data)
+        client.publish "chat", "#{@nickname}: #{data}"
     end
-    def on_close
-        publish "chat", "#{@nickname}: left the chat."
+    def on_close(client)
+        client.publish "chat", "#{@nickname}: left the chat."
     end
 end
 

data/ext/iodine/iodine_connection.c

@@ -583,6 +583,7 @@ static VALUE iodine_pubsub_unsubscribe(VALUE self, VALUE name) {
   return ret;
 }
 
+// clang-format off
 /**
 Publishes a message to a channel.
 
@@ -601,11 +602,11 @@ Alternatively, accepts the following named arguments:
 
 :message :: The message to be published (required).
 
-:engine :: If provided, the engine to use for pub/sub. Otherwise the default
-engine is used.
+:engine :: If provided, the engine to use for pub/sub. Otherwise the default engine is used.
 
 */
 static VALUE iodine_pubsub_publish(int argc, VALUE *argv, VALUE self) {
+  // clang-format on
   VALUE rb_ch, rb_msg, rb_engine = Qnil;
   const pubsub_engine_s *engine = NULL;
   switch (argc) {

data/ext/iodine/iodine_pubsub.c

@@ -220,6 +220,8 @@ static void iodine_pubsub_data_mark(void *c_) {
 /* a callback for the GC (marking active objects) */
 static void iodine_pubsub_data_free(void *c_) {
   iodine_pubsub_s *data = c_;
+  pubsub_engine_deregister(data->engine);
+  IodineStore.remove(data->handler); /* redundant except during exit */
   if (data->dealloc) {
     data->dealloc(data->engine);
   }
@@ -335,7 +337,7 @@ static VALUE iodine_pubsub_attach(VALUE self, VALUE engine) {
  * the {Iodine::PubSub::Engine}'s callbacks ({Iodine::PubSub::Engine#subscribe}
  * and {Iodine::PubSub::Engine#unsubscribe})
  */
-static VALUE iodine_pubsub_dettach(VALUE self, VALUE engine) {
+static VALUE iodine_pubsub_detach(VALUE self, VALUE engine) {
   iodine_pubsub_s *e = iodine_pubsub_CData(engine);
   if (!e) {
     rb_raise(rb_eTypeError, "not a valid engine");
@@ -657,7 +659,8 @@ void iodine_pubsub_init(void) {
   rb_define_module_function(PubSubModule, "default", iodine_pubsub_default_get,
                             0);
   rb_define_module_function(PubSubModule, "attach", iodine_pubsub_attach, 1);
-  rb_define_module_function(PubSubModule, "dettach", iodine_pubsub_dettach, 1);
+  rb_define_module_function(PubSubModule, "dettach", iodine_pubsub_detach, 1);
+  rb_define_module_function(PubSubModule, "detach", iodine_pubsub_detach, 1);
   rb_define_module_function(PubSubModule, "reset", iodine_pubsub_reset, 1);
 
   /* Define the Engine class and it's methods */

data/ext/iodine/pubsub.c

@@ -446,8 +446,10 @@ void pubsub_engine_deregister(pubsub_engine_s *engine) {
       (fio_hash_key_s){.hash = (uintptr_t)engine, .obj = FIOBJ_INVALID}, NULL);
   fio_hash_compact(&engines);
   spn_unlock(&engn_lock);
-  if (!old)
-    fprintf(stderr, "Deregister error, not registered?\n");
+  // if (!old) {
+  //   fprintf(stderr, "WARNING: (pub/sub) Deregister error,"
+  //                   " not registered?\n");
+  // }
 }
 
 /**

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.6.0'.freeze
+  VERSION = '0.6.1'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-05-12 00:00:00.000000000 Z
+date: 2018-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack