iodine 0.1.21 → 0.2.0

data/Rakefile

@@ -1,5 +1,6 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
+require "rake/extensiontask"
 
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
@@ -7,4 +8,15 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList['test/**/*_test.rb']
 end
 
-task :default => :test
+task :default => [:compile, :test]
+
+Rake::ExtensionTask.new "iodine" do |ext|
+  ext.lib_dir = "lib/iodine"
+end
+
+# Rake::ExtensionTask.new "iodine_http" do |ext|
+#   ext.name = 'iodine_http'
+#   ext.lib_dir = "lib/iodine"
+#   ext.ext_dir = 'ext/iodine'
+#   ext.config_script = 'extconf-http.rb'
+# end

data/bin/config.ru

@@ -0,0 +1,63 @@
+require 'benchmark'
+require 'rack/sendfile'
+require 'rack/lint'
+
+# There are a number of possible applications to run in this file,
+# because I use it to test stuff.
+#
+# This value (app) sets which of the different applications will run.
+#
+# Valid values are "hello", "slow" (debugs env values), "simple"
+app = 'hello'
+# This is a simple Hello World Rack application, for benchmarking.
+hello = proc do |_env|
+  [200, { 'Content-Type'.freeze => 'text/html'.freeze,
+          'Content-Length'.freeze => '16'.freeze },
+   ['Hello from Rack!'.freeze]]
+end
+
+slow = proc do |env|
+  out = "ENV:\n<br/>\n#{env.to_a.map { |h| "#{h[0]}: #{h[1]}" } .join "\n<br/>\n"}\n<br/>\n"
+  request = Rack::Request.new(env)
+  # Benchmark.bm do |bm|
+  #   bm.report('Reading from env Hash to a string X 1000') { 1000.times { out = "ENV:\r\n#{env.to_a.map { |h| "#{h[0]}: #{h[1]}" } .join "\n"}\n" } }
+  #   bm.report('Creating the Rack::Request (can\'t repeat)') { 1.times { request = Rack::Request.new(env) } }
+  # end
+  if request.path_info == '/source'.freeze
+    [200, { 'X-Sendfile' => File.expand_path(__FILE__) }, []]
+  else
+    out += "\n<br/>\nRequest Path: #{request.path_info}\n<br/>\nParams:\n<br/>\n#{request.params.to_a.map { |h| "#{h[0]}: #{h[1]}" } .join "\n<br/>\n"}\n<br/>\n" unless request.params.empty?
+    [200, { 'Content-Type'.freeze => 'text/html'.freeze,
+            'Content-Length'.freeze => out.length.to_s },
+     [out]]
+ end
+end
+
+simple = proc do |env|
+  request = Rack::Request.new(env)
+  if request.path_info == '/source'.freeze
+    [200, { 'X-Sendfile' => File.expand_path(__FILE__) }, []]
+  elsif request.path_info == '/file'.freeze
+    [200, { 'X-Header' => 'This was a Rack::Sendfile response' }, File.open(__FILE__)]
+  else
+    [200, { 'Content-Type'.freeze => 'text/html'.freeze,
+            'Content-Length'.freeze => request.path_info.length.to_s },
+     [request.path_info]]
+ end
+end
+
+case app
+when 'simple'
+  use Rack::Sendfile
+  run simple
+when 'hello'
+  run hello
+when 'slow'
+  use Rack::Lint
+  run slow
+else
+  run hello
+end
+
+# ab -n 1000000 -c 2000 -k http://127.0.0.1:3000/
+# wrk -c400 -d5 -t12 http://localhost:3000/

data/bin/console

@@ -1,5 +1,11 @@
 #!/usr/bin/env ruby
 
+# this will compile Iodine and start a Ruby console with the Iodine gem loaded.
+
+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"

data/bin/echo

@@ -1,36 +1,46 @@
 #!/usr/bin/env ruby
 
-require 'pathname'
-Root ||= Pathname.new(File.dirname(__FILE__)).expand_path
-Dir.chdir Root.join('..').to_s
-
-require "bundler/setup"
-require "iodine"
-require 'stringio'
-
-# ab -n 10000 -c 200 -k http://127.0.0.1:3000/ctrl
-# ~/ruby/wrk/wrk -c400 -d10 -t12 http://localhost:3000/ctrl
-
-
-
-class EchoServer < Iodine::Protocol
-	def on_message data
-		write("-- Closing connection, goodbye.\n") && close if data =~ /^(bye|close|exit|stop)/i
-		write(">> #{data.chomp}\n")
-	end
-
-	def ping
-		write "-- Are you still there?\n"
-	end
-
-	def on_close
-		Iodine.info "Closed connection."
-	end
-	def on_open
-		Iodine.info "Opened connection."
-		set_timeout 5
-	end
+# this will compile Iodine and run an echo 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'
+
+class EchoProtocol
+  @timeout = 10
+
+  def self.on_start
+    puts '* Echo service is now running.'
+  end
+
+  def on_open
+    puts 'New connection'
+  end
+
+  def ping
+    write "-- are you there?\n"
+  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.
+    write "Echo: #{buffer}"
+    puts buffer.dump
+    close if buffer =~ /^bye[\r\n]/i
+  end
 end
 
-
-Iodine.protocol = EchoServer
+# create the server object and setup any settings we might need.
+Iodine.listen 3000, EchoProtocol
+# server.threads = 10
+# server.processes = 1
+Iodine.start

data/bin/http-hello

@@ -0,0 +1,62 @@
+#!/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 ||= 16
+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

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

@@ -0,0 +1,62 @@
+#!/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/poc/Gemfile.lock

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