iodine 0.7.60 → 0.8.0

data/examples/pubsub_engine.ru

@@ -1,81 +0,0 @@
-# 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/rack3.ru

@@ -1,12 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-# adjusted from the code suggested by @taku0 (GitHub issue #131)
-require 'rack'
-require 'iodine'
-
-run { |env|
-  response = Rack::Response.new(nil, 204)
-  response.set_cookie('aaa', 'aaa')
-  response.set_cookie('bbb', 'bbb')
-  response.finish
-}

data/examples/redis.ru

@@ -1,70 +0,0 @@
-# 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

@@ -1,73 +0,0 @@
-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

@@ -1,90 +0,0 @@
-# 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

@@ -1,66 +0,0 @@
-#! 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

@@ -1,14 +0,0 @@
-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