iodine 0.7.59 → 0.8.0

data/bin/mustache_bench.rb

@@ -1,100 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'benchmark/ips'
-require 'mustache'
-require 'iodine'
-
-def benchmark_mustache
-  # benchmark code was copied, in part, from:
-  #   https://github.com/mustache/mustache/blob/master/benchmarks/render_collection_benchmark.rb
-  template = """
-  {{#products}}
-    <div class='product_brick'>
-      <div class='container'>
-        <div class='element'>
-          <img src='images/{{image}}' class='product_miniature' />
-        </div>
-        <div class='element description'>
-          <a href={{url}} class='product_name block bold'>
-            {{external_index}}
-          </a>
-        </div>
-      </div>
-    </div>
-  {{/products}}
-  """
-
-  IO.write "test_template.mustache", template
-  filename = "test_template.mustache"
-
-  data_1 = {
-    products: [ {
-      :external_index=>"This <product> should've been \"properly\" escaped.",
-      :url=>"/products/7",
-      :image=>"products/product.jpg"
-    } ]
-  }
-  data_1000 = {
-    products: []
-  }
-
-  1000.times do
-    data_1000[:products] << {
-      :external_index=>"product",
-      :url=>"/products/7",
-      :image=>"products/product.jpg"
-    }
-  end
-
-  data_1000_escaped = {
-    products: []
-  }
-
-  1000.times do
-    data_1000_escaped[:products] << {
-      :external_index=>"This <product> should've been \"properly\" escaped.",
-      :url=>"/products/7",
-      :image=>"products/product.jpg"
-    }
-  end
-
-  view = Mustache.new
-  view.template = template
-  view.render # Call render once so the template will be compiled
-  iodine_view = Iodine::Mustache.new(filename)
-
-  puts "Ruby Mustache rendering (and HTML escaping) results in:",
-       view.render(data_1), "",
-       "Notice that Iodine::Mustache rendering (and HTML escaping) results in agressive escaping:",
-       iodine_view.render(data_1), "", "----"
-
-  # return;
-
-  Benchmark.ips do |x|
-    x.report("Ruby Mustache render list of 1000") do |times|
-      view.render(data_1000)
-    end
-    x.report("Iodine::Mustache render list of 1000") do |times|
-      iodine_view.render(data_1000)
-    end
-
-    x.report("Ruby Mustache render list of 1000 with escaped data") do |times|
-      view.render(data_1000_escaped)
-    end
-    x.report("Iodine::Mustache render list of 1000 with escaped data") do |times|
-      iodine_view.render(data_1000_escaped)
-    end
-
-    x.report("Ruby Mustache - no chaching - render list of 1000") do |times|
-      tmp = Mustache.new
-      tmp.template = template
-      tmp.render(data_1000)
-    end
-    x.report("Iodine::Mustache - no chaching - render list of 1000") do |times|
-      Iodine::Mustache.render(nil, data_1000, template)
-    end
-
-  end
-end
-
-benchmark_mustache

data/bin/poc/Gemfile.lock

@@ -1,23 +0,0 @@
-GIT
-  remote: https://github.com/boazsegev/iodine.git
-  revision: 8b57a5f2008b9c35f2cf589be7ed121823a84582
-  specs:
-    iodine (0.2.0)
-      rack
-      rake-compiler
-
-GEM
-  specs:
-    rack (2.0.1)
-    rake (11.2.2)
-    rake-compiler (0.9.5)
-      rake
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  iodine!
-
-BUNDLED WITH
-   1.12.5

data/bin/poc/README.md

