iodine 0.4.19 → 0.5.0

data/ext/iodine/websockets.h

@@ -1,11 +1,11 @@
 /*
-copyright: Boaz segev, 2016-2017
+copyright: Boaz Segev, 2016-2018
 license: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
 */
-#ifndef WEBSOCKETS_H
-#define WEBSOCKETS_H
+#ifndef H_WEBSOCKETS_H
+#define H_WEBSOCKETS_H
 
 #include "http.h"
 
@@ -14,109 +14,14 @@ Feel free to copy, use and enjoy according to the license provided.
 extern "C" {
 #endif
 
-/* *****************************************************************************
-Upgrading from HTTP to Websockets
-***************************************************************************** */
-
-/**
-The Websocket type is an opaque type used by the websocket API to provide
-identify a specific Websocket connection and manage it's internal state.
-*/
-typedef struct Websocket ws_s;
-
 /**
-The protocol / service identifier for `libserver`.
+The protocol / service identifier.
 */
 extern char *WEBSOCKET_ID_STR;
-/**
-The Websocket Handler contains all the settings required for new websocket
-connections.
 
-This struct is used for the named agruments in the `websocket_upgrade`
-macro.
-*/
-typedef struct {
-  /**
-  The (optional) on_message callback will be called whenever a websocket message
-  is
-  received for this connection.
-
-  The data received points to the websocket's message buffer and it will be
-  overwritten once the function exits (it cannot be saved for later, but it can
-  be copied).
-  */
-  void (*on_message)(ws_s *ws, char *data, size_t size, uint8_t is_text);
-  /**
-  The (optional) on_open callback will be called once the websocket connection
-  is established and before is is registered with `facil`, so no `on_message`
-  events are raised before `on_open` returns.
-  */
-  void (*on_open)(ws_s *ws);
-  /**
-  The (optional) on_ready callback will be after a the underlying socket's
-  buffer changes it's state from full to available.
-
-  If the socket's buffer is never full, the callback is never called.
-
-  It should be noted that `libsock` manages the socket's buffer overflow and
-  implements and augmenting user-land buffer, allowing data to be safely written
-  to the websocket without worrying over the socket's buffer.
-  */
-  void (*on_ready)(ws_s *ws);
-  /**
-  The (optional) on_shutdown callback will be called if a websocket connection
-  is still open while the server is shutting down (called before `on_close`).
-  */
-  void (*on_shutdown)(ws_s *ws);
-  /**
-  The (optional) on_close callback will be called once a websocket connection is
-  terminated or failed to be established.
-  */
-  void (*on_close)(ws_s *ws);
-  /** The `http_request_s` to be converted ("upgraded") to a websocket
-   * connection. Either a request or a response object is required.*/
-  http_request_s *request;
-  /**
-  The (optional) HttpResponse to be used for sending the upgrade response.
-
-  Using this object allows cookies to be set before "upgrading" the connection.
-
-  The ownership of the response object will remain unchanged - so if you have
-  created the response object, you should free it.
-  */
-  http_response_s *response;
-  /**
-  The maximum websocket message size/buffer (in bytes) for this connection.
-  */
-  size_t max_msg_size;
-  /** Opaque user data. */
-  void *udata;
-  /**
-  Timeout for the websocket connections, a ping will be sent
-  whenever the timeout is reached. Connections are only closed when a ping
-  cannot be sent (the network layer fails). Pongs aren't reviewed.
-  */
-  uint8_t timeout;
-} websocket_settings_s;
-
-/** This macro allows easy access to the `websocket_upgrade` function. The macro
- * allows the use of named arguments, using the `websocket_settings_s` struct
- * members. i.e.:
- *
- *     on_message(ws_s * ws, char * data, size_t size, int is_text) {
- *        ; // ... this is the websocket on_message callback
- *        websocket_write(ws, data, size, is_text); // a simple echo example
- *     }
- *
- *     on_request(http_request_s* request) {
- *        websocket_upgrade( .request = request, .on_message = on_message);
- *     }
- *
- * Returns 0 on sucess and -1 on failure. A response is always sent.
- */
-ssize_t websocket_upgrade(websocket_settings_s settings);
-#define websocket_upgrade(...)                                                 \
-  websocket_upgrade((websocket_settings_s){__VA_ARGS__})
+/** used internally: attaches the Websocket protocol to the socket. */
+void websocket_attach(intptr_t uuid, http_settings_s *http_settings,
+                      websocket_settings_s *args, void *data, size_t length);
 
 /* *****************************************************************************
 Websocket information
@@ -177,22 +82,12 @@ typedef struct pubsub_engine_s pubsub_engine_s;
 typedef struct {
   /** the websocket receiving the message. */
   ws_s *ws;
-  /** the pub/sub engine from which where the message originated. */
-  struct pubsub_engine_s *engine;
   /** the Websocket pub/sub subscription ID. */
   uintptr_t subscription_id;
   /** the channel where the message was published. */
-  struct {
-    const char *name;
-    size_t len;
-  } channel;
+  FIOBJ channel;
   /** the published message. */
-  struct {
-    const char *data;
-    size_t len;
-  } msg;
-  /** Pattern matching was used for channel subscription. */
-  unsigned use_pattern : 1;
+  FIOBJ message;
   /** user opaque data. */
   void *udata;
 } websocket_pubsub_notification_s;
