iodine 0.3.6 → 0.4.0

data/bin/echo

@@ -33,7 +33,7 @@ class EchoProtocol
   # `on_message` has a 1Kb buffer that recycles itself for memory optimization.
   def on_message(buffer)
     # writing will never block and will use a buffer written in C when needed.
-    write "Echo: #{buffer}"
+    write! "Echo: #{buffer}"
     puts buffer.dump
     close if buffer =~ /^bye[\r\n]/i
   end
@@ -41,6 +41,6 @@ end
 
 # create the server object and setup any settings we might need.
 Iodine.listen 3000, EchoProtocol
-# server.threads = 10
+Iodine.threads = 10
 # server.processes = 1
 Iodine.start

data/bin/http-hello

@@ -19,6 +19,7 @@ Iodine::Rack.public = '~/Documents/Scratch'
 count = 2
 Iodine::Rack.app = proc { |_env| [200, { 'Content-Length'.freeze => '12'.freeze }, ['He11o World!'.freeze]] }
 puts Iodine::Rack.address
+Iodine::HTTP.listen app: Iodine::Rack.app, port: "3030", public: '~/Documents/Scratch'
 Iodine.start
 
 # puts env.to_a.map { |pair| pair.join(': ') } .join("\n").to_s;

data/bin/updated api

@@ -0,0 +1,113 @@
+#!/usr/bin/env ruby
+
+Dir.chdir(File.expand_path(File.join('..', '..'), __FILE__))
+puts `rake clean`
+puts `rake compile`
+
+require 'benchmark'
+$LOAD_PATH.unshift File.expand_path(File.join('..', '..', 'lib'), __FILE__)
+require 'bundler/setup'
+require 'iodine'
+require 'rack'
+
+class WSEcho
+  def self.call(env)
+    if env['upgrade.websocket?'.freeze] # && env['HTTP_UPGRADE'.freeze] =~ /websocket/i
+      env['upgrade.websocket'.freeze] = WSEcho
+      return [0, {}, []]
+    end
+    out = "ENV:\r\n#{env.to_a.map { |h| "#{h[0]}: #{h[1]}" } .join "\n"}\n"
+    request = Rack::Request.new(env)
+    out += "\nRequest Path: #{request.path_info}\nParams:\r\n#{request.params.to_a.map { |h| "#{h[0]}: #{h[1]}" } .join "\n"}\n" unless request.params.empty?
+    [200, { 'Content-Length' => out.length, 'Content-Type' => 'text/plain; charset=UTF-8;' }, [out]]
+  end
+
+  def on_open
+    puts 'We have a websocket connection'
+    Iodine::Websocket.defer(uuid) { |ws| puts "This websocket's uuid is #{ws.uuid}" }
+  end
+
+  def on_close
+    puts "Bye Bye... only #{count} left..."
+  end
+
+  def on_shutdown
+    puts "I'm shutting down #{self}"
+  end
+
+  def on_ready
+    puts "on_ready called for #{self}"
+  end
+
+  def on_message(data)
+    puts "got message: #{data}"
+    write data
+    write (data * 16_384) if data =~ /^multi me$/
+  end
+
+  def echo(data)
+    write "echo: #{data}"
+  end
+end
+
+# create the server object and setup any settings we might need.
+Iodine.threads ||= 4
+Iodine.processes ||= 1
+count = 2
+
+Iodine::HTTP.listen app: WSEcho, log: true, port: 3000
+Iodine.start
+# server.on_http= Proc.new do |env|
+#   # [200, {"Content-Length".freeze => "12".freeze}, ["Hello World!".freeze]];
+#   if env["HTTP_UPGRADE".freeze] =~ /websocket/i.freeze
+#     env['iodine.websocket'.freeze] = WSEcho.new
+#     [0,{}, []]
+#   else
+#     req = Rack::Request.new env
+#     res = Rack::Response.new
+#     res.write "Hello World!".freeze
+#     res.to_a
+#   end
+# end
+
+# server.on_start do
+#   server.run_every(1000) {puts "#{server.connection_count} clients connected."}
+# end
+
+# puts "Press enter to start (#{Process.pid})"
+# gets
+
+# def nag
+#   puts `ab -n 200000 -c 2000 -k http://127.0.0.1:3000/`
+#   sleep 2
+# end
+#
+# nag while true
+#
+# def nag
+#   puts `wrk -c2000 -d10 -t4 http://localhost:3000/`
+#   sleep 3
+# end
+#
+# nag while true
+
+# ab -n 100000 -c 200 -k http://127.0.0.1:3000/
+# ab -n 100000 -c 4000 -k http://127.0.0.1:3000/
+# ab -n 1000000 -c 20000 -k http://127.0.0.1:3000/
+# ~/ruby/wrk/wrk -c400 -d10 -t12 http://localhost:3000/
+# wrk -c200 -d4 -t12 http://localhost:3000/
+# ab -n 2000 -c 20 -H "Connection: close" http://127.0.0.1:3000/
+# RACK_ENV="production" rackup -p 3000 -s iodine
+
+# thor --amount 5000 ws://localhost:3000/echo
+# thor --amount 5000 ws://localhost:3000/broadcast
+
+# ws = new WebSocket("ws://localhost:3000"); ws.onmessage = function(e) {console.log("Got message!"); console.log(e.data);}; ws.onclose = function(e) {console.log("closed")}; ws.onopen = function(e) {ws.send("hi");};
+# for(i = 0; i< 256; i++) {
+#   ws = new WebSocket("ws://localhost:3000");
+#   ws.onmessage = function(e) {console.log("Got message!"); console.log(e.data); e.target.close(); };
+#   ws.onclose = function(e) {console.log("closed")};
+#   ws.onopen = function(e) {e.target.send("hi");};
+# };
+# ws = new WebSocket("ws://localhost:3000"); ws.onmessage = function(e) {console.log("Got message " + e.data.length + " bytes long"); for(var i = 0; i < e.data.length ; i += 4) {if (e.data.slice(i, i+4) != "text") {console.log( "incoming message corrupted? ", e.data.slice(i, i+4) ); return;};}; }; ws.onclose = function(e) {console.log("closed")}; ws.onopen = function(e) {ws.send("hi");};
+# str = "text"; function size_test() { if(ws.readyState != 1) return; if(str.length > 4194304) {console.log("str reached 4MiB!"); str = "test"; return;}; ws.send(str); str = str + str; window.setTimeout(size_test, 150); }; size_test();