@@ -1,37 +0,0 @@
-# A proof of concept for Rack's `env['rack.websocket']`
-
-This is a proof of concept for Rack based Websocket connections, showing how the Rack API can be adjusted to support server native real-time connections.
-
-The chosen proof of concept was the ugliest chatroom I could find.
-
-Although my hope is that Rack will adopt the concept and make `env['rack.websocket?']` and `env['rack.websocket']` part of it's standard, at the moment it's an Iodine specific feature, implemented using `env['iodine.websocket']`.
-
-## Install
-
-Install required gems using:
-
-```sh
-bundler install
-```
-
-## Run
-
-Run this application single threaded:
-
-```sh
-bundler exec iodine -- -www ./www
-```
-
-Or both multi-threaded and forked (you'll notice that memory barriers for forked processes prevent websocket broadcasting from reaching websockets connected to a different process).
-
-```sh
-bundler exec iodine -- -www ./www -t 16 -w 4
-```
-
-## Further reading
-
-* https://github.com/rack/rack/issues/1093
-
-* https://bowild.wordpress.com/2016/07/31/the-dark-side-of-the-rack
-
-* https://github.com/boazsegev/iodine

data/bin/poc/config.ru

@@ -1,66 +0,0 @@
-# The Rack Application container
-module MyRackApplication
-  # Rack applications use the `call` callback to handle HTTP requests.
-  def self.call(env)
-    # if upgrading...
-    if env['HTTP_UPGRADE'.freeze] =~ /websocket/i
-      # We can assign a class or an instance that implements callbacks.
-      # We will assign an object, passing it the request information (`env`)
-      env['iodine.websocket'.freeze] = MyWebsocket.new(env)
-      # Rack responses must be a 3 item array
-      # [status, {http: :headers}, ["response body"]]
-      return [0, {}, []]
-    end
-    # a semi-regualr HTTP response
-    out = File.open File.expand_path('../www/index.html', __FILE__)
-    [200, { 'X-Sendfile' => File.expand_path('../www/index.html', __FILE__),
-            'Content-Length' => out.size }, out]
-  end
-end
-
-# The Websocket Callback Object
-class MyWebsocket
-  # this is optional, but I wanted the object to have the nickname provided in
-  # the HTTP request
-  def initialize(env)
-    # we need to change the ASCI Rack encoding to UTF-8,
-    # otherwise everything with the nickname will be a binary "blob" in the
-    # Javascript layer
-    @nickname = env['PATH_INFO'][1..-1].force_encoding 'UTF-8'
-  end
-
-  # A classic websocket callback, called when the connection is opened and
-  # linked to this object
-  def on_open
-    puts 'We have a websocket connection'
-  end
-
-  # A classic websocket callback, called when the connection is closed
-  # (after disconnection).
-  def on_close
-    puts "Bye Bye... #{count} connections left..."
-  end
-
-  # A server-side niceness, called when the server if shutting down,
-  # to gracefully disconnect (before disconnection).
-  def on_shutdown
-    write 'The server is shutting down, goodbye.'
-  end
-
-  def on_message(data)
-    puts "got message: #{data} encoded as #{data.encoding}"
-    # data is a temporary string, it's buffer cleared as soon as we return.
-    # So we make a copy with the desired format.
-    tmp = "#{@nickname}: #{data}"
-    # The `write` method was added by the server and writes to the current
-    # connection
-    write tmp
-    puts "broadcasting #{tmp.bytesize} bytes with encoding #{tmp.encoding}"
-    # `each` was added by the server and excludes this connection
-    # (each except self).
-    each { |h| h.write tmp }
-  end
-end
-
-# `run` is a Rack API command, telling Rack where the `call(env)` callback is located.
-run MyRackApplication

data/bin/poc/gemfile

@@ -1 +0,0 @@
-gem 'iodine', git: 'https://github.com/boazsegev/iodine.git'

data/bin/poc/www/index.html

@@ -1,57 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-    <script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.4/jquery.min.js"></script>
-    <script>
-        ws = NaN
-        handle = ''
-        function onsubmit(e) {
-            e.preventDefault();
-            if($('#text')[0].value == '') {return false}
-            if(ws && ws.readyState == 1) {
-                ws.send($('#text')[0].value);
-                $('#text')[0].value = '';
-            } else {
-                handle = $('#text')[0].value
-                var url = (window.location.protocol.match(/https/) ? 'wss' : 'ws') +
-                            '://' + window.document.location.host +
-                            '/' + $('#text')[0].value
-                ws = new WebSocket(url)
-                ws.onopen = function(e) {
-                    output("<b>Connected :-)</b>");
-                    $('#text')[0].value = '';
-                    $('#text')[0].placeholder = 'your message';
-                }
-                ws.onclose = function(e) {
-                    output("<b>Disonnected :-/</b>")
-                    $('#text')[0].value = '';
-                    $('#text')[0].placeholder = 'nickname';
-                    $('#text')[0].value = handle
-                }
-                ws.onmessage = function(e) {
-                    output(e.data);
-                }
-            }
-            return false;
-        }
-        function output(data) {
-            $('#output').append("<li>" + data + "</li>")
-            $('#output').animate({ scrollTop:
-                        $('#output')[0].scrollHeight }, "slow");
-        }
-    </script>
-    <style>
-    html, body {width:100%; height: 100%; background-color: #ddd; color: #111;}
-    h3, form {text-align: center;}
-    input {background-color: #fff; color: #111; padding: 0.3em;}
-    </style>
-</head><body>
-  <h3>The Ugly Chatroom POC</h3>
-    <form id='form'>
-        <input type='text' id='text' name='text' placeholder='nickname'></input>
-        <input type='submit' value='send'></input>
-    </form>
-    <script> $('#form')[0].onsubmit = onsubmit </script>
-    <ul id='output'></ul>
-</body>
-</html>

data/examples/async_task.ru

@@ -1,92 +0,0 @@
-# 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/bates/README.md

@@ -1,3 +0,0 @@
-# Bates numbering with CombinePDF and Rack
-
-This folder holds a demo application combining Iodine's `X-Sendfile` support with the [`combine_pdf` gem](https://github.com/boazsegev/combine_pdf) to create a "bates numbering" tool that is common to the one used by some court systems (such as Israeli courts).