iodine 0.5.2 → 0.6.0

data/ext/iodine/iodine_tcp.h

@@ -0,0 +1,9 @@
+#ifndef H_IODINE_RAW_TCP_IP_H
+#define H_IODINE_RAW_TCP_IP_H
+
+#include "ruby.h"
+
+void iodine_init_tcp_connections(void);
+void iodine_tcp_attch_uuid(intptr_t uuid, VALUE handler);
+
+#endif

data/lib/iodine.rb

@@ -3,215 +3,118 @@ require 'socket'
 require 'iodine/version'
 require 'iodine/iodine'
 
-# Iodine is both a Rack server and a platform for writing evented network services on Ruby.
+# Iodine is an HTTP / WebSocket server as well as an Evented Network Tool Library.
 #
-# Here is a sample Echo server using Iodine:
+# Here is a simple telnet based echo server using Iodine (see full list at {Iodine::Connection}):
 #
 #
+#       require 'iodine'
 #       # define the protocol for our service
-#       class EchoProtocol
-#         @timeout = 10
-#         # this is just one possible callback with a recyclable buffer
-#         def on_message buffer
+#       module EchoProtocol
+#         def on_open(client)
+#           # Set a connection timeout
+#           client.timeout = 10
+#           # Write a welcome message
+#           client.write "Echo server running on Iodine #{Iodine::VERSION}.\r\n"
+#         end
+#         # this is called for incoming data - note data might be fragmented.
+#         def on_message(client, data)
 #           # write the data we received
-#           write "echo: #{buffer}"
+#           client.write "echo: #{data}"
 #           # close the connection when the time comes
-#           close if buffer =~ /^bye[\n\r]/
+#           client.close if data =~ /^bye[\n\r]/
+#         end
+#         # called if the connection is still open and the server is shutting down.
+#         def on_shutdown(client)
+#           # write the data we received
+#           client.write "Server going away\r\n"
 #         end
+#         extend self
 #       end
-#       # create the service instance
-#       Iodine.listen 3000, EchoProtocol
+#       # create the service instance, the block returns a connection handler.
+#       Iodine.listen(port: "3000") { EchoProtocol }
 #       # start the service
+#       Iodine.threads = 1
 #       Iodine.start
 #
 #
-# Please read the {file:README.md} file for an introduction to Iodine and an overview of it's API.
-#
-# == The API
-#
-# The main API methods for the top {Iodine} namesapce are grouped here by subject.
-#
-# === Event Loop / Concurrency
-#
-# Iodine manages an internal event-loop and reactor pattern. The following API
-# manages Iodine's behavior.
-#
-# * {Iodine.threads}, {Iodine.threads=} gets or sets the amount of threads iodine will use in it's working thread pool.
-# * {Iodine.processes}, {Iodine.processes} gets or sets the amount of processes iodine will utilize (`fork`) to handle connections.
-# * {Iodine.start} starts iodine's event loop and reactor pattern. At this point, it's impossible to change the number of threads or processes used.
-#
-# === Event and Task Scheduling
-#
-# * {Iodine.run} schedules a block of code to run asynchronously.
-# * {Iodine.run_after}, {Iodine.run_every} schedules a block of code to run (asynchronously) using a timer.
-# * {Iodine.start} starts iodine's event loop and reactor pattern. At this point, it's impossible to change the number of threads or processes used.
-#
-# 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, which allows for a connection bound task(s) to be scheduled to run within the connection's lock (for example, {Iodine::Websocket#defer} and {Iodine::Websocket#each}).
-#
-# === Connection Handling
-#
-# Iodine handles connections using {Iodine::Protocol} objects. The following API
-# manages either built-in or custom {Protocol} objects (classes / instances) in relation to their network sockets.
-#
-# * {Iodine.attach_fd}, {Iodine.attach_io} allows Iodine to take controll of an IO object (i.e., a TCP/IP Socket, a Unix Socket or a pipe).
-# * {Iodine.connect} creates a new TCP/IP connection using the specified Protocol.
-# * {Iodine.listen} listens to new TCP/IP connections using the specified Protocol.
-# * {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).
-#
-# 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.
 #