data/bin/ws-echo

@@ -58,7 +58,6 @@ Iodine::Rack.log = 1
 count = 2
 Iodine::Rack.app = WSEcho
 Iodine.start
-
 # server.on_http= Proc.new do |env|
 #   # [200, {"Content-Length".freeze => "12".freeze}, ["Hello World!".freeze]];
 #   if env["HTTP_UPGRADE".freeze] =~ /websocket/i.freeze

data/examples/broadcast.ru

@@ -0,0 +1,56 @@
+# This is a Websocket echo application.
+#
+# Running this application from the command line is eacy with:
+#
+#      iodine hello.ru
+#
+# Or, in single thread and single process:
+#
+#      iodine -t 1 -w 1 hello.ru
+#
+# Benchmark with `ab` or `wrk` (a 5 seconds benchmark with 2000 concurrent clients):
+#
+#      ab -c 2000 -t 5 -n 1000000 -k http://127.0.0.1:3000/
+#      wrk -c2000 -d5 -t12 http://localhost:3000/
+
+
+# A simple router - Checks for Websocket Upgrade and answers HTTP.
+module MyHTTPRouter
+  # This is the HTTP response object according to the Rack specification.
+  HTTP_RESPONSE = [200, { 'Content-Type' => 'text/html',
+          'Content-Length' => '32' },
+   ['Please connect using websockets.']]
+
+  WS_RESPONSE = [0, {}, []].freeze
+
+   # this is function will be called by the Rack server (iodine) for every request.
+   def self.call env
+     # check if this is an upgrade request.
+     if(env['upgrade.websocket?'.freeze])
+       env['upgrade.websocket'.freeze] = WebsocketBroadcast
+       return WS_RESPONSE
+     end
+     # simply return the RESPONSE object, no matter what request was received.
+     HTTP_RESPONSE
+   end
+end
+
+# A simple Websocket Callback Object.
+class WebsocketBroadcast
+  # seng a message to new clients.
+  def on_open
+    puts self
+    write "Welcome to our echo service!"
+  end
+  # send a message, letting the client know the server is suggunt down.
+  def on_shutdown
+    write "Server shutting down. Goodbye."
+  end
+  # perform the echo
+  def on_message data
+    write data
+  end
+end
+
+# this function call links our HelloWorld application with Rack
+run MyHTTPRouter

data/examples/echo.ru

@@ -0,0 +1,57 @@
+# This is a Websocket echo application.
+#
+# Running this application from the command line is eacy with:
+#
+#      iodine hello.ru
+#
+# Or, in single thread and single process:
+#
+#      iodine -t 1 -w 1 hello.ru
+#
+# Benchmark with `ab` or `wrk` (a 5 seconds benchmark with 2000 concurrent clients):
+#
+#      ab -c 2000 -t 5 -n 1000000 -k http://127.0.0.1:3000/
+#      wrk -c2000 -d5 -t12 http://localhost:3000/
+
+
+# A simple router - Checks for Websocket Upgrade and answers HTTP.
+module MyHTTPRouter
+  # This is the HTTP response object according to the Rack specification.
+  HTTP_RESPONSE = [200, { 'Content-Type' => 'text/html',
+          'Content-Length' => '32' },
+   ['Please connect using websockets.']]
+
+   WS_RESPONSE = [0, {}, []].freeze
+
+   # this is function will be called by the Rack server (iodine) for every request.
+   def self.call env
+     # check if this is an upgrade request.
+     if(env['upgrade.websocket?'.freeze])
+       env['upgrade.websocket'.freeze] = WebsocketEcho
+       return [0, {}, []]
+       return WS_RESPONSE
+     end
+     # simply return the RESPONSE object, no matter what request was received.
+     HTTP_RESPONSE
+   end
+end
+
+# A simple Websocket Callback Object.
+class WebsocketEcho
+  # seng a message to new clients.
+  def on_open
+    p self
+    write "Welcome to our echo service!"
+  end
+  # send a message, letting the client know the server is suggunt down.
+  def on_shutdown
+    write "Server shutting down. Goodbye."
+  end
+  # perform the echo
+  def on_message data
+    write data
+  end
+end
+
+# this function call links our HelloWorld application with Rack
+run MyHTTPRouter

data/examples/hello.ru

@@ -0,0 +1,30 @@
+# This is a simple Hello World Rack application
+#
+# Running this application from the command line is eacy with:
+#
+#      iodine hello.ru
+#
+# Or, in single thread and single process:
+#
+#      iodine -t 1 -w 1 hello.ru
+#
+# Benchmark with `ab` or `wrk` (a 5 seconds benchmark with 2000 concurrent clients):
+#
+#      ab -c 2000 -t 5 -n 1000000 -k http://127.0.0.1:3000/
+#      wrk -c2000 -d5 -t12 http://localhost:3000/
+
+module HelloWorld
+  # This is the HTTP response object according to the Rack specification.
+  RESPONSE = [200, { 'Content-Type' => 'text/html',
+          'Content-Length' => '32' },
+   ['Please connect using websockets.']]
+
+   # this is function will be called by the Rack server (iodine) for every request.
+   def self.call env
+     # simply return the RESPONSE object, no matter what request was received.
+     RESPONSE
+   end
+end
+
+# this function call links our HelloWorld application with Rack
+run HelloWorld

data/examples/redis.ru

@@ -0,0 +1,69 @@
+# This example implements a Redis pub/sub engine according to the Iodine::PubSub::Engine specifications.
+#
+# The engine code is locates at examples/redis_pubsub.rb and it requires the hiredis gem.
+#
+# Run this applications on two ports, in two terminals to see the synchronization is action
+#
+#      REDIS_URL=redis://localhost:6379/0 iodine -t 1 -p 3000 redis.ru
+#      REDIS_URL=redis://localhost:6379/0 iodine -t 1 -p 3030 redis.ru
+#
+require 'uri'
+# initialize the Redis engine for each Iodine process by using `Iodine.run`
+if ENV["REDIS_URL"]
+  uri = URI(ENV["REDIS_URL"])
+  Iodine.default_pubsub = Iodine::PubSub::RedisEngine.new(uri.host, uri.port, 0, uri.password)
+else
+  puts "* No Redis! pub/sub is limited to the process cluster."
+end
+puts "The default Pub/Sub engine is:", Iodine.default_pubsub
+
+# A simple router - Checks for Websocket Upgrade and answers HTTP.
+module MyHTTPRouter
+  # This is the HTTP response object according to the Rack specification.
+  HTTP_RESPONSE = [200, { 'Content-Type' => 'text/html',
+          'Content-Length' => '32' },
+   ['Please connect using websockets.']]
+
+   WS_RESPONSE = [0, {}, []]
+
+   # this is function will be called by the Rack server (iodine) for every request.
+   def self.call env
+     # check if this is an upgrade request.
+     if(env['upgrade.websocket?'.freeze])
+       env['upgrade.websocket'.freeze] = WS_RedisPubSub.new(env['PATH_INFO'] ? env['PATH_INFO'][1..-1] : "guest")
+       return [0, {}, []]
+       return WS_RESPONSE
+     end
+     # simply return the RESPONSE object, no matter what request was received.
+     HTTP_RESPONSE
+   end
+end
+
+# A simple Websocket Callback Object.
+class WS_RedisPubSub
+  def initialize name
+    @name = name
+  end
+  # seng a message to new clients.
+  def on_open
+    subscribe channel: "chat"
+    # let everyone know we arrived
+    # publish channel: "chat", message: "#{@name} entered the chat."
+  end
+  # send a message, letting the client know the server is suggunt down.
+  def on_shutdown
+    write "Server shutting down. Goodbye."
+  end
+  # perform the echo
+  def on_message data
+    publish channel: "chat", message: "#{@name}: #{data}"
+  end
+  def on_close
+    # let everyone know we left
+    publish channel: "chat", message: "#{@name} left the chat."
+    # we don't need to unsubscribe, subscriptions are cleared automatically once the connection is closed.
+  end
+end
+
+# this function call links our HelloWorld application with Rack
+run MyHTTPRouter

data/examples/shootout.ru

@@ -0,0 +1,53 @@
+require 'iodine'
+
+# ON_IDLE = proc { Iodine::Base.db_print_registry ; Iodine.on_idle(&ON_IDLE) }
+# ON_IDLE.call
+
+class ShootoutApp
+  # the default HTTP response
+  def self.call(env)
+    if env['upgrade.websocket?'.freeze] # && env['HTTP_UPGRADE'.freeze] =~ /websocket/i
+      env['upgrade.websocket'.freeze] = ShootoutApp.new
+      return [0, {}, []]
+    end
+    out = "ENV:\r\n#{env.to_a.map { |h| "#{h[0]}: #{h[1]}" } .join "\n"}\n"
+    request = Rack::Request.new(env)
+    out += "\nRequest Path: #{request.path_info}\nParams:\r\n#{request.params.to_a.map { |h| "#{h[0]}: #{h[1]}" } .join "\n"}\n" unless request.params.empty?
+    [200, { 'Content-Length' => out.length, 'Content-Type' => 'text/plain; charset=UTF-8;' }, [out]]
+  end
+  # We'll base the shootout on the internal Pub/Sub service.
+  # It's slower than writing to every socket a pre-parsed message, but it's closer
+  # to real-life implementations.
+  def on_open
+    subscribe channel: "shootout"
+  end
+  def on_message data
+    if data[0] == 'b' # binary
+      publish(channel: "shootout", message: data)
+      data[0] = 'r'
+      write data
+      return
+    end
+    cmd, payload = JSON(data).values_at('type', 'payload')
+    if cmd == 'echo'
+      write({type: 'echo', payload: payload}.to_json)
+    else
+      # data = {type: 'broadcast', payload: payload}.to_json
+      # broadcast :push2client, data
+      publish(channel: "shootout", message: ({type: 'broadcast', payload: payload}.to_json))
+      write({type: "broadcastResult", payload: payload}.to_json)
+    end
+  rescue
+    puts "Incoming message format error - not JSON?"
+  end
+end
+
+run ShootoutApp
+#
+# def cycle
+#   puts `websocket-bench broadcast ws://127.0.0.1:3000/ --concurrent 10 --sample-size 100 --server-type binary --step-size 1000 --limit-percentile 95 --limit-rtt 250ms --initial-clients 1000`
+#   sleep(2)
+#   puts `wrk -c4000 -d15 -t12 http://localhost:3000/`
+#   true
+# end
+# sleep(10) while cycle

data/exe/iodine

@@ -1,83 +1,5 @@
 #!/usr/bin/env ruby
 
-require 'iodine'
-require 'rack'
+require 'iodine/cli'
 
-if ARGV[0] =~ /(\-\?)|(help)|(\?)$/
-  puts <<-EOS
-
-Iodine's HTTP/Websocket server version #{Iodine::VERSION}
-
-Use:
-
-    iodine <options> <filename>
-
-Both <options> and <filename> are optional.
-
-Available options:
- -p          Port number. Default: 3000.
- -t          Number of threads. Default: half of the CPU core count.
- -w          Number of worker processes. half of the CPU core count.
- -www        Public folder for static file serving. Default: nil (none).
- -v          Log responses.
- -q          Never log responses.
- -warmup     Warmup invokes autoloading (lazy loading) during server startup.
- -tout       HTTP inactivity connection timeout. Default: 5.
- -maxbd      Maximum Mb per HTTP message (max body size). Default: 50Mib.
- -maxms      Maximum Bytes per Websocket message. Default: 250Kib.
- -ping       Websocket ping interval in seconds. Default: 40 seconds.
- <filename>  Defaults to: config.ru
-
-Example:
-
-    iodine -p 80
-
-    iodine -p 8080 path/to/app/conf.ru
-
-    iodine -p 8080 -w 4 -t 16
-
-EOS
-  exit(0)
-end
-
-app, opt = nil, nil
-filename = (ARGV[-2].to_s[0] != '-' && ARGV[-1].to_s[0] != '-' && ARGV[-1]) || 'config.ru'
-
-begin
-  app, opt = Rack::Builder.parse_file filename
-rescue
-  if ARGV.index('-www') && ARGV[ARGV.index('-www') + 1]
-    puts "WARNING: Ruby application not found - missing #{filename}?"
-    puts "         Running only static file service."
-    app = Rack::Builder.new do
-      run lambda { |env| [404, {'Content-Type' => 'text/plain', 'Content-Length'.freeze => '21'.freeze}, ['Error 404 - Not Found']] }
-    end
-    opt = Rack::Server::Options.new.parse!([])
-    p app, opt
-  else
-    puts "ERROR: Ruby application not found - missing #{filename}? For help run:"
-    puts "       iodine -?"
-    exit(0)
-  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 minutes)."
-end
-Iodine::Rack.log = true if ARGV.index('-v')
-Iodine::Rack.log = false if ARGV.index('-q')
-Iodine.warmup if ARGV.index('-warmup')
-Iodine::Rack.run(app, opt)
+Iodine::Base::CLI.call