iodine 0.7.59 → 0.8.0

data/Rakefile

@@ -1,23 +1,16 @@
-require "bundler/gem_tasks"
-require "rake/extensiontask"
-
-begin
-  require 'rspec/core/rake_task'
-  RSpec::Core::RakeTask.new(:rspec)
-rescue LoadError
-end
+# frozen_string_literal: true
 
-task :spec => [:compile, :rspec]
+require "bundler/gem_tasks"
+task default: %i[]
 
-task :default => [:compile, :spec]
+require "rake/extensiontask"
 
 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
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = "spec/**/*_spec.rb"
+  t.rspec_opts = "--format progress --no-color --backtrace"
+end

data/examples/chatroom.nru

@@ -0,0 +1,9 @@
+# A simple Hello World NeoRack application
+module App
+	def self.on_http(e)
+		e.status = 200
+		e.finish
+	end
+end
+
+run App

data/examples/client

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'iodine'
+
+Iodine::Logger.level = 3 # only log warnings or worse
+
+# A demo client class
+module Client
+
+  # a helper to print response data
+  def self.print_response(h)
+    puts "#{h.version} #{h.status}"
+    h.headers.each {|k,v| puts("#{k}: #{v}\r") if k.is_a? String }
+    puts "\r"
+    while(s = h.gets)
+      puts s
+    end
+  end
+
+  # Called Once per HTTP request. Each HTTP request starts with a new HTTP handle / Event object (`h`).
+  def self.on_http(h)
+    print_response(h)
+  end
+
+  # Called when a long-running connection opens.
+  # 
+  # This will be called for Event Source, WebSocket, TCP/IP and Raw Unix Socket connections.
+  def self.on_open(ws)
+    print_response(ws)
+    puts "Opening #{ws.websocket? ? "WebSocket" : "SSE" } Connection"
+    ws.subscribe(:stdio) if ws.websocket? # SSE connections don't send stuff
+  end
+  # Called when incoming data arrives and its behavior depends on the underlying protocol.
+  def self.on_message(ws, data)
+    puts "Got WebSocket Message: #{data}"
+  end
+
+  # Called a long running connection was closed (WebSocket / SSE / TCP/IP / Raw Unix Socket).
+  def self.on_close(ws)
+    puts "Closed #{ws.websocket? ? "WebSocket" : "SSE" } Connection"
+  end
+  # Called after `on_http`/`on_closed` or if a client failed to connect.
+  def self.on_finish(h)
+    Iodine.stop
+  end
+  # Called when an Event Source (SSE) event has been received (when acting as an Event Source client).
+  def self.on_eventsource(sse, message)
+    puts "id: #{message.id}"
+    puts "event: #{message.event}"
+    puts "data: #{message.data}"
+  end
+end
+
+# I will cheat a little, using Iodine's CLI parser...
+opt = Iodine::Base::CLI.parse(false)
+opt[:bind] ||= opt[0] # allow the first unnamed parameter to be the URL to connect to
+raise "ERROR: this app requires a URL to connect to!" unless opt[:bind]
+
+Iodine.threads = 0
+Iodine.workers = 0
+
+# create the service instance, the block returns a connection handler.
+Iodine::Connection.new(opt[:bind], handler: Client)
+
+# Read STDIO while running
+Thread.new do
+  while true
+    Iodine.publish channel: :stdio, message: STDIN.readline
+  end
+end
+
+# Start the server
+Iodine.start

data/examples/config-hello.nru

@@ -0,0 +1,9 @@
+# A simple Hello World NeoRack application
+module App
+	HELLO_RESPONSE = "Hello World!"
+	def self.on_http(e)
+		e.finish HELLO_RESPONSE
+	end
+end
+
+run App

data/examples/config-hello.ru

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# A simple Hello World Rack application
+module App
+	HELLO_RESPONSE = [200, {"content-length" => 12}, ["Hello World!"]]
+	def self.call(e)
+		HELLO_RESPONSE
+	end
+end
+
+run App

data/examples/config-hijack.ru

@@ -0,0 +1,13 @@
+# A simple Rack application that prints out the `env` variable to the browser.
+module EchoApp
+	def self.call(e)
+		io = e['rack.hijack'].call
+		txt = ["Hijacked!\r\n"]
+		e.each {|k,v| txt << "#{k}: #{v}\r\n" }
+		txt = txt.join()
+		Thread.new {sleep(0.5); io.write("HTTP/1.1 200 OK\r\nContent-Length: #{txt.bytesize}\r\n\r\n#{txt}"); io.close; puts("Sent"); }
+		[200, {}, []]
+	end
+end
+
+run EchoApp

