iodine 0.7.9 → 0.7.10

data/bin/http-hello

@@ -1,62 +0,0 @@
-#!/usr/bin/env ruby
-
-# this will compile Iodine and run an HTTP server "Hello World" example.
-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'
-
-# create the server object and setup any settings we might need.
-Iodine::Rack
-Iodine.threads ||= 1
-Iodine.processes ||= 1 # 4
-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.start
-
-# puts env.to_a.map { |pair| pair.join(': ') } .join("\n").to_s;
-
-# puts "Press enter to start (#{Process.pid})"
-# gets
-
-###############
-## for testing:
-
-# 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/
-# 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");};
-# };

data/bin/http-playground

@@ -1,124 +0,0 @@
-#!/usr/bin/env ruby
-
-# this is arbitrary code that will be executed after Iodine compiles. Used for ad-hok testing.
-
-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['HTTP_UPGRADE'.freeze] =~ /websocket/i
-      env['iodine.websocket'.freeze] = WSEcho
-      return [0, {}, []]
-    end
-    out = "ENV:\r\n#{env.to_a.map { |h| "#{h[0]}: #{h[1]}" } .join "\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"}" unless request.params.empty?
-    [200, { 'Content-Length' => out.length }, [out]]
-  end
-
-  # def on_open
-  #   puts "We have a websocket connection"
-  # end
-  # def on_close
-  #   puts "Bye Bye... only #{ws_count} left..."
-  # end
-  def on_shutdown
-    puts "I'm shutting down #{self}"
-  end
-
-  def on_message(data)
-    # puts data
-    write data
-    data_cp = data.dup
-    # puts "broadcasting #{data_cp.bytesize} bytes"
-    # each {|h| h.echo data_cp }
-  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
-Iodine::Rack.public = '/Users/2Be/Documents/Scratch'
-count = 2
-Iodine::Rack.app = WSEcho
-
-# 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 {puts "I'm running!"}
-  # server.run_after(5000) {puts "5 seconds have passed."}
-  server.run_every(1000) { puts "#{server.count} clients connected." }
-  # server.run_every(10000) do
-  #   begin
-  #     puts "making a system call"
-  #     puts `ab -n 100000 -c 200 -k http://127.0.0.1:3000/`
-  #   rescue => e
-  #     l = Logger.new STDOUT
-  #     l.error e
-  #   end
-  # 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
-
-server.start
-
-# 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/
-# 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");};
-# };

data/bin/playground

@@ -1,62 +0,0 @@
-#!/usr/bin/env ruby
-
-# this is arbitrary code that will be executed after Iodine compiles. Used for ad-hok testing.
-
-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"
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-class ShoooProtocol
-  def on_message buffer
-    write "what do you mean - #{buffer.strip} ?!\n"
-    close if buffer =~ /^bye[\r\n]/i
-  end
-
-end
-class EchoProtocol
-  # `on_message` is an optional alternative to the `on_data` callback.
-  # `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 buffer
-    puts buffer.dump
-    # close will be performed only once all the data in the write buffer
-    # was sent. use `force_close` to close early.
-    close if buffer =~ /^bye[\r\n]/i
-    # upgrade ShoooProtocol
-    # # use buffer.dup to save the data from being recycled once we return.
-    # data = buffer.dup
-    # # run asynchronous tasks with ease
-    # run do
-    #   sleep 1
-    #   puts "Echoed data: #{data}"
-    # end
-  end
-end
-
-# create the server object and setup any settings we might need.
-server = Iodine.new
-server.threads = 10
-server.processes = 1
-server.busy_msg = "To many connections, try again later."
-server.protocol = EchoProtocol
-
-b = server.on_start do
-  server.run_after(1000) {puts "A seconds have passed?"}
-  server.run_every(1000) {puts "#{server.connection_count} clients connected."}
-  puts "Since we have 2 timers, we have #{server.connection_count} connections."
-end
-
-server.start

data/bin/raw-rbhttp

@@ -1,38 +0,0 @@
-#!/usr/bin/env ruby
-
-# this will compile Iodine and run a raw sockets server that emulates HTTP (without parsing any incoming requests).
-
-# # test using:
-# ab -n 100000 -c 200 -k http://127.0.0.1:3000/
-
-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'
-
-module HttpProtocol
-	def self.on_open client
-		client.timeout = 10
-	end
-  # `on_message` is an optional alternative to the `on_data` callback.
-  # `on_message` has a 1Kb buffer that recycles itself for memory optimization.
-  def self.on_message client, _
-    # writing will never block and will use a buffer written in C when needed.
-    client.write "HTTP/1.1 200 OK\r\nConnection: keep-alive\r\nKeep-Alive: timeout=1\r\nContent-Length: 12\r\n\r\nHello World!"
-  end
-  def self.call
-  	self
-  end
-end
-
-puts "thread #{Iodine.threads}"
-# Listen
-Iodine.listen port: '3000', handler: HttpProtocol
-Iodine.threads = 4
-Iodine.workers = 1
-puts "now, thread #{Iodine.threads}"
-Iodine.start