@@ -201,17 +96,8 @@ typedef struct {
 struct websocket_subscribe_s {
   /** the websocket receiving the message. REQUIRED. */
   ws_s *ws;
-  /**
-   * The pub/sub engine to use.
-   *
-   * Default: engine will publish messages throughout the facil process cluster.
-   */
-  struct pubsub_engine_s *engine;
   /** the channel where the message was published. */
-  struct {
-    const char *name;
-    size_t len;
-  } channel;
+  FIOBJ channel;
   /**
    * The callback that handles pub/sub notifications.
    *
@@ -288,8 +174,7 @@ void websocket_unsubscribe(ws_s *ws, uintptr_t subscription_id);
 
 /* *****************************************************************************
 Websocket Tasks - within a single process scope, NOT and entire cluster
-*****************************************************************************
-*/
+***************************************************************************** */
 
 /** The named arguments for `websocket_each` */
 struct websocket_each_args_s {
@@ -303,17 +188,22 @@ struct websocket_each_args_s {
   void (*on_finish)(ws_s *origin, void *arg);
 };
 /**
-Performs a task on each websocket connection that shares the same process
-(except the originating `ws_s` connection which is allowed to be NULL).
+ * DEPRECATION NOTICE: this function will be removed in favor of pub/sub logic.
+ *
+ * Performs a task on each websocket connection that shares the same process
+ * (except the originating `ws_s` connection which is allowed to be NULL).
  */
-void websocket_each(struct websocket_each_args_s args);
+void __attribute__((deprecated))
+websocket_each(struct websocket_each_args_s args);
 #define websocket_each(...)                                                    \
   websocket_each((struct websocket_each_args_s){__VA_ARGS__})
 
 /**
-The Arguments passed to the `websocket_write_each` function / macro are defined
-here, for convinience of calling the function.
-*/
+ * DEPRECATION NOTICE: this function will be removed in favor of pub/sub logic.
+ *
+ * The Arguments passed to the `websocket_write_each` function / macro are
+ * defined here, for convinience of calling the function.
+ */
 struct websocket_write_each_args_s {
   /** The originating websocket client will be excluded from the `write`.
    * Can be NULL. */
@@ -343,7 +233,8 @@ Writes data to each websocket connection that shares the same process
 Accepts a sing `struct websocket_write_each_args_s` argument. See the struct
 details for possible arguments.
  */
-int websocket_write_each(struct websocket_write_each_args_s args);
+int __attribute__((deprecated))
+websocket_write_each(struct websocket_write_each_args_s args);
 #define websocket_write_each(...)                                              \
   websocket_write_each((struct websocket_write_each_args_s){__VA_ARGS__})
 

data/lib/iodine.rb

@@ -59,8 +59,6 @@ require 'iodine/iodine'
 # * {Iodine.listen2http} listens to new TCP/IP connections using the buildin HTTP / Websocket Protocol.
 # * {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.
 #
 # In addition to the top level API, there's also the connection class and connection instance API, as specified in the {Iodine::Protocol} and {Iodine::Websocket} documentation.
 #
@@ -70,12 +68,14 @@ require 'iodine/iodine'
 #
 # The following methods offect server side Pub/Sub that allows the server code to react to channel event.
 #
-# * {Iodine.subscribe}, {Iodine.unsubscribe} manages a process's subscription to a channel (which is different than a connection's subscription, such as employed by {Iodine::Websocket}).
-# * {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.subscribe} subscribes the process to a channel (which might be different than a connection's subscription, see {Iodine::Websocket}).
+# * {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 possibly other machines (when using an engine such as {Iodine::PubSub::RedisEngine}).
+# * {Iodine::PubSub.default_engine=}, {Iodine::PubSub.default_engine} 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 without invoking the Ruby interpreter).
 #
+# Note that {Iodine.subscribe} returns an {Iodine::PubSub::Subscription} object that can be used for closing the subscription.
+#
 # == Patching Rack
 #
 # Although Iodine offers Rack::Utils optimizations using monkey patching, Iodine does NOT monkey patch Rack automatically.
@@ -170,7 +170,8 @@ module Iodine
     end
   end
 
-  def self.patch_rack
+    # Will monkey patch some Rack methods to increase their performance.
+    def self.patch_rack
     ::Rack::Utils.class_eval do
       Iodine::Base::MonkeyPatch::RackUtils.methods(false).each do |m|
         ::Rack::Utils.define_singleton_method(m,
@@ -179,7 +180,51 @@ module Iodine
     end
   end
 
-  self.default_pubsub = ::Iodine::PubSub::CLUSTER
+  # Will monkey patch the default JSON parser to replace the default `JSON.parse` with {Iodine::JSON.parse}.
+  def self.patch_json
+    ::JSON.class_eval do
+        ::JSON.define_singleton_method(:parse,
+              Iodine::JSON.instance_method(:parse) )
+    end
+  end
+
+
+  @after_fork_blocks = []
+  def self.after_fork(*args, &block)
+    if(block)
+      @after_fork_blocks << [args, block]
+    else
+      @after_fork_blocks.each {|b| b[1].call(b[0]) }
+    end
+  end
+
+  @before_fork_blocks = []
+  def self.before_fork(*args, &block)
+    if(block)
+      @before_fork_blocks << [args, block]
+    else
+      @before_fork_blocks.each {|b| b[1].call(b[0]) }
+    end
+  end
+
+  ::Iodine::PubSub.default_engine = ::Iodine::PubSub::CLUSTER
 end
 
+if(!defined?(after_fork))
+  def after_fork(*args, &block)
+    Iodine.after_fork(*args, &block)
+  end
+end
+if(!defined?(on_worker_boot))
+  def on_worker_boot(*args, &block)
+    Iodine.after_fork(*args, &block)
+  end
+end
+if(!defined?(before_fork))
+  def before_fork(*args, &block)
+    Iodine.before_fork(*args, &block)
+  end
+end
+
+
 require 'rack/handler/iodine' unless defined? ::Iodine::Rack::IODINE_RACK_LOADED

data/lib/iodine/cli.rb

@@ -19,15 +19,17 @@ Use:
 Both <options> and <filename> are optional.
 
 Available options:
+ -b          Binding address. Default: nil (same as 0.0.0.0).
  -p          Port number. Default: 3000.
  -t          Number of threads. Default: CPU core count.
  -w          Number of worker processes. Default: CPU core count.
  -www        Public folder for static file serving. Default: nil (none).
  -v          Log responses. Default: never log responses.
  -warmup     Warmup invokes autoloading (lazy loading) during server startup.
- -tout       HTTP inactivity connection timeout. Default: 5 seconds.
- -maxbd      Maximum Mb per HTTP message (max body size). Default: 50Mib.
- -maxms      Maximum Bytes per Websocket message. Default: 250Kib.
+ -tout       HTTP inactivity connection timeout. Default: 40 seconds.
+ -maxhead    Maximum total headers length per HTTP request. Default: 32Kb.
+ -maxbd      Maximum Mb per HTTP message (max body size). Default: 50Mb.
+ -maxms      Maximum Bytes per Websocket message. Default: 250Kb.
  -ping       Websocket ping interval in seconds. Default: 40 seconds.
  <filename>  Defaults to: config.ru
 
@@ -48,15 +50,13 @@ EOS
         return ::Rack::Builder.parse_file filename
       end
 
-
-
       def call
         if ARGV[0] =~ /(\-\?)|(help)|(\?)|(h)|(\-h)$/
           return print_help
         end
 
         app, opt = nil, nil
-        filename = ((ARGV[-2].to_s[0] != '-' || ARGV[-2].to_s == '-warmup') && ARGV[-1].to_s[0] != '-' && ARGV[-1])
+        filename = ((ARGV[-2].to_s[0] != '-' || ARGV[-2].to_s == '-warmup' || ARGV[-2].to_s == '-v' || ARGV[-2].to_s == '-q') && ARGV[-1].to_s[0] != '-' && ARGV[-1])
         if filename
           app, opt = try_file filename;
           unless opt
@@ -79,24 +79,6 @@ EOS
           end
         end
 
-        if ARGV.index('-maxbd') && ARGV[ARGV.index('-maxbd') + 1]
-          Iodine::Rack.max_body_size = ARGV[ARGV.index('-maxbd') + 1].to_i
-        end
-        if ARGV.index('-maxms') && ARGV[ARGV.index('-maxms') + 1]
-          Iodine::Rack.max_msg_size = ARGV[ARGV.index('-maxms') + 1].to_i
-        end
-        if ARGV.index('-ping') && ARGV[ARGV.index('-ping') + 1]
-          Iodine::Rack.ws_timeout = ARGV[ARGV.index('-ping') + 1].to_i
-        end
-        if ARGV.index('-www') && ARGV[ARGV.index('-www') + 1]
-          Iodine::Rack.public = ARGV[ARGV.index('-www') + 1]
-        end
-        if ARGV.index('-tout') && ARGV[ARGV.index('-tout') + 1]
-          Iodine::Rack.timeout = ARGV[ARGV.index('-tout') + 1].to_i
-          puts "WARNNING: Iodine::Rack.timeout set to 0 (ignored, timeout will be ~5 seconds)."
-        end
-        Iodine::Rack.log = true if ARGV.index('-v')
-        Iodine::Rack.log = false if ARGV.index('-q')
         Iodine.warmup(app) if ARGV.index('-warmup')
         Iodine::Rack.run(app, opt)
       end

data/lib/iodine/json.rb

@@ -0,0 +1,40 @@
+module Iodine
+  # Iodine includes a lenient JSON parser that attempts to ignore JSON errors when possible and adds some extensions such as Hex numerical representations and comments.
+  #
+  # On my system, the Iodine JSON parser is more than 40% faster than the native Ruby parser. When using symbols the speed increase is even higher.
+  #
+  # It's easy to monkey-patch the system's `JSON.parse` method (not the `JSON.parse!` method) by using `Iodine.patch_json`.
+  #
+  # You can benchmark the Iodine JSON performance and decide if you wish to monkey-patch the Ruby implementation.
+  #
+  #      JSON_FILENAME="foo.json"
+  #
+  #      require 'json'
+  #      require 'iodine'
+  #      TIMES = 100
+  #      STR = IO.binread(JSON_FILENAME); nil
+  #
+  #      JSON.parse(STR) == Iodine::JSON.parse(STR) # => true
+  #      JSON.parse!(STR) == Iodine::JSON.parse!(STR) # => undefined, maybe true maybe false
+  #
+  #      # warm-up
+  #      TIMES.times { JSON.parse STR }
+  #      TIMES.times { Iodine::JSON.parse STR }
+  #
+  #      puts ""; Benchmark.bm do |b|
+  #        sys = b.report("system") { TIMES.times { JSON.parse STR } }
+  #        sys_sym = b.report("system-sym") { TIMES.times { JSON.parse STR, symbolize_names: true } }
+  #        iodine = b.report("iodine") { TIMES.times { Iodine::JSON.parse STR } }
+  #        iodine_sym = b.report("iodine-sym") { TIMES.times { Iodine::JSON.parse STR, symbolize_names: true } }
+  #
+  #        puts "----------------------------"
+  #        puts "Iodine::JSON speed as percent of Ruby's native JSON:"
+  #        puts "normal:    #{sys/iodine}"
+  #        puts "symolized: #{sys_sym/iodine_sym}"
+  #      end; nil
+  #
+  # Note that the bang(!) method should NOT be used for monkey-patching the default JSON parser, since some important features are unsupported by the Iodine parser.
+  #
+  module JSON
+  end
+end

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.4.19'.freeze
+  VERSION = '0.5.0'.freeze
 end

data/lib/iodine/websocket.rb

@@ -1,11 +1,13 @@
 module Iodine
-  # This module lists the available API for Websocket connections and classes.
+  # This module lists the available API for WebSocket and EventSource (SSE) connections.
   #
-  # This module is mixed in (using `extend` and `include`) with the Websocket Callback Object (as specified by the {file:SPEC-Websocket-Draft.md proposed Rack specification}.
+  # This module is mixed in (using `extend` and `include`) with the WebSocket Callback Object (as specified by the {file:SPEC-Websocket-Draft.md proposed Rack specification}.
+  #
+  # The server performs `extend` to allow the application to be namespace agnostic (so the server can be replaced without effecting the application).
   #
   # The websocket API is divided into three main groups:
   # * Server <=> Client relations ({Iodine::Websocket#write}, {Iodine::Websocket#close} etc')
-  # * Client <=> Server <=> Client relations ({Iodine::Websocket#subscribe}, {Iodine::Websocket#publish}, etc').
+  # * Client <=> Server <=> Pub/Sub relations ({Iodine::Websocket#subscribe}, {Iodine::Websocket#publish}.
   # * Task scheduling ({Iodine::Websocket.defer}, {Iodine::Websocket#defer}, {Iodine::Websocket.each}).
   #
   # Notice that Websocket callback objects (as specified by the {file:SPEC-Websocket-Draft.md proposed Rack specification} *MUST* provide an `on_message(data)` callback.

data/lib/rack/handler/iodine.rb

@@ -1,9 +1,7 @@
 require 'iodine' unless defined?(::Iodine::VERSION)
 
 module Iodine
-  # {Iodine::Rack} provides a Rack complient interface (connecting Iodine to Rack) for an HTTP and Websocket Server.
-  #
-  # {Iodine::Rack} also provides convinient access to the {Iodine::HTTP.listen} function, which powers the {Iodine::Rack} server.
+  # Iodine's {Iodine::Rack} module provides a Rack complient interface (connecting Iodine to Rack) for an HTTP and Websocket Server.
   module Rack
     # get/set the Rack application.
     def self.app=(val)
@@ -14,16 +12,18 @@ module Iodine
     def self.app
       @app
     end
+    @app = nil
 
-    # get/set the HTTP connection timeout property. Defaults to 5. Limited to a maximum of 255. 0 values are silently ignored.
+    # get/set the HTTP connection timeout property. Defaults to 40. Limited to a maximum of 255. 0 values are silently ignored.
     def self.timeout=(t)
       @timeout = t
     end
 
-    # get/set the HTTP connection timeout property. Defaults to 5.
+    # get/set the HTTP connection timeout property. Defaults to 40 seconds.
     def self.timeout
       @timeout
     end
+    @timeout = 0
 
     # get/set the Websocket connection timeout property. Defaults to 40 seconds. Limited to a maximum of 255. 0 values are silently ignored.
     def self.ws_timeout=(t)
@@ -34,14 +34,15 @@ module Iodine
     def self.ws_timeout
       @ws_timeout
     end
+    @ws_timeout = 0
 
-    # get/set the HTTP public folder property. Defaults to 5. Defaults to the incoming argumrnts or `nil`.
+    # get/set the HTTP public folder property. Defaults to the incoming arguments or `nil`.
     def self.public=(val)
       @public = val
     end
-    @public = ARGV[ARGV.index('-www') + 1] if ARGV.index('-www')
+    @public = nil
 
-    # get/set the HTTP public folder property. Defaults to 5.
+    # get/set the HTTP public folder property. Defaults to `nil`.
     def self.public
       @public
     end
@@ -55,7 +56,6 @@ module Iodine
     def self.max_body_size
       @max_body
     end
-
     # get/set the maximum HTTP body size for incoming data. Defaults to ~50Mb. 0 values are silently ignored.
     def self.max_body=(val)
       @max_body = val
@@ -65,6 +65,19 @@ module Iodine
     def self.max_body
       @max_body
     end
+    @max_body = 0
+
+    # get/set the maximum HTTP header length for incoming requests. Defaults to ~32Kb. 0 values are silently ignored.
+    def self.max_headers=(val)
+      @max_headers = val
+    end
+
+    # get/set the maximum HTTP header length for incoming requests. Defaults to ~32Kb.
+    def self.max_headers
+      @max_headers
+    end
+    @max_headers = 0
+
 
     # get/set the maximum Websocket body size for incoming data. Defaults to defaults to ~250KB. 0 values are silently ignored.
     def self.max_msg_size=(val)
@@ -85,6 +98,7 @@ module Iodine
     def self.max_msg
       @max_msg
     end
+    @max_msg = 0
 
     # get/set the HTTP logging value (true / false). Defaults to the incoming argumrnts or `false`.
     def self.log=(val)
@@ -95,8 +109,7 @@ module Iodine
     def self.log
       @log
     end
-    @log = true if ARGV.index('-v')
-    @log = false if ARGV.index('-q')
+    @log = false
 
     # get/set the HTTP listening port. Defaults to 3000.
     def self.port=(val)
@@ -107,8 +120,7 @@ module Iodine
     def self.port
       @port
     end
-    @port = ARGV[ARGV.index('-p') + 1] if ARGV.index('-p')
-    @port ||= 3000.to_s
+    @port = 3000.to_s
 
     # get/set the HTTP socket binding address. Defaults to `nil` (usually best).
     def self.address=(val)
@@ -153,6 +165,38 @@ module Iodine
   end
 end
 
+if ARGV.index('-b') && ARGV[ARGV.index('-b') + 1]
+  Iodine::Rack.address = ARGV[ARGV.index('-b') + 1]
+end
+if ARGV.index('-p') && ARGV[ARGV.index('-p') + 1]
+  Iodine::Rack.port = ARGV[ARGV.index('-p') + 1]
+end
+
+if ARGV.index('-maxbd') && ARGV[ARGV.index('-maxbd') + 1]
+  Iodine::Rack.max_body_size = ARGV[ARGV.index('-maxbd') + 1].to_i
+end
+if ARGV.index('-maxms') && ARGV[ARGV.index('-maxms') + 1]
+  Iodine::Rack.max_msg_size = ARGV[ARGV.index('-maxms') + 1].to_i
+end
+if ARGV.index('-ping') && ARGV[ARGV.index('-ping') + 1]
+  Iodine::Rack.ws_timeout = ARGV[ARGV.index('-ping') + 1].to_i
+end
+if ARGV.index('-www') && ARGV[ARGV.index('-www') + 1]
+  Iodine::Rack.public = ARGV[ARGV.index('-www') + 1]
+end
+if ARGV.index('-maxhead') && ARGV[ARGV.index('-maxhead') + 1]
+  Iodine::Rack.max_headers = ARGV[ARGV.index('-maxhead') + 1].to_i
+end
+if ARGV.index('-tout') && ARGV[ARGV.index('-tout') + 1]
+  Iodine::Rack.timeout = ARGV[ARGV.index('-tout') + 1].to_i
+  puts "WARNNING: Iodine::Rack.timeout set to 0 (ignored, timeout will be ~5 seconds)."
+end
+Iodine::Rack.log = true if ARGV.index('-v')
+Iodine::Rack.log = false if ARGV.index('-q')
+
+
+
+
 # Iodine::Rack.app = proc { |env| p env; puts env['rack.input'].read(1024).tap { |s| puts "Got data #{s.length} long, #{s[0].ord}, #{s[1].ord} ... #{s[s.length - 2].ord}, #{s[s.length - 1].ord}:" if s }; env['rack.input'].rewind; [404, {}, []] }
 
 ENV['RACK_HANDLER'] = 'iodine'
@@ -167,6 +211,7 @@ end
 
 begin
   ::Rack::Handler.register('iodine', 'Iodine::Rack') if defined?(::Rack::Handler)
+  ::Rack::Handler.register('Iodine', 'Iodine::Rack') if defined?(::Rack::Handler)
 rescue Exception
 
 end