-# === Pub/Sub
+# Methods for setting up and starting {Iodine} include {start}, {threads}, {threads=}, {workers} and {workers=}.
 #
-# Iodine offers a native Pub/Sub engine (no database required) that can be easily extended by implementing a Pub/Sub {Iodine::PubSub::Engine}.
+# Methods for setting startup / operational callbacks include {on_idle}, {on_shutdown}, {before_fork} and {after_fork}.
 #
-# The following methods offect server side Pub/Sub that allows the server code to react to channel event.
+# Methods for asynchronous execution include {run} (same as {defer}), {run_after} and {run_every}.
 #
-# * {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).
+# Methods for application wide pub/sub include {subscribe}, {unsubscribe} and {publish}. Connection specific pub/sub methods are documented in the {Iodine::Connection} class).
 #
-# {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).
+# Methods for TCP/IP and Unix Sockets connections include {listen} and {connect}.
 #
-# Note that {Iodine.subscribe} returns an {Iodine::PubSub::Subscription} object that can be used for closing the subscription.
+# Methods for HTTP connections include {listen2http}.
 #
-# == Patching Rack
+# Note that the HTTP server supports both TCP/IP and Unix Sockets as well as SSE / WebSockets extensions.
 #
-# Although Iodine offers Rack::Utils optimizations using monkey patching, Iodine does NOT monkey patch Rack automatically.
+# Iodine doesn't call {patch_rack} automatically, but doing so will improve Rack's performace.
 #
-# Choosing to monkey patch Rack::Utils could offer significant performance gains for some applications. i.e. (on my machine):
+# Please read the {file:README.md} file for an introduction to Iodine.
 #
-#       require 'iodine'
-#       require 'rack'
-#       # a String in need of decoding
-#       s = '%E3%83%AB%E3%83%93%E3%82%A4%E3%82%B9%E3%81%A8'
-#       Benchmark.bm do |bm|
-#         # Pre-Patch
-#         bm.report("   Rack.unescape")    {1_000_000.times { Rack::Utils.unescape s } }
-#         bm.report("    Rack.rfc2822")    {1_000_000.times { Rack::Utils.rfc2822(Time.now) } }
-#         bm.report("    Rack.rfc2109")    {1_000_000.times { Rack::Utils.rfc2109(Time.now) } }
-#         # Perform Patch
-#         Iodine.patch_rack
-#         puts "            --- Monkey Patching Rack ---"
-#         # Post Patch
-#         bm.report("Patched.unescape")    {1_000_000.times { Rack::Utils.unescape s } }
-#         bm.report(" Patched.rfc2822")    {1_000_000.times { Rack::Utils.rfc2822(Time.now) } }
-#         bm.report(" Patched.rfc2109")    {1_000_000.times { Rack::Utils.rfc2109(Time.now) } }
-#       end && nil
-#
-# Results:
-#         user     system      total        real
-#         Rack.unescape  8.660000   0.010000   8.670000 (  8.687807)
-#         Rack.rfc2822  3.730000   0.000000   3.730000 (  3.727732)
-#         Rack.rfc2109  3.020000   0.010000   3.030000 (  3.031940)
-#                      --- Monkey Patching Rack ---
-#         Patched.unescape  0.340000   0.000000   0.340000 (  0.341506)
-#         Patched.rfc2822  0.740000   0.000000   0.740000 (  0.737796)
-#         Patched.rfc2109  0.690000   0.010000   0.700000 (  0.700155)
-#
-# At the moment, the extent of the monkey patching offered is very limited.
-# As new optimizations are added, the policy regarding monkey patching (benifit vs. risks) might be re-evaluated.
 module Iodine
