tipi 0.32 → 0.37

data/df/routing_benchmark.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+require 'tipi/digital_fabric'
+
+class FakeAgent
+  def initialize(idx)
+    @idx = idx
+  end
+end
+
+def setup_df_service_with_agents(agent_count)
+  server = DigitalFabric::Service.new
+  agent_count.times do |i|
+    server.mount({path: "/#{i}"}, FakeAgent.new(i))
+  end
+  server
+end
+
+def benchmark_route_compilation(agent_count, iterations)
+  service = setup_df_service_with_agents(agent_count)
+  t0 = Time.now
+  iterations.times { service.compile_agent_routes }
+  elapsed = Time.now - t0
+  puts "route_compilation: #{agent_count} => #{elapsed / iterations}s (#{1/(elapsed / iterations)} ops/sec)"
+end
+
+class FauxRequest
+  def initialize(agent_count)
+    @agent_count = agent_count
+  end
+
+  def headers
+    { ':path' => "/#{rand(@agent_count)}"}
+  end
+end
+
+def benchmark_find_agent(agent_count, iterations)
+  service = setup_df_service_with_agents(agent_count)
+  t0 = Time.now
+  request = FauxRequest.new(agent_count)
+  iterations.times do
+    agent = service.find_agent(request)
+  end
+  elapsed = Time.now - t0
+  puts "routing: #{agent_count} => #{elapsed / iterations}s (#{1/(elapsed / iterations)} ops/sec)"
+end
+
+def benchmark
+  benchmark_route_compilation(100, 1000)
+  benchmark_route_compilation(500,  200)
+  benchmark_route_compilation(1000, 100)
+
+  benchmark_find_agent(100, 1000)
+  benchmark_find_agent(500,  200)
+  benchmark_find_agent(1000, 100)
+end
+
+benchmark

data/df/sample_agent.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+require 'json'
+require 'tipi/digital_fabric/protocol'
+require 'tipi/digital_fabric/agent'
+
+Protocol = DigitalFabric::Protocol
+
+class SampleAgent < DigitalFabric::Agent
+  HTML_WS = IO.read(File.join(__dir__, 'ws_page.html'))
+  HTML_SSE = IO.read(File.join(__dir__, 'sse_page.html'))
+
+  def http_request(req)
+    path = req['headers'][':path']
+    case path
+    when '/agent'
+      send_df_message(Protocol.http_response(
+        req['id'],
+        'Hello, world!',
+        {},
+        true
+      ))
+    when '/agent/ws'
+      send_df_message(Protocol.http_response(
+        req['id'],
+        HTML_WS,
+        { 'Content-Type' => 'text/html' },
+        true
+      ))
+    when '/agent/sse'
+      send_df_message(Protocol.http_response(
+        req['id'],
+        HTML_SSE,
+        { 'Content-Type' => 'text/html' },
+        true
+      ))
+    when '/agent/sse/events'
+      stream_sse_response(req)
+    else
+      send_df_message(Protocol.http_response(
+        req['id'],
+        nil,
+        { ':status' => 400 },
+        true
+      ))
+    end
+  
+  end
+
+  def ws_request(req)
+    send_df_message(Protocol.ws_response(req['id'], {}))
+
+    10.times do
+      sleep 1
+      send_df_message(Protocol.ws_data(req['id'], Time.now.to_s))
+    end
+    send_df_message(Protocol.ws_close(req['id']))
+  end
+
+  def stream_sse_response(req)
+    send_df_message(Protocol.http_response(
+      req['id'],
+      nil,
+      { 'Content-Type' => 'text/event-stream' },
+      false
+    ))
+    10.times do
+      sleep 1
+      send_df_message(Protocol.http_response(
+        req['id'],
+        "data: #{Time.now}\n\n",
+        nil,
+        false
+      ))
+    end
+    send_df_message(Protocol.http_response(
+      req['id'],
+      "retry: 0\n\n",
+      nil,
+      true
+    ))
+  end
+  
+end
+
+agent = SampleAgent.new('127.0.0.1', 4411, { path: '/agent' })
+agent.run