data/bin/raw-rbhttp-em

@@ -1,63 +0,0 @@
-#!/usr/bin/env ruby
-
-# this will compile Iodine and run a raw sockets server that emulates HTTP (without parsing any incoming requests).
-
-# # test using:
-# ab -n 100000 -c 200 -k http://127.0.0.1:3000/
-# wrk -c200 -d4 -t12 http://localhost:3000/
-
-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 'eventmachine'
-
-module HttpProtocol
-  def receive_data data
-    send_data "HTTP/1.1 200 OK\r\nConnection: keep-alive\r\nKeep-Alive: timeout=1\r\nContent-Length: 12\r\n\r\nHello World!"
-  end
-end
-
-puts "Running EM emulating HTTP."
-
-if EventMachine.kqueue?
-  EventMachine.kqueue = true
-  puts "using Kqueue."
-end
-if EventMachine.epoll?
-  EventMachine.epoll = true
-  puts "using epoll."
-end
-
-# Note that this will block current thread.
-EventMachine.run {
- EventMachine.start_server "127.0.0.1", 3030, HttpProtocol
-}
-
-#
-# require 'iodine'
-#
-# class HttpProtocol
-#   @timeout = 5
-#   # `on_message` is an optional alternative to the `on_data` callback.
-#   # `on_message` has a 1Kb buffer that recycles itself for memory optimization.
-#   def on_data
-#     # writing will never block and will use a buffer written in C when needed.
-#     data = nil
-#     while (data = read)
-#       write "HTTP/1.1 200 OK\r\nConnection: keep-alive\r\nKeep-Alive: timeout=1\r\nContent-Length: 12\r\n\r\nHello World!"
-#     end
-#   end
-# end
-#
-# puts "thread #{Iodine.threads}"
-# # Listen
-# Iodine.listen '3000', HttpProtocol
-# Iodine.threads = 7
-# Iodine.processes = 1
-# puts "now, thread #{Iodine.threads}"
-# Iodine.start

data/bin/raw_broadcast

@@ -1,64 +0,0 @@
-#!/usr/bin/env ruby
-
-# this will compile Iodine and run a raw sockets broadcasting (chatroom) server.
-
-# # test using:
-# telnet localhost 3000
-
-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'
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-# test the upgrade protocol using the ShoooProtocol
-class ShoooProtocol
-  @timeout = 10
-  def ping
-    write "Wha, ya' still here?! Go away!\n"
-    close
-  end
-
-  def on_message(buffer)
-    write "what do you mean - #{buffer.strip} ?!\nShoo, away with you!\n"
-    close
-  end
-end
-
-# the broadcasting protocol
-class EchoProtocol
-  def self.on_start
-    Iodine.run_every(1000) { puts "#{Iodine.count} clients connected." }
-    puts "We have 1 timer, and #{Iodine.count} connections."
-  end
-
-  def on_open
-    subscribe(channel: :chat) {|ch, msg|  write msg }
-    subscribe channel: :quite
-  end
-
-  # `on_message` is an optional alternative to the `on_data` callback.
-  # `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.
-    publish channel: :chat, message: "Someone said: #{buffer}"
-    switch_protocol ShoooProtocol if buffer =~ /^shoo[\r\n]/i
-    write "You speak!\n" if unsubscribe(subscribed?(channel: :quite))
-  end
-end
-
-# create the server object and setup any settings we might need.
-Iodine.listen 3000, EchoProtocol
-Iodine.threads = 10
-Iodine.processes = 1
-Iodine.start

data/bin/test_with_faye

@@ -1,44 +0,0 @@
-#!/usr/bin/env ruby
-
-Dir.chdir(File.expand_path(File.join('..', '..'), __FILE__))
-puts `rake clean`
-puts `rake compile`
-
-require 'benchmark'
-require 'faye/websocket'
-# require 'thin'
-# Faye::WebSocket.load_adapter('thin')
-
-$LOAD_PATH.unshift File.expand_path(File.join('..', '..', 'lib'), __FILE__)
-require 'bundler/setup'
-require 'iodine'
-
-APP = lambda do |env|
-  if Faye::WebSocket.websocket?(env)
-    ws = Faye::WebSocket.new(env)
-
-    ws.on :message do |event|
-      ws.send(event.data.to_s)
-    end
-
-    ws.on :close do |event|
-      p [:close, event.code, event.reason]
-      ws = nil
-    end
-
-    # Return async Rack response
-    response = ws.rack_response
-    p response
-    response
-  else
-    # Normal HTTP request
-    [200, { 'Content-Type' => 'text/plain' }, ["Hello\n"]]
-  end
-end
-
-Iodine.listen2http app: APP
-
-Iodine.threads = 4
-Iodine.start
-
-# 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");};