data/examples/config-shootout.ru

@@ -0,0 +1,43 @@
+# # Written for NeoRack with Iodine v.0.8.x
+# #
+# # Run using:
+# iodine -t <number of threads> -w <number of processes> -p <port>
+# # i.e.:
+# iodine -t 8 -w 0 -p 3334
+
+# Local process-cluster support is built into iodine's pub/sub, but cross-machine pub/sub requires a RESP3 database (such as Valkey or Redis).
+class ShootoutApp
+  SHOOTOUT = "shootout".freeze
+  def on_http(e)
+    e.finish "This application should be used with the websocket-shootout benchmark utility."
+  end
+  
+  def on_open(e)
+    e.subscribe channel: SHOOTOUT
+  end
+
+  def on_message e, data
+
+    if data[0] == 'b' # binary
+      e.publish(channel: SHOOTOUT, message: data)
+      data[0] = 'r'
+      e.write data
+      return
+    end
+
+    # cmd, payload = JSON(data).values_at('type', 'payload')
+    cmd, payload = Iodine::JSON.parse(data).values_at('type', 'payload')
+    if cmd == 'echo'
+      e.write({type: 'echo', payload: payload}.to_json)
+    else
+      e.publish(channel: SHOOTOUT, message: {type: 'broadcast', payload: payload})
+      e.write({type: "broadcastResult", payload: payload})
+    end
+
+  rescue
+    puts "Incoming message format error!"
+  end
+
+end
+
+run ShootoutApp.new

data/examples/config.nru

@@ -0,0 +1,120 @@
+# This is a NeoRack Application with a Rack fallback for non-NeoRack servers (such as Puma).
+#
+# Iodine can run both Rack (old school) and NeoRack applications.
+# 
+# In this case the `on_http` implementation will be called by iodine (and the `call` implementation will be called by any other server).
+# 
+module EchoApp
+  # A selector for the on_http example to implement.
+  STREAM_RESPONSES = false
+
+  # for non-NeoRack servers, such as Puma
+  def self.call(e)
+    txt = []
+    if e['rack.upgrade?']
+      e['rack.upgrade'] = self
+    else
+      e.each {|k,v| txt << "#{k}: #{v}\r\n" }
+    end
+    [200, {}, txt]
+  end
+
+  # Choose requested response callback – a streaming response vs. `content-length`.
+  if(STREAM_RESPONSES)
+
+    # This approach streams the data, adding some HTTP overhead, as may be performed by longer handlers.
+    def self.on_http(e)
+      # we write without finishing and without setting the content-length header...
+      # servers should automatically stream the response (i.e., using chunked encoding)
+      e.write "path:    #{e.path}\r\n"
+      e.write "opath:   #{e.opath}  -- (original)\r\n"
+      e.write "query:   #{e.query}\r\n"
+      e.write "method:  #{e.method}\r\n"
+      e.write "version: #{e.version}\r\n"
+      e.write "from:    #{e.from} (real: #{e.peer_addr})\r\n"
+      e.headers.each {|k,v| e.write "#{k}: #{v}\r\n" }
+      # echo request body to the response
+      while(l = e.gets)
+        e.write l
+      end
+      e.finish
+    end
+
+  else # STREAM_RESPONSES?
+
+    # This is similar to Rack, compiling the whole response before sending it
+    # this should optimally result in `content-length` being set by the server
+    def self.on_http(e)
+      # First, prepare the output data
+      out =  "path:    #{e.path}\r\n" + 
+             "opath:   #{e.opath}  -- (original)\r\n" +
+             "query:   #{e.query}\r\n" +
+             "method:  #{e.method}\r\n" +
+             "version: #{e.version}\r\n" +
+             "from:    #{e.from} (#{e.peer_addr})\r\n"
+      e.headers.each {|k,v| out += "#{k}: #{v}\r\n" }
+      # append the incoming body
+      while(l = e.gets)
+        out += l
+      end
+      # finish and write the data to the client.
+      # efficient servers will see this is the first and only `write` and set `content-length`
+      e.finish out 
+    end
+
+  end
+
+  # Called when a WebSocket / SSE connection is opened.
+  def self.on_open(e)
+    e.subscribe(:broadcast) # { |msg| puts "(#{Process.pid}:#{Thread.current}): #{msg.channel} : #{msg.message}"; e.write msg.message }
+  end
+
+  # Called when a WebSocket message is received...
+  #
+  # ... however, Iodine also allows SSE clients to "cheat" and push messages to this callback.
+  def self.on_message(e, m)
+    Iodine.publish(:broadcast, m)
+  end
+end
+
+module ResourceApp  
+  def self.index(e);  e.finish("Show Index"); end
+  def self.show(e);   e.finish("Show Item: #{e.path[1..-1]}"); end
+  def self.delete(e); e.finish("Delete Item: #{e.path[1..-1]}"); end
+  def self.new(e);    e.finish("New Item Form."); end
+  def self.edit(e);   e.finish("Edit Item: #{e.path.split(?/)[1]}"); end
+  def self.create(e); e.finish("Create a new Item."); end
+  def self.update(e); e.finish("Update Item: #{e.path[1..-1]}"); end
+end
+neorack_resource ResourceApp
+
+if defined?(Iodine)
+  map("hello") { map("echo", EchoApp); run {|e| [200, {}, "Hello World"] } }
+  map("rack") { run {|e| EchoApp.call(e) } }
+  map('/crud', ResourceApp)
+end
+run EchoApp
+
+# Benchmark with keep-alive:
+# 
+#     ab -c 200 -t 4 -n 1000000 -k http://127.0.0.1:3000/
+#     wrk -c200 -d4 -t2 http://localhost:3000/
+# 
+# Connect to chat server with WebSockets:
+# 
+#     ws = new WebSocket("ws://" + document.location.host + document.location.pathname);
+#     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");};
+# 
+# Listen to chat messages with Server Sent Events (EventSource / SSE):
+# 
+#     const listener = new EventSource(document.location.href);
+#     listener.onmessage = (e) => { console.log(e); }
+#     listener.addEventListener("time", (e) => { console.log(e); })
+#     listener.addEventListener("event", (e) => { console.log(e); })
+#
+# To run any code / configuration on the root (master) process, call Iodine with `-C`:
+#
+#     iodine -C config.rb
+#