data/df/server.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'tipi'
+require 'tipi/digital_fabric'
+require 'tipi/digital_fabric/executive'
+require 'json'
+require 'fileutils'
+FileUtils.cd(__dir__)
+
+service = DigitalFabric::Service.new(token: 'foobar')
+executive = DigitalFabric::Executive.new(service, { host: 'executive.realiteq.net' })
+
+spin_loop(interval: 60) { GC.start }
+
+class Polyphony::BaseException
+  attr_reader :caller_backtrace
+end
+
+puts "pid: #{Process.pid}"
+
+tcp_listener = spin do
+  opts = {
+    reuse_addr:  true,
+    dont_linger: true,
+  }
+  puts 'Listening on localhost:4411'
+  server = Polyphony::Net.tcp_listen('0.0.0.0', 4411, opts)
+  server.accept_loop do |client|
+    spin do
+      service.incr_connection_count
+      Tipi.client_loop(client, opts) { |req| service.http_request(req) }
+    ensure
+      service.decr_connection_count
+    end
+  end
+end
+
+UNIX_SOCKET_PATH = '/tmp/df.sock'
+
+unix_listener = spin do
+  puts "Listening on #{UNIX_SOCKET_PATH}"
+  FileUtils.rm(UNIX_SOCKET_PATH) if File.exists?(UNIX_SOCKET_PATH)
+  socket = UNIXServer.new(UNIX_SOCKET_PATH)
+  Tipi.accept_loop(socket, {}) { |req| service.http_request(req) }
+end
+
+begin
+  Fiber.await(tcp_listener, unix_listener)
+rescue Interrupt
+  puts "Got SIGINT, shutting down gracefully"
+  service.graceful_shutdown
+  puts "post graceful shutdown"
+end

data/df/sse_page.html

@@ -0,0 +1,29 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <title>SSE Client</title>
+</head>
+<body>
+  <h1>SSE Client</h1>
+  <script>
+    var connect = function () {
+      console.log("connecting...");
+      var eventSource = new EventSource("/agent/sse/events");
+
+      eventSource.addEventListener('open', function(e) {
+        console.log("connected");
+        document.querySelector('#status').innerText = 'connected';
+        return false;
+      }, false);
+
+      eventSource.addEventListener('message', function(e) {
+        document.querySelector('#msg').innerText = e.data;
+      }, false);
+    };
+
+    window.onload = connect;
+  </script>
+  <h1 id="status">disconnected</h1>
+  <h1 id="msg"></h1>
+</body>
+</html>

data/df/stress.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+require 'fileutils'
+
+FileUtils.cd(__dir__)
+
+def monitor_process(cmd)
+  while true
+    puts "Starting #{cmd}"
+    Polyphony::Process.watch(cmd)
+    sleep 5
+  end
+end
+
+puts "pid: #{Process.pid}"
+puts 'Starting stress test'
+
+spin { monitor_process('ruby server.rb') }
+spin { monitor_process('ruby multi_agent_supervisor.rb') }
+spin { monitor_process('ruby multi_client.rb') }
+
+sleep

data/df/ws_page.html

@@ -0,0 +1,38 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <title>Websocket Client</title>
+</head>
+<body>
+  <h1>WebSocket Client</h1>
+  <script>
+    var connect = function () {
+      console.log("connecting...")
+      var exampleSocket = new WebSocket("wss://dev.realiteq.net/agent");
+
+      exampleSocket.onopen = function (event) {
+        console.log("connected");
+        document.querySelector('#status').innerText = 'connected';
+        exampleSocket.send("Can you hear me?");
+      };
+      exampleSocket.onclose = function (event) {
+        console.log("disconnected");
+        document.querySelector('#status').innerText = 'disconnected';
+        setTimeout(function () {
+          // exampleSocket.removeAllListeners();
+          connect();
+        }, 1000);
+      }
+      exampleSocket.onmessage = function (event) {
+        console.log("got message", event.data);
+        document.querySelector('#msg').innerText = event.data;
+        console.log(event.data);
+      }
+    };
+
+    window.onload = connect;
+  </script>
+  <h1 id="status">disconnected</h1>
+  <h1 id="msg"></h1>
+</body>
+</html>