-  @threads = (ARGV.index('-t') && ARGV[ARGV.index('-t') + 1]) || ENV['MAX_THREADS']
-  @processes = (ARGV.index('-w') && ARGV[ARGV.index('-w') + 1]) || ENV['MAX_WORKERS']
-  @threads = @threads.to_i if @threads
-  if @processes == 'auto'
-    begin
-      require 'etc'
-      @processes = Etc.nprocessors
-    rescue Exception
-      warn "This version of Ruby doesn't support automatic CPU core detection."
-    end
-  end
-  @processes = @processes.to_i if @processes
-
-  # Get/Set the number of threads used in the thread pool (a static thread pool). Can be 1 (single working thread, the main thread will sleep) and can be 0 (the main thread will be used as the only active thread).
-  def self.threads
-    @threads
-  end
-
-  # Get/Set the number of threads used in the thread pool (a static thread pool). Can be 1 (single working thread, the main thread will sleep) and can be 0 (the main thread will be used as the only active thread).
-  def self.threads=(count)
-    @threads = count.to_i
-  end
-
-  # Get/Set the number of worker processes. A value greater then 1 will cause the Iodine to "fork" any extra worker processes needed.
-  def self.processes
-    @processes
-  end
-
-  # Get/Set the number of worker processes. A value greater then 1 will cause the Iodine to "fork" any extra worker processes needed.
-  def self.processes=(count)
-    @processes = count.to_i
-  end
-
-  # Runs the warmup sequence. {warmup} attempts to get every "autoloaded" (lazy loaded)
-  # file to load now instead of waiting for "first access". This allows multi-threaded safety and better memory utilization during forking.
-  #
-  # However, `warmup` might cause undefined behavior and should be avoided when using gems that initiate network / database connections or gems that spawn threads (i.e., ActiveRecord / ActiveCable).
-  #
-  # Use {warmup} when either {processes} or {threads} are set to more then 1 and gems don't spawn threads or initialize network connections.
-  def self.warmup app
-    # load anything marked with `autoload`, since autoload isn't thread safe nor fork friendly.
-    Iodine.run do
-      Module.constants.each do |n|
-        begin
-          Object.const_get(n)
-        rescue Exception => _e
-        end
-      end
-      ::Rack::Builder.new(app) do |r|
-        r.warmup do |a|
-          client = ::Rack::MockRequest.new(a)
-          client.get('/')
-        end
-      end
-    end
-  end
 
     # Will monkey patch some Rack methods to increase their performance.
+    #
+    # This is recommended, see {Iodine::Rack::Utils} for details.
     def self.patch_rack
     ::Rack::Utils.class_eval do
       Iodine::Base::MonkeyPatch::RackUtils.methods(false).each do |m|
         ::Rack::Utils.define_singleton_method(m,
               Iodine::Base::MonkeyPatch::RackUtils.instance_method(m) )
+        end
       end
     end
-  end
 
-  # 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
+end
 
+require 'rack/handler/iodine' unless defined? ::Iodine::Rack::IODINE_RACK_LOADED
 
-  @after_fork_blocks = []
-  # Performs a block of code whenever a new worker process spins up (performed once per worker).
-  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 = []
-  # Performs a block of code just before a new worker process spins up (performed once per worker).
-  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
+### CLI argument parsing
 
-  ::Iodine::PubSub.default_engine = ::Iodine::PubSub::CLUSTER
+if ARGV.index('-b') && ARGV[ARGV.index('-b') + 1]
+  Iodine::DEFAULT_HTTP_ARGS[:address] = ARGV[ARGV.index('-b') + 1]
+end
+if ARGV.index('-p') && ARGV[ARGV.index('-p') + 1]
+  Iodine::DEFAULT_HTTP_ARGS[:port] = ARGV[ARGV.index('-p') + 1]
 end
 
