isomorfeus-iodine 0.7.44

data/examples/async_task.ru

@@ -0,0 +1,92 @@
+# This is a task scheduling WebSocket push example application.
+#
+# Benchmark HTTPP 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/
+#
+# Test websocket tasks using the browser. For example:
+#      ws = new WebSocket("ws://localhost:3000/userID"); ws.onmessage = function(e) {console.log(e.data);}; ws.onclose = function(e) {console.log("closed")};
+#      ws.onopen = function(e) {ws.send(JSON.stringify({'task': 'echo', 'data': 'Hello!'}));};
+require 'iodine'
+require 'json'
+
+TASK_PUBLISHING_ENGINE = Iodine::PubSub::PROCESS
+
+# This module handles tasks and send them back to the frontend
+module TaskHandler
+  def echo msg
+    msg = Iodine::JSON.parse(msg, symbolize_names: true)
+    publish_to = msg.delete(:from)
+    Iodine.publish(publish_to, msg.to_json, TASK_PUBLISHING_ENGINE) if publish_to
+    puts "performed 'echo' task"
+  rescue => e
+    puts "JSON task message error? #{e.message} - under attack?"
+  end
+
+  def add msg
+    msg = Iodine::JSON.parse(msg, symbolize_names: true)
+    raise "addition task requires an array of numbers" unless msg[:data].is_a?(Array)
+    msg[:data] = msg[:data].inject(0){|sum,x| sum + x }
+    publish_to = msg.delete(:from)
+    Iodine.publish(publish_to, msg.to_json, TASK_PUBLISHING_ENGINE) if publish_to
+    puts "performed 'add' task"
+  rescue => e
+    puts
+     "JSON task message error? #{e.message} - under attack?"
+  end
+
+  def listen2tasks
+    Iodine.subscribe(:echo) {|ch,msg| TaskHandler.echo(msg) }
+    Iodine.subscribe(:add) {|ch,msg| TaskHandler.add(msg) }
+  end
+
+  extend self
+end
+
+module WebsocketClient
+  def on_open client
+    # Pub/Sub directly to the client (or use a block to process the messages)
+    client.subscribe client.env['PATH_INFO'.freeze]
+  end
+  def on_message client, data
+    # Strings and symbol channel names are equivalent.
+    msg = Iodine::JSON.parse(data, symbolize_names: true)
+    raise "no valid task" unless ["echo".freeze, "add".freeze].include? msg[:task]
+    msg[:from] = client.env['PATH_INFO'.freeze]
+    client.publish msg[:task], msg.to_json, TASK_PUBLISHING_ENGINE
+  rescue => e
+      puts "JSON message error? #{e.message}\n\t#{data}\n\t#{msg}"
+  end
+  extend self
+end
+
+APP = Proc.new do |env|
+  if env['rack.upgrade?'.freeze] == :websocket 
+    env['rack.upgrade'.freeze] = WebsocketClient 
+    [0,{}, []] # It's possible to set cookies for the response.
+  elsif env['rack.upgrade?'.freeze] == :sse
+    puts "SSE connections can only receive data from the server, the can't write." 
+    env['rack.upgrade'.freeze] = WebsocketClient
+    [0,{}, []] # It's possible to set cookies for the response.
+  else
+    [200, {"Content-Type" => "text/plain"}, ["Send messages with WebSockets using JSON.\ni.e.: {\"task\":\"add\", \"data\":[1,2]}"]]
+  end
+end
+
+# test automatically for Redis extensions.
+if(Iodine::PubSub.default.is_a? Iodine::PubSub::Redis)
+  TASK_PUBLISHING_ENGINE = Iodine::PubSub.default
+  if(ARGV.include? "worker")
+    TaskHandler.listen2tasks
+    Iodine.workers = 1
+    Iodine.threads = 16 if Iodine.threads == 0
+    Iodine.start
+    exit(0)
+  end
+else
+  TaskHandler.listen2tasks
+end
+
+# # or in config.ru
+run APP

data/examples/config.ru