data/examples/http_request_ws_server.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'tipi'
+require 'tipi/websocket'
+
+def ws_handler(conn)
+  timer = spin_loop(interval: 1) do
+    conn << Time.now.to_s
+  end
+  while (msg = conn.recv)
+    conn << "you said: #{msg}"
+  end
+ensure
+  timer.stop
+end
+
+opts = {
+  reuse_addr:  true,
+  dont_linger: true,
+}
+
+HTML = IO.read(File.join(__dir__, 'ws_page.html'))
+
+puts "pid: #{Process.pid}"
+puts 'Listening on port 4411...'
+
+Tipi.serve('0.0.0.0', 4411, opts) do |req|
+  if req.upgrade_protocol == 'websocket'
+    conn = req.upgrade_to_websocket
+    ws_handler(conn)
+  else
+    req.respond(HTML, 'Content-Type' => 'text/html')
+  end
+end

data/examples/http_server.rb

@@ -8,14 +8,14 @@ opts = {
   dont_linger: true
 }
 
+puts "pid: #{Process.pid}"
+puts 'Listening on port 4411...'
+
 spin do
-  Tipi.serve('0.0.0.0', 1234, opts) do |req|
+  Tipi.serve('0.0.0.0', 4411, opts) do |req|
     req.respond("Hello world!\n")
   rescue Exception => e
     p e
   end
-end
-
-puts "pid: #{Process.pid}"
-puts 'Listening on port 1234...'
-suspend
+  p 'done...'
+end.await

data/examples/http_server_forked.rb

@@ -7,18 +7,15 @@ require 'tipi'
 
 opts = {
   reuse_addr:  true,
+  reuse_port: true,
   dont_linger: true
 }
 
-server = Polyphony::HTTP::Server.listen('0.0.0.0', 1234, opts)
-
-puts 'Listening on port 1234'
-
 child_pids = []
 8.times do
   pid = Polyphony.fork do
     puts "forked pid: #{Process.pid}"
-    server.each do |req|
+    Tipi.serve('0.0.0.0', 1234, opts) do |req|
       req.respond("Hello world! from pid: #{Process.pid}\n")
     end
   rescue Interrupt
@@ -26,4 +23,6 @@ child_pids = []
   child_pids << pid
 end
 
+puts 'Listening on port 1234'
+
 child_pids.each { |pid| Thread.current.backend.waitpid(pid) }

data/examples/http_server_form.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'tipi'
+
+opts = {
+  reuse_addr:  true,
+  dont_linger: true
+}
+
+puts "pid: #{Process.pid}"
+puts 'Listening on port 4411...'
+
+spin do
+  Tipi.serve('0.0.0.0', 4411, opts) do |req|
+    body = req.read
+    body2 = req.read
+    req.respond("body: #{body} (body2: #{body2.inspect})\n")
+  rescue Exception => e
+    p e
+  end
+  p 'done...'
+end.await

data/examples/http_server_throttled_accept.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'tipi'
+
+::Exception.__disable_sanitized_backtrace__ = true
+
+opts = {
+  reuse_addr:     true,
+  reuse_port:     true,
+  dont_linger:    true
+}
+
+server = Tipi.listen('0.0.0.0', 1234, opts)
+
+puts 'Listening on port 1234'
+
+throttler = Polyphony::Throttler.new(interval: 5)
+server.accept_loop do |socket|
+  throttler.call do
+    spin { Tipi.client_loop(socket, opts) { |req| req.respond("Hello world!\n") } }
+  end
+end

data/examples/http_unix_socket_server.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'tipi'
+
+path = '/tmp/tipi.sock'
+
+puts "pid: #{Process.pid}"
+puts "Listening on #{path}"
+
+FileUtils.rm(path) rescue nil
+socket = UNIXServer.new(path)
+Tipi.accept_loop(socket, {}) do |req|
+  req.respond("Hello world!\n")
+rescue Exception => e
+  p e
+end