data/examples/config.rb

@@ -0,0 +1,37 @@
+# This is an example configuration file
+#
+# The configuration file will run code before loading the application.
+#
+# When hot swapping, the configuration file code will remain in memory (will be forked), but the application code will reload.
+
+module MyConfig
+	def self.timer
+		# a false return value will cancel the timer.
+		return false unless Iodine.master?
+		puts("Heart Beat")
+	end
+end
+
+Iodine.run_after(2000, -1, MyConfig.method(:timer))
+
+# Pub/Sub engines are a classical use-case for a configuration file.
+#
+class LogPubSub < Iodine::PubSub::Engine
+	def subscribe ch
+		puts "(#{Process.pid}) #{ch} has listeners (created)"
+	end
+	def psubscribe ch
+		puts "(#{Process.pid}) (pattern) #{ch} has listeners (created)"
+	end
+	def unsubscribe ch
+		puts "(#{Process.pid}) #{ch} has no more listeners (destroyed)"
+	end
+	def punsubscribe ch
+		puts "(#{Process.pid}) (pattern) #{ch} has no more listeners (destroyed)"
+	end
+	def publish m
+		puts "(#{Process.pid}) Someone published to #{m.channel}"
+		Iodine.publish channel: m.channel, message: m.message, filter: m.filter, engine: Iodine::PubSub::CLUSTER
+	end
+end
+Iodine::PubSub.default = LogPubSub.new

data/examples/config.ru

@@ -1,59 +1,48 @@
-# This is a WebSocket / SSE notification broadcasting application.
+# A simple Rack application that prints out the `env` variable to the browser.
 #
-# 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/
-#
-# 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' => '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
+# This example also supports the (deprecated) old-style iodine Rack upgrade.
+module App
+  def self.call(env)
+    txt = []
+    # support old-style iodine Rack upgrade for pure Rack applications.
+    if env['rack.upgrade?']
+      env['rack.upgrade'] = self
+    else
+      env.each {|k,v| txt << "#{k}: #{v}\r\n" }
+    end
+    [200, {}, txt]
   end
-  # send a message, letting the client know the server is suggunt down.
-  def on_shutdown client
-    client.write "Server shutting down. Goodbye."
+  def self.on_open(e)
+    e.subscribe :broadcast
   end
-  # perform the echo
-  def on_message client, data
-    client.publish :broadcast, data
+  def self.on_message(e, m)
+    Iodine.publish :broadcast, m
   end
-  extend self
 end
 