+if ARGV.index('-maxbd') && ARGV[ARGV.index('-maxbd') + 1]
+  Iodine::DEFAULT_HTTP_ARGS[:max_body_size] = ARGV[ARGV.index('-maxbd') + 1].to_i
+end
+if ARGV.index('-maxms') && ARGV[ARGV.index('-maxms') + 1]
+  Iodine::DEFAULT_HTTP_ARGS[:max_msg_size] = ARGV[ARGV.index('-maxms') + 1].to_i
+end
+if ARGV.index('-maxhead') && ARGV[ARGV.index('-maxhead') + 1]  && ARGV[ARGV.index('-maxhead') + 1].to_i > 0
+  Iodine::DEFAULT_HTTP_ARGS[:max_headers] = ARGV[ARGV.index('-maxhead') + 1].to_i
+end
+if ARGV.index('-ping') && ARGV[ARGV.index('-ping') + 1]
+  Iodine::DEFAULT_HTTP_ARGS[:ping] = ARGV[ARGV.index('-ping') + 1].to_i
+end
+if ARGV.index('-www') && ARGV[ARGV.index('-www') + 1]
+  Iodine::DEFAULT_HTTP_ARGS[:public] = ARGV[ARGV.index('-www') + 1]
+end
+if ARGV.index('-tout') && ARGV[ARGV.index('-tout') + 1]
+  Iodine::DEFAULT_HTTP_ARGS[:timeout] = ARGV[ARGV.index('-tout') + 1].to_i
+  puts "WARNNING: timeout set to 0 (ignored, timeout will be ~5 seconds)." if (Iodine::DEFAULT_HTTP_ARGS[:timeout].to_i <= 0 || Iodine::DEFAULT_HTTP_ARGS[:timeout].to_i > 255)
+end
+Iodine::DEFAULT_HTTP_ARGS[:log] = true if ARGV.index('-v')
+
+if ARGV.index('-t') && ARGV[ARGV.index('-t') + 1].to_i != 0
+  Iodine.threads = ARGV[ARGV.index('-t') + 1].to_i
+end
+if ARGV.index('-w') && ARGV[ARGV.index('-w') + 1].to_i != 0
+  Iodine.workers = ARGV[ARGV.index('-w') + 1].to_i
+end
+
+### Puma / Thin DSL compatibility
+
 if(!defined?(after_fork))
   # Performs a block of code whenever a new worker process spins up (performed once per worker).
   def after_fork(*args, &block)
@@ -232,4 +135,3 @@ if(!defined?(before_fork))
 end
 
 
-require 'rack/handler/iodine' unless defined? ::Iodine::Rack::IODINE_RACK_LOADED

data/lib/iodine/connection.rb

@@ -0,0 +1,34 @@
+module Iodine
+  # Iodine's {Iodine::Connection} class is the class that TCP/IP, WebSockets and SSE connections inherit from.
+  #
+  # Instances of this class are passed to the callback objects. i.e.:
+  #
+  #     module MyConnectionCallbacks
+  #       # called when the callback object is linked with a new client
+  #       def on_open client
+  #          client.is_a?(Iodine::Connection) # => true
+  #       end
+  #       # called when data is available
+  #       def on_message client, data
+  #          client.is_a?(Iodine::Connection) # => true
+  #       end
+  #       # called when the server is shutting down, before closing the client
+  #       # (it's still possible to send messages to the client)
+  #       def on_shutdown client
+  #          client.is_a?(Iodine::Connection) # => true
+  #       end
+  #       # called when the client is closed (no longer available)
+  #       def on_close client
+  #          client.is_a?(Iodine::Connection) # => true
+  #       end
+  #       # called when all the previous calls to `client.write` have completed
+  #       # (the local buffer was drained and is now empty)
+  #       def on_drained client
+  #          client.is_a?(Iodine::Connection) # => true
+  #       end
+  #     end
+  #
+  # All connection related actions can be performed using the methods provided through this class.
+	class Connection
+	end
+end

data/lib/iodine/pubsub.rb

@@ -26,9 +26,9 @@ module Iodine
     # Iodine comes with two built-in engines:
     #
     # * `Iodine::PubSub::Engine::CLUSTER` will distribute messages to all subscribers in the process cluster.
-    # * `Iodine::PubSub::Engine::SINGLE_PROCESS` will distribute messages to all subscribers sharing the same process.
+    # * `Iodine::PubSub::Engine::PROCESS` will distribute messages to all subscribers sharing the same process.
     #
-    # {Iodine::PubSub::Engine} instances should be initialized only after Iodine
+    # It's recommended that {Iodine::PubSub::Engine} instances be initialized only after Iodine
     # started running (or the `fork`ing of the engine's connection will introduce communication issues).
     #
     # For this reason, the best approcah to initialization would be:
@@ -41,28 +41,15 @@ module Iodine
     #          MyEngine = MyEngineClass.new
     #       end
     #
-    # {Iodine::PubSub::Engine} child classes MUST override the {Iodine::PubSub::Engine#subscribe},
-    # {Iodine::PubSub::Engine#unsubscribe} and {Iodine::PubSub::Engine#publish}
+    # {Iodine::PubSub::Engine} child classes MUST override the {Iodine::PubSub::Engine#subscribe}, {Iodine::PubSub::Engine#unsubscribe} and {Iodine::PubSub::Engine#publish}
     # in order to perform this actions using the backend service (i.e. using Redis).
     #
     # Once an {Iodine::PubSub::Engine} instance receives a message from the backend service,
-    # it should forward the message to the Iodine distribution layer using the {Iodine::PubSub::Engine#distribute} method.
+    # it should forward the message to the Iodine distribution layer using the {Iodine.publish} method, setting the 3rd argument to `false`.
     #
-    # Iodine will than distribute the message to all registered clients.
-    #
-    # *IMPORTANT*:
-    #
-    # Connections shouldn't call any of the {Iodine::PubSub::Engine} or {Iodine::PubSub} methods directly,
-    # since connections might be disconnected at any time, at which point their memory will become corrupted or recycled.
-    #
-    # The connection pub/sub methods (coming soon) keep the application safe from these
-    # risks by performing specific checks for connection related pub/sub actions.
+    # Iodine will than distribute the message to all registered clients in that specific process (if the engine is cluster wide, set the 3rd argument to {Iodine::PubSub::CLUSTER}.
     #
     class Engine
     end
-    # This is the (currently) default pub/sub engine. It will distribute messages to all subscribers in the process cluster.
-    CLUSTER
-    # This is a single process pub/sub engine. It will distribute messages to all subscribers sharing the same process.
-    SINGLE_PROCESS
   end
 end

data/lib/iodine/rack_utils.rb

@@ -0,0 +1,43 @@
+module Iodine
+  # Iodine's {Iodine::Rack} module provides a Rack complient interface (connecting Iodine to Rack) for an HTTP and Websocket Server.
+	module Rack
+		# The methods in this module are designed to be Rack compatible and to provide higher performance than the original Rack methods.
+		#
+		# Iodine does NOT monkey patch Rack automatically. However, it's possible and recommended to moneky patch Rack::Utils to use the methods in this module.
+    #
+		# Choosing to monkey patch Rack::Utils could offer significant performance gains for some applications. i.e. (on my machine):
+		#
+		#       require 'iodine'
+		#       require 'rack'
+		#       # a String in need of decoding
+		#       s = '%E3%83%AB%E3%83%93%E3%82%A4%E3%82%B9%E3%81%A8'
+		#       Benchmark.bm do |bm|
+		#         # Pre-Patch
+		#         bm.report("   Rack.unescape")    {1_000_000.times { Rack::Utils.unescape s } }
+		#         bm.report("    Rack.rfc2822")    {1_000_000.times { Rack::Utils.rfc2822(Time.now) } }
+		#         bm.report("    Rack.rfc2109")    {1_000_000.times { Rack::Utils.rfc2109(Time.now) } }
+		#         # Perform Patch
+		#         Iodine.patch_rack
+		#         puts "            --- Monkey Patching Rack ---"
+		#         # Post Patch
+		#         bm.report("Patched.unescape")    {1_000_000.times { Rack::Utils.unescape s } }
+		#         bm.report(" Patched.rfc2822")    {1_000_000.times { Rack::Utils.rfc2822(Time.now) } }
+		#         bm.report(" Patched.rfc2109")    {1_000_000.times { Rack::Utils.rfc2109(Time.now) } }
+		#       end && nil
+		#
+		# Results:
+		#
+		#         user     system      total        real
+		#         Rack.unescape  8.706881   0.019995   8.726876 (  8.740530)
+		#         Rack.rfc2822  3.270305   0.007519   3.277824 (  3.279416)
+		#         Rack.rfc2109  3.152188   0.003852   3.156040 (  3.157975)
+		#                    --- Monkey Patching Rack ---
+		#         Patched.unescape  0.327231   0.003125   0.330356 (  0.337090)
+		#         Patched.rfc2822  0.691304   0.003330   0.694634 (  0.701172)
+		#         Patched.rfc2109  0.685029   0.001956   0.686985 (  0.687607)
+		#
+		# Iodine uses the same code internally for HTTP timestamping (adding missing `Date` headers) and logging.
+		module Utils
+		end
+	end
+end

data/lib/iodine/version.rb

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

data/lib/rack/handler/iodine.rb

@@ -3,202 +3,21 @@ require 'iodine' unless defined?(::Iodine::VERSION)
 module Iodine
   # 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)
-      @app = val
-    end
-
-    # get/set the Rack application.
-    def self.app
-      @app
-    end
-    @app = nil
-
-    # 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 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)
-      @ws_timeout = t
-    end
-
-    # 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
-      @ws_timeout
-    end
-    @ws_timeout = 0
-
-    # get/set the HTTP public folder property. Defaults to the incoming arguments or `nil`.
-    def self.public=(val)
-      @public = val
-    end
-    @public = nil
-
-    # get/set the HTTP public folder property. Defaults to `nil`.
-    def self.public
-      @public
-    end
-
-    # get/set the maximum HTTP body size for incoming data. Defaults to ~50Mb. 0 values are silently ignored.
-    def self.max_body_size=(val)
-      @max_body = val
-    end
-
-    # get/set the maximum HTTP body size for incoming data. Defaults to ~50Mb.
-    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
-    end
-
-    # get/set the maximum HTTP body size for incoming data. Defaults to ~50Mb.
-    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)
-      @max_msg = val
-    end
-
-    # 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
-      @max_msg
-    end
-
-    # get/set the maximum Websocket body size for incoming data. Defaults to defaults to ~250KB. 0 values are silently ignored.
-    def self.max_msg=(val)
-      @max_msg = val
-    end
-
-    # get/set the maximum Websocket body size for incoming data. Defaults to defaults to ~250KB. 0 values are silently ignored.
-    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)
-      @log = val
-    end
-
-    # get/set the HTTP logging value (true / false). Defaults to the incoming argumrnts or `false`.
-    def self.log
-      @log
-    end
-    @log = false
-
-    # get/set the HTTP listening port. Defaults to 3000.
-    def self.port=(val)
-      @port = val
-    end
-
-    # get/set the HTTP listening port. Defaults to 3000.
-    def self.port
-      @port
-    end
-    @port = 3000.to_s
-
-    # get/set the HTTP socket binding address. Defaults to `nil` (usually best).
-    def self.address=(val)
-      @address = val
-    end
-
-    # get/set the HTTP socket binding address. Defaults to `nil` (usually best).
-    def self.address
-      @address
-    end
-    @address = nil
 
     # Runs a Rack app, as par the Rack handler requirements.
     def self.run(app, options = {})
       # nested applications... is that a thing?
-      if @app && @app != app
-        old_app = @app
-        @app = proc do |env|
-          ret = old_app.call(env)
-          ret = app.call(env) if !ret.is_a?(Array) || (ret.is_a?(Array) && ret[0].to_i == 404)
-          ret
-        end
-      else
-        @app = app
-      end
-      @port = options[:Port].to_s if options[:Port]
-      @address = options[:Address].to_s if options[:Address]
-
-      # # provide Websocket features using Rack::Websocket
-      # Rack.send :remove_const, :Websocket if defined?(Rack::Websocket)
-      # Rack.const_set :Websocket, ::Iodine::Websocket
+      Iodine.listen2http(app: app, port: options[:Port], address: options[:Address])
 
       # start Iodine
       Iodine.start
 
-      # # remove the Websocket features from Rack::Websocket
-      # Rack.send :remove_const, :Websocket
-
       true
     end
     IODINE_RACK_LOADED = true
   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'
 
 # make Iodine the default fallback position for Rack.