@@ -0,0 +1,56 @@
+# This is a WebSocket / SSE notification broadcasting application.
+#
+# Running this application from the command line is easy with:
+#
+#      iodine
+#
+# Or, in single thread and single process:
+#
+#      iodine -t 1 -w 1
+#
+# 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' => '77' },
+   ['Please connect using WebSockets or SSE (send messages only 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 (WebsSocket / SSE).
+     if(env['rack.upgrade?'.freeze])
+       env['rack.upgrade'.freeze] = BroadcastClient
+       return WS_RESPONSE
+     end
+     # simply return the RESPONSE object, no matter what request was received.
+     HTTP_RESPONSE
+   end
+end
+
+# A simple Websocket Callback Object.
+module BroadcastClient
+  # seng a message to new clients.
+  def on_open client
+    client.subscribe :broadcast
+  end
+  # send a message, letting the client know the server is suggunt down.
+  def on_shutdown client
+    client.write "Server shutting down. Goodbye."
+  end
+  # perform the echo
+  def on_message client, data
+    client.publish :broadcast, data
+  end
+  extend self
+end
+
+# this function call links our HelloWorld application with Rack
+run MyHTTPRouter

data/examples/echo.ru

@@ -0,0 +1,59 @@
+# This is a Websocket echo application.
+#
+# Running this application from the command line is easy with:
+#
+#      iodine echo.ru
+#
+# Or, in single thread and single process:
+#
+#      iodine -t 1 -w 1 echo.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/
+#
+# Test websocket echo using the browser. For example:
+#      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");};
+
+
+# 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['rack.upgrade?'.freeze] == :websocket)
+       env['rack.upgrade'.freeze] = WebsocketEcho
+       return WS_RESPONSE
+     end
+     # simply return the RESPONSE object, no matter what request was received.
+     HTTP_RESPONSE
+   end
+end
+
+# A simple Websocket Callback Object.
+module WebsocketEcho
+  # seng a message to new clients.
+  def on_open client
+    client.write "Welcome to our echo service!"
+  end
+  # send a message, letting the client know the server is suggunt down.
+  def on_shutdown client
+    client.write "Server shutting down. Goodbye."
+  end
+  # perform the echo
+  def on_message client, data
+    client.write data
+  end
+  extend self
+end
+
+# this function call links our HelloWorld application with Rack
+run MyHTTPRouter

data/examples/hello.ru

@@ -0,0 +1,29 @@
+# This is a simple Hello World Rack application
+#
+# Running this application from the command line is easy 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' => '12' }, [ 'Hello World!' ] ]
+
+   # 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/pubsub_engine.ru

@@ -0,0 +1,81 @@
+# This example implements a custom (noop) pub/sub engine according to the Iodine::PubSub::Engine specifications.
+#
+require 'uri'
+require 'iodine'
+
+# creates an example Pub/Sub Engine that merely reports any pub/sub events to the system's terminal
+class PubSubReporter < Iodine::PubSub::Engine
+  def initialize
+    # make sure engine setup is complete
+    super
+    # register engine and make it into the new default
+    @target = Iodine::PubSub.default
+    Iodine::PubSub.default = self
+    Iodine::PubSub.attach self
+  end
+  def subscribe to, as = nil
+    puts "* Subscribing to \"#{to}\" (#{as || "exact match"})"
+  end
+  def unsubscribe to, as = nil
+    puts "* Unsubscribing to \"#{to}\" (#{as || "exact match"})"
+  end
+  def publish to, msg
+    puts "* Publishing to \"#{to}\": #{msg.to_s[0..12]}..."
+    # we need to forward the message to the actual engine (the previous default engine),
+    # or it will never be received by any Pub/Sub client.
+    @target.publish to, msg
+  end
+end
+
+PubSubReporter.new
+
+# 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['rack.upgrade?'.freeze])
+       puts "SSE connections will not be able te send data, just listen." if(env['rack.upgrade?'.freeze] == :sse)
+       env['rack.upgrade'.freeze] = PubSubClient.new(env['PATH_INFO'] && env['PATH_INFO'].length > 1 ? env['PATH_INFO'][1..-1] : "guest")
+       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 PubSubClient
+  def initialize name
+    @name = name
+  end
+  # seng a message to new clients.
+  def on_open(client)
+    client.subscribe "chat"
+    # let everyone know we arrived
+    client.publish "chat", "#{@name} entered the chat."
+  end
+  # send a message, letting the client know the server is suggunt down.
+  def on_shutdown(client)
+    client.write "Server shutting down. Goodbye."
+  end
+  # perform the echo
+  def on_message(client, data)
+    client.publish "chat", "#{@name}: #{data}"
+  end
+  def on_close(client)
+    # let everyone know we left
+    client.publish "chat", "#{@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/redis.ru

@@ -0,0 +1,70 @@
+# This example implements a Redis pub/sub engine according to the Iodine::PubSub::Engine specifications.
+#
+# Run this applications on two ports, in two terminals to see the synchronization is action:
+#
+#      IODINE_REDIS_URL=redis://localhost:6379/0 iodine -t 1 -p 3000 redis.ru
+#      IODINE_REDIS_URL=redis://localhost:6379/0 iodine -t 1 -p 3030 redis.ru
+#
+# Or:
+#
+#      iodine -t 1 -p 3000 redis.ru -redis redis://localhost:6379/0
+#      iodine -t 1 -p 3030 redis.ru -redis redis://localhost:6379/0
+#
+require 'iodine'
+# initialize the Redis engine for each Iodine process.
+if Iodine::DEFAULT_HTTP_ARGS[:redis_]
+  puts "* Redis support automatically detected."
+else
+  puts "* No Redis, it's okay, pub/sub will support the process cluster."
+end
+
+# 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['rack.upgrade?'.freeze])
+       puts "SSE connections will not be able te send data, just listen." if(env['rack.upgrade?'.freeze] == :sse)
+       env['rack.upgrade'.freeze] = WS_RedisPubSub.new(env['PATH_INFO'] && env['PATH_INFO'].length > 1 ? env['PATH_INFO'][1..-1] : "guest")
+       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 client
+    client.subscribe "chat"
+    # let everyone know we arrived
+    client.publish "chat", "#{@name} entered the chat."
+  end
+  # send a message, letting the client know the server is suggunt down.
+  def on_shutdown client
+    client.write "Server shutting down. Goodbye."
+  end
+  # perform the echo
+  def on_message client, data
+    client.publish "chat", "#{@name}: #{data}"
+  end
+  def on_close client
+    # let everyone know we left
+    client.publish "chat", "#{@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,73 @@
+require 'iodine'
+require 'json'
+require 'rack'
+
+module ShootoutApp
+  # the default HTTP response
+  def self.call(env)
+     if(env['rack.upgrade?'.freeze] == :websocket)
+      env['rack.upgrade'.freeze] = ShootoutApp
+      return [0, {}, []]
+    end
+    out = []
+    len = 0
+    out << "ENV:\n"
+    len += 5
+    env.each { |k, v| out << "#{k}: #{v}\n" ; len += out[-1].length }
+    request = Rack::Request.new(env)
+    out << "\nRequest Path: #{request.path_info}\n"
+    len += out[-1].length
+    unless request.params.empty?
+      out << "Params:\n"
+      len += out[-1].length
+      request.params.each { |k,v| out << "#{k}: #{v}\n" ; len += out[-1].length }
+    end
+    if(env['rack.input'])
+      env['rack.input'].rewind
+      out << "Body\n\n"
+      out << env['rack.input'].read
+      len += out[-1].length + 6
+      out << "\n\nBody Length: #{out[-1].length}\n\n"
+      len += out[-1].length
+    end
+    [200, { 'Content-Length' => len.to_s, '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 self.on_open client
+      client.subscribe(:shootout_b, as: :binary) # { |ch, msg| client.write(msg)}
+      client.subscribe(:shootout) # { |ch, msg| client.write(msg)}
+  end
+  def self.on_message client, data
+    if data[0] == 'b' # binary
+      client.publish :shootout_b, data
+      data[0] = 'r'
+      client.write data
+      return
+    end
+    cmd, payload = JSON(data).values_at('type', 'payload')
+    if cmd == 'echo'
+      client.write({type: 'echo', payload: payload}.to_json)
+    else
+      client.publish :shootout, {type: 'broadcast', payload: payload}.to_json
+      client.write({type: "broadcastResult", payload: payload}.to_json)
+    end
+  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(4)
+#   puts `wrk -c4000 -d15 -t2 http://localhost:3000/`
+#   true
+# end
+# sleep(10) while cycle
+
+# # Used when debugging:
+# ON_IDLE = proc { Iodine::Base.db_print_protected_objects ; Iodine.on_idle(&ON_IDLE) }
+# ON_IDLE.call
+# Iodine.on_shutdown { Iodine::Base.db_print_protected_objects }
+

data/examples/sub-protocols.ru

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# This is a WebSocket / SSE notification example application.
+#
+# In this example, WebSocket sub-protocols are explored.
+#
+# Running this application from the command line is easy with:
+#
+#      iodine
+#
+# Or, in a single thread and a single process:
+#
+#      iodine -t 1 -w 1
+#
+# Test using:
+#
+#      var subprotocol = "echo"; // or "chat"
+#      ws = new WebSocket("ws://localhost:3000/Mitchel", subprotocol);
+#      ws.onmessage = function(e) { console.log(e.data); };
+#      ws.onclose = function(e) { console.log("Closed"); };
+#      ws.onopen = function(e) { e.target.send("Yo!"); };
+
+
+# Chat clients connect with the "chat" sub-protocol.
+class ChatClient
+  def on_open client
+    @nickname = client.env['PATH_INFO'].to_s.split('/')[1] || "Guest"
+    client.subscribe :chat
+    client.publish :chat , "#{@nickname} joined the chat."
+  end
+  def on_close client
+    client.publish :chat , "#{@nickname} left the chat."
+  end
+  def on_shutdown client
+    client.write "Server is shutting down... disconnecting all clients. Goodbye."
+  end
+  def on_message client, message
+    client.publish :chat , "#{@nickname}: #{message}"
+  end
+end
+
+# Echo clients connect with the "echo" sub-protocol.
+class EchoClient
+  def on_open client
+    client.write "You established an echo connection."
+  end
+  def on_shutdown client
+    client.write "Server is shutting down... goodbye."
+  end
+  def on_message client, message
+    client.write message
+  end
+end
+
+# Rack application module
+module APP
+  # the allowed protocols
+  CHAT_PROTOCOL_NAME = "chat"
+  ECHO_PROTOCOL_NAME = "echo"
+  PROTOCOLS =[CHAT_PROTOCOL_NAME, ECHO_PROTOCOL_NAME]
+
+  # the Rack application
+  def call env
+    return [200, {}, ["Hello World"]] unless env["rack.upgrade?"]
+    protocol = select_protocol(env)
+    case(protocol)
+    when CHAT_PROTOCOL_NAME
+      env["rack.upgrade"] = ChatClient.new
+      [101, { "Sec-Websocket-Protocol" => protocol }, []]
+    when ECHO_PROTOCOL_NAME
+      env["rack.upgrade"] = EchoClient.new
+      [101, { "Sec-Websocket-Protocol" => protocol }, []]
+    else
+      [400, {}, ["Unsupported protocol specified"]]
+    end
+  end
+
+  def select_protocol(env)
+    request_protocols = env["HTTP_SEC_WEBSOCKET_PROTOCOL"]
+    unless request_protocols.nil?
+      request_protocols = request_protocols.split(/,\s?/) if request_protocols.is_a?(String)
+      request_protocols.detect { |request_protocol| PROTOCOLS.include? request_protocol }
+    end # either `nil` or the result of `request_protocols.detect` are returned
+  end
+
+  # make functions availble as singleton module
+  extend self
+end
+
+run APP

data/examples/tcp_client.rb

@@ -0,0 +1,66 @@
+#! ruby
+
+# A raw TCP/IP client example using iodine.
+#
+# The client will connect to a remote server and send a simple HTTP/1.1 GET request.
+#
+# Once some data was recieved, a delayed closure and shutdown signal will be sent to iodine.
+
+# use a secure connection?
+USE_TLS = true
+
+# remote server details
+$port = USE_TLS ? 443 : 80
+$address = "google.com"
+
+
+# require iodine
+require 'iodine'
+
+# Iodine runtime settings
+Iodine.threads = 1
+Iodine.workers = 1
+Iodine.verbosity = 3 # warnings only
+
+
+# a client callback handler
+module Client
+
+  def self.on_open(client)
+    # Set a connection timeout
+    client.timeout = 10
+    # subscribe to the chat channel.
+    puts "* Sending request..."
+    client.write "GET / HTTP/1.1\r\nHost: #{$address}\r\n\r\n"
+  end
+
+  def self.on_message(client, data)
+    # publish the data we received
+    STDOUT.write data
+    # close the client after a second... we're not really parsing anything, so it's a guess.
+    Iodine.run_after(1000) { client.close }
+  end
+
+  def self.on_close(client)
+    # stop iodine
+    Iodine.stop
+    puts "Done."
+  end
+
+  # returns the callback object (self).
+  def self.call
+    self
+  end
+end
+
+
+
+if(USE_TLS)
+  tls = Iodine::TLS.new
+  tls.on_protocol("http/1.1") { Client }
+end
+# we use can both the `handler` keyword or a block, anything that answers #call.
+Iodine.connect(address: $address, port: $port, handler: Client, tls: tls)
+
+# start the iodine reactor
+Iodine.start

data/examples/x-sendfile.ru

@@ -0,0 +1,14 @@
+app = proc do |env|
+  request = Rack::Request.new(env)
+  if request.path_info == '/source'.freeze
+    [200, { 'X-Sendfile' => File.expand_path(__FILE__), 'Content-Type' => 'text/plain'}, []]
+  elsif request.path_info == '/file'.freeze
+    [200, { 'X-Header' => 'This was a Rack::Sendfile response sent as text.' }, File.open(__FILE__)]
+  else
+    [200, { 'Content-Type' => 'text/html',
+            'Content-Length' => request.path_info.length.to_s },
+     [request.path_info]]
+ end
+end
+
+run app