-# this function call links our HelloWorld application with Rack
-run MyHTTPRouter
+map("/hello") { map("/echo") { run App }; run {|e| [200, {}, ["Hello World"]] } }
+run App
+
+# Benchmark with keep-alive:
+# 
+#     ab -c 200 -t 4 -n 1000000 -k http://127.0.0.1:3000/
+#     wrk -c200 -d4 -t2 http://localhost:3000/
+# 
+# Connect to chat server with WebSockets:
+# 
+#     ws = new WebSocket("ws://" + document.location.host + document.location.pathname);
+#     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");};
+# 
+# Listen to chat messages with Server Sent Events (EventSource / SSE):
+# 
+#     const listener = new EventSource(document.location.href);
+#     listener.onmessage = (e) => { console.log(e); }
+#     listener.addEventListener("time", (e) => { console.log(e); })
+#     listener.addEventListener("event", (e) => { console.log(e); })
+#
+# To run any code / configuration on the root (master) process, call Iodine with `-C`:
+#
+#     iodine -C config.rb
+#

data/examples/fake

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+require 'iodine'
+
+# Iodine::Logger.level = 5
+# Iodine.threads = 0
+# Iodine.workers = 0
+
+
+# Define the protocol for our service
+module FakeHTTP
+  def on_message(client, data)
+    client.write "HTTP/1.1 200 OK\r\ndate: Mon, 22 Jul 2024 14:06:56 GMT\r\ncontent-length:#{data.bytesize}\r\n\r\n#{data}"
+  end
+  # We can use a singleton pattern,
+  # as the Protocol object doesn't contain any per-connection data.
+  extend self
+end
+
+# create the service instance, the block returns a connection handler.
+Iodine.listen(handler: FakeHTTP, service: :tcp)
+
+# Start the server
+Iodine.start

data/examples/hello_neorack

@@ -0,0 +1,137 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+
+# Benchmark with keep-alive:
+# 
+#     ab -c 200 -t 4 -n 1000000 -k http://127.0.0.1:3000/
+#     wrk -c200 -d4 -t2 http://localhost:3000/
+# 
+# Connect to chat server with WebSockets:
+# 
+#     ws = new WebSocket("ws://" + document.location.host + document.location.pathname);
+#     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");};
+# 
+# Listen to chat messages with Server Sent Events (EventSource / SSE):
+# 
+#     const listener = new EventSource(document.location.href);
+#     listener.onmessage = (e) => { console.log(e); }
+#     listener.addEventListener("time", (e) => { console.log(e); })
+#     listener.addEventListener("event", (e) => { console.log(e); })
+
+require 'iodine'
+
+Server.threads = 1
+Server.workers = 0
+
+# Define the protocol for our service
+# 
+# We can use a singleton pattern, as the Protocol object doesn't contain any per-connection data.
+# 
+# See the [NeoRack](https://github.com/boazsegev/neorack) specification for details.
+module MyNeoRackApp
+  # Called Once per HTTP request. Each HTTP request starts with a new HTTP handle / Event object (`h`).
+  def self.on_http(h)
+    h[:start] = Time.now
+    # This would be faster if we sent the whole response as a single String.
+    #
+    # However, this example demonstrates a Streaming response, so we will call `h.write` multiple times.
+    h.status = 200
+    h.write("Hello NeoRack World!\r\n#{h.method} #{h.path} #{h.version}\r\n")
+    h.headers.each {|k,v| h.write("#{k}: #{v}\r\n") if k.is_a? String }
+    h.finish
+  end
+
+  # Called after `on_http` / `on_closed` or if as a client Iodine failed to connect.
+  def self.on_finish(h); puts "#{h.method} #{h.path} - #{Time.now - h[:start]}s" end
+
+  # This is ignored by NeoRack.
+  # 
+  # It's called when receiving HTTP requests using a Rack server (or if on_http is removed).
+  #
+  # [Rack](https://github.com/rack/rack) is the classical server interface and it is supported by Iodine with minimal extensions.
+  def self.call(env);
+    env[:start] = Time.now
+    txt = []
+    txt << "Hello Rack World!\r\n#{env['REQUEST_METHOD']} #{env['PATH_INFO']} #{env['HTTP_VERSION']}\r\n"
+    env.each {|k,v| txt << "#{k}: #{v}\r\n" if k.is_a? String }
+    [200, {}, txt]
+  end
+
+  # When `on_authenticate is present, a missing `on_authenticate_sse` or missing `on_authenticate_websocket`
+  # will route to this callback, allowing authentication logic to be merged in one method.
+  # 
+  # **Must** return `true` for the connection to be allowed.
+  # 
+  # **Any other return value will cause the connection to be refused** (and disconnected).
+  #
+  # By default, if `on_message` or `on_open` are defined, than `on_authenticate` returns `true`. Otherwise, `on_authenticate` returns `false`.
+  def self.on_authenticate(h)
+    h[:start] = Time.now
+    puts "Authenticating client #{h.object_id}"
+    true
+  end
+  # def self.on_authenticate_sse(h); end
+  # def self.on_authenticate_websocket(h); end
+
+  # Called when a long-running connection opens.
+  # 
+  # This will be called for Event Source, WebSocket, TCP/IP and Raw Unix Socket connections.
+  def self.on_open(ws)
+    ws.subscribe(:time) if Server.extensions[:pubsub]
+  end
+  # Called when incoming data arrives and its behavior depends on the underlying protocol.
+  # 
+  # For TCP/IP and Raw Unix connections, the data is a Binary encoded String with some (or all) of the data available in the incoming socket buffer.
+  #
+  # For WebSockets, the `data` element will contain a String with the WebSocket Message.
+  # 
+  # If the WebSocket message is in text, the String encoding will be UTF-8.
+  # 
+  # If the WebSocket message is binary, the String encoding will be Binary (ASCII).
+  def self.on_message(ws, data)
+    puts "Got WebSocket Message: #{data}"
+    ws.write("Echo: #{data}")
+  end
+  # Called when all calls to {Iodine::Connection#write} have been handled and the outgoing buffer is now empty.
+  def self.on_drained(ws)
+    puts "Finished sending data to #{ws.object_id}"
+  end
+  # Called when timeout has been reached for a TCP/IP / Raw Unix Socket connection.
+  def self.on_timeout(tcp)
+    puts "Timeout detected for #{tcp.object_id}"
+  end
+  # Called when the worker that manages this connection (or the root process, in non-cluster mode) starts shutting down.
+  def self.on_shutdown(ws)
+    ws.write "Server shutting down. Goodbye."
+  end
+  # Called a long running connection was closed (WebSocket / SSE / TCP/IP / Raw Unix Socket).
+  def self.on_close(ws)
+    puts "Closed #{ws.object_id}"
+  end
+  # Called when an Event Source (SSE) event has been received (when acting as an Event Source client).
+  def self.on_eventsource(sse, message)
+    puts "Normally only an SSE client would receive sse messages...\r\n#{message}"
+  end
+  # Called an Event Source (SSE) client send a re-connection request with the ID of the last message received.
+  def self.on_eventsource_reconnect(sse, last_message_id)
+    puts "Reconnecting SSE client #{sse.object_id}, should send everything after message ID #{last_message_id}"
+  end
+end
+
+# create the service instance, the block returns a connection handler.
+Server.listen(handler: MyNeoRackApp)
+
+# create the time pub/sub service
+if Server.extensions[:pubsub]
+  Iodine.run_after(1000, -1) do
+    Server.publish(channel: :time, message: Iodine::Utils.time2str(Time.now))
+  end
+end
+
+
+
+# Start the server
+Server.start

data/examples/routes.nru

@@ -0,0 +1,29 @@
+# This is a multi-route example using NeoRack vs Rack `map`
+
+class RouteApp
+	def initialize(name)
+		@response = [200, {}, "Hello #{name}"] 
+	end
+	def call(e)
+		@response
+	end
+end
+
+ROUTE_COUNT = 100
+BSET_CASE_FOR_TRI = true
+
+if BSET_CASE_FOR_TRI # best case
+	ROUTE_COUNT.times {|i| url = "/try_this_route-#{i}" ; map(url) { run RouteApp.new(url) } }
+	puts "\t test with:"
+	puts "\t wrk -c200 -d4 -t2 http://localhost:3000/try_this_route-0"
+	puts "\t wrk -c200 -d4 -t2 http://localhost:3000/try_this_route-#{ROUTE_COUNT / 2}"
+	puts "\t wrk -c200 -d4 -t2 http://localhost:3000/try_this_route-#{ROUTE_COUNT - 1}"
+else
+	ROUTE_COUNT.times {|i| url = "/#{i}-try_this_route" ; map(url) { run RouteApp.new(url) } }
+	puts "\t test with:"
+	puts "\t wrk -c200 -d4 -t2 http://localhost:3000/0-try_this_route"
+	puts "\t wrk -c200 -d4 -t2 http://localhost:3000/#{ROUTE_COUNT / 2}-try_this_route"
+	puts "\t wrk -c200 -d4 -t2 http://localhost:3000/#{ROUTE_COUNT - 1}-try_this_route"
+end
+
+run {[404, {}, nil]}