polyphony 0.13 → 0.14

data/examples/interfaces/redis_client.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'modulation'
+
+Polyphony = import('../../lib/polyphony')
+import('../../lib/polyphony/extensions/redis')
+
+redis = Redis.new
+
+X = 10000
+
+t0 = Time.now
+X.times { redis.get('abc') }
+puts "get rate: #{X / (Time.now - t0)} reqs/s"
+
+puts "abc = #{redis.get('abc')}"
+
+puts "updating value..."
+redis.set('abc', Time.now.to_s)
+
+puts "abc = #{redis.get('abc')}"

data/examples/interfaces/redis_pubsub.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'modulation'
+
+Polyphony = import('../../lib/polyphony')
+import('../../lib/polyphony/extensions/redis')
+
+spawn do
+  redis = Redis.new
+  redis.subscribe('redis-channel') do |on|
+    on.message do |channel, message|
+      puts "##{channel}: #{message}"
+      redis.unsubscribe if message == "exit"
+    end
+  end
+end
+
+spawn do
+  redis = Redis.new
+  move_on_after(3) do
+    throttled_loop(1) do
+      redis.publish('redis-channel', Time.now)
+    end
+  end
+  redis.publish('redis-channel', 'exit')
+end

data/examples/interfaces/redis_pubsub_perf.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'modulation'
+require 'json'
+
+Polyphony = import('../../lib/polyphony')
+import('../../lib/polyphony/extensions/redis')
+
+X_SESSIONS = 1000
+X_NODES = 10000
+X_SUBSCRIPTIONS_PER_SESSION = 100
+
+$sessions = []
+X_SESSIONS.times do
+  $sessions << {
+    subscriptions: X_SUBSCRIPTIONS_PER_SESSION.times.map {
+      "node#{rand(X_NODES)}"
+    }.uniq
+  }
+end
+
+spawn do
+  redis = Redis.new
+  redis.subscribe('events') do |on|
+    on.message do |_, message|
+      distribute_event(JSON.parse(message, symbolize_names: true))
+    end
+  end
+end
+
+$update_count = 0
+
+def distribute_event(event)
+  $update_count += 1
+  t0 = Time.now
+  count = 0
+  $sessions.each do |s|
+    count += 1 if s[:subscriptions].include?(event[:path])
+  end
+  elapsed = Time.now - t0
+  rate = X_SESSIONS / elapsed
+  # puts "elapsed: #{elapsed} (#{rate}/s)" if $update_count % 100 == 0
+end
+
+spawn do
+  redis = Redis.new
+  throttled_loop(1000) do
+    redis.publish('events', {path: "node#{rand(X_NODES)}"}.to_json)
+  end
+end
+
+spawn do
+  last_count = 0
+  last_stamp = Time.now
+  throttled_loop(1) do
+    now = Time.now
+    elapsed = now - last_stamp
+    delta = $update_count - last_count
+    puts "update rate: #{delta.to_f/elapsed}"
+    last_stamp = now
+    last_count = $update_count
+  end
+end
+
+Polyphony.trap(:int) { puts "bye..."; exit! }

data/examples/io/config.ru

@@ -0,0 +1,3 @@
+run Proc.new { |env|
+    ['200', {'Content-Type' => 'text/html'}, ['A barebones rack app.']]
+}

data/examples/io/echo_client.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'modulation'
+
+Polyphony = import('../../lib/polyphony')
+
+socket = Polyphony::Net.tcp_connect('127.0.0.1', 1234)
+
+writer = spawn do
+  throttled_loop(1) { socket << "#{Time.now}\n" }
+end
+
+reader = spawn do
+  puts "received from echo server:"
+  while data = socket.read
+    STDOUT << data
+  end
+end
+
+sleep(5)
+[reader, writer].each(&:stop)
+socket.close

data/examples/io/echo_server.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'modulation'
+Polyphony = import('../../lib/polyphony')
+
+server = TCPServer.open(1234)
+puts "Echoing on port 1234..."
+while client = server.accept
+  spawn do
+    while data = client.readpartial(8192) rescue nil
+      client.write("you said: ", data.chomp, "!\n")
+    end
+  end
+end

data/examples/io/echo_server_with_timeout.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'modulation'
+
+Polyphony = import('../../lib/polyphony')
+
+begin
+  server = Polyphony::Net.tcp_listen(nil, 1234, reuse_addr: true, dont_linger: true)
+  puts "listening on port 1234..."
+
+  loop do
+    client = server.accept
+    spawn do
+      cancel_scope = nil
+      move_on_after(5) do |s|
+        cancel_scope = s
+        loop do
+          data = client.read
+          s.reset_timeout
+          client.write(data)
+        end
+      end
+      client.write "Disconnecting due to inactivity\n" if cancel_scope.cancelled?
+    rescue => e
+      puts "client error: #{e.inspect}"
+    ensure
+      client.close
+    end
+  end
+rescue Exception => e
+  puts "uncaught exception: #{e.inspect}"
+  server&.close
+end

data/examples/io/echo_stdin.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'modulation'
+
+Polyphony = import('../../lib/polyphony')
+
+puts "Write something..."
+move_on_after(5) do |scope|
+  loop do
+    data = STDIN.read
+    scope.reset_timeout
+    puts "you wrote: #{data}"
+  end
+end
+puts "quitting due to inactivity"

data/examples/io/happy_eyeballs.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'modulation'
+Polyphony = import('../../lib/polyphony')
+
+async def try_connect(supervisor, target)
+  puts "trying #{target[2]}"
+  socket = Polyphony::Net.tcp_connect(target[2], 80)
+  supervisor.stop!([target[2], socket])
+rescue IOError, SystemCallError
+end
+
+def happy_eyeballs(hostname, port, max_wait_time: 0.025)
+  targets = Socket.getaddrinfo(hostname, port, :INET, :STREAM)
+  t0 = Time.now
+  cancel_after(5) do
+    success = supervise do |supervisor|
+      targets.each_with_index do |t, idx|
+        sleep(max_wait_time) if idx > 0
+        supervisor.spawn try_connect(supervisor, t)
+      end
+    end
+    if success
+      puts "success: #{success[0]} (#{Time.now - t0}s)"
+    else
+      puts "timed out (#{Time.now - t0}s)"
+    end
+  end
+end
+
+# Let's try it out:
+happy_eyeballs("debian.org", "https")

data/examples/io/http_client.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'modulation'
+
+Polyphony = import('../../lib/polyphony')
+Agent = import('../../lib/polyphony/http/agent')
+
+def get_server_time
+  Agent.get('https://ui.realiteq.net/', q: :time).json
+end
+
+X = 50
+puts "Making #{X} requests..."
+t0 = Time.now
+supervise do |s|
+  X.times { get_server_time }
+end
+elapsed = Time.now - t0
+puts "count: #{X} elapsed: #{elapsed} rate: #{X / elapsed} reqs/s"

data/examples/io/http_server.js

@@ -0,0 +1,24 @@
+// For the sake of comparing performance, here's a node.js-based HTTP server
+// doing roughly the same thing as http_server. Preliminary benchmarking shows
+// the ruby version has a throughput (req/s) of about 2/3 of the JS version.
+
+const http = require('http');
+
+const MSG = 'Hello World';
+
+const server = http.createServer((req, res) => {
+  // let requestCopy = {
+  //   method: req.method,
+  //   request_url: req.url,
+  //   headers: req.headers
+  // };
+  
+  // res.writeHead(200, { 'Content-Type': 'application/json' });
+  // res.end(JSON.stringify(requestCopy));
+
+  res.writeHead(200);
+  res.end(MSG)
+});
+
+server.listen(1235);
+console.log('Listening on port 1235');

data/examples/io/http_server.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'modulation'
+
+Polyphony = import('../../lib/polyphony')
+HTTPServer = import('../../lib/polyphony/http/server')
+
+opts = { reuse_addr: true, dont_linger: true }
+server = HTTPServer.serve('0.0.0.0', 1234, opts) do |req|
+  req.respond("Hello world!\n")
+end
+puts "pid: #{Process.pid}"
+puts "Listening on port 1234..."
+server.await
+puts "bye bye"
+

data/examples/io/http_server_forked.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'modulation'
+require 'localhost/authority'
+
+Polyphony = import('../../lib/polyphony')
+HTTPServer = import('../../lib/polyphony/http/server')
+
+opts = {
+  reuse_addr: true,
+  dont_linger: true,
+}
+runner = HTTPServer.listener('0.0.0.0', 1234, opts) do |req|
+  req.respond("Hello world!\n")
+end
+
+puts "Listening on port 1234"
+
+child_pids = []
+4.times do
+  child_pids << Polyphony.fork do
+    puts "forked pid: #{Process.pid}"
+    spawn(&runner)
+  end
+end
+
+child_pids.each { |pid| EV::Child.new(pid).await }

data/examples/io/http_server_throttled.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'modulation'
+
+Polyphony = import('../../lib/polyphony')
+HTTPServer = import('../../lib/polyphony/http/server')
+
+$throttler = throttle(1000)
+opts = { reuse_addr: true, dont_linger: true }
+server = HTTPServer.serve('0.0.0.0', 1234, opts) do |req|
+  $throttler.call { req.respond("Hello world!\n") }
+end
+puts "pid: #{Process.pid}"
+puts "Listening on port 1234..."
+server.await
+puts "bye bye"

data/examples/io/http_ws_server.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'modulation'
+
+STDOUT.sync = true
+
+Polyphony = import('../../lib/polyphony')
+HTTPServer = import('../../lib/polyphony/http/server')
+Websocket = import('../../lib/polyphony/websocket')
+
+def ws_handler(conn)
+  timer = spawn {
+    throttled_loop(1) {
+      conn << Time.now.to_s
+    }
+  }
+  while msg = conn.recv
+    # conn << "you said: #{msg}"
+  end
+ensure
+  timer.stop
+end
+
+opts = {
+  reuse_addr: true,
+  dont_linger: true,
+  upgrade: {
+    websocket: Websocket.handler(&method(:ws_handler))
+  }
+}
+
+HTML = IO.read(File.join(__dir__, 'ws_page.html'))
+
+server = HTTPServer.serve('0.0.0.0', 1234, opts) do |req|
+  req.respond(HTML, 'Content-Type' => 'text/html')
+end
+
+puts "pid: #{Process.pid}"
+puts "Listening on port 1234..."
+server.await
+puts "bye bye"
+

data/examples/io/https_client.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'modulation'
+
+Polyphony = import('../../lib/polyphony')
+
+spawn do
+  t0 = Time.now
+  io = Polyphony::Net.tcp_connect('google.com', 443, secure: true)
+  io.write("GET / HTTP/1.1\r\nHost: google.com\r\n\r\n")
+  reply = io.read(2**16)
+  puts "time: #{Time.now - t0}"
+  puts
+  puts reply
+rescue => e
+  p e
+end

data/examples/io/https_server.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'modulation'
+require 'localhost/authority'
+
+Polyphony = import('../../lib/polyphony')
+HTTPServer = import('../../lib/polyphony/http/server')
+
+spawn do
+  authority = Localhost::Authority.fetch
+  opts = {
+    reuse_addr: true,
+    dont_linger: true,
+    secure_context: authority.server_context
+  }
+  server = HTTPServer.serve('0.0.0.0', 1234, opts) do |req|
+    req.respond("Hello world!\n")
+  end
+  server.await
+end
+
+puts "pid: #{Process.pid}"
+puts "Listening on port 1234..."

data/examples/io/https_wss_server.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'modulation'
+require 'localhost/authority'
+
+STDOUT.sync = true
+
+Polyphony = import('../../lib/polyphony')
+HTTPServer = import('../../lib/polyphony/http/server')
+Websocket = import('../../lib/polyphony/websocket')
+
+def ws_handler(conn)
+  timer = spawn {
+    throttled_loop(1) {
+      conn << Time.now.to_s rescue nil
+    }
+  }
+  while msg = conn.recv
+    puts "msg: #{msg}"
+    # conn << "you said: #{msg}"
+  end
+ensure
+  timer.stop
+end
+
+authority = Localhost::Authority.fetch
+opts = {
+  reuse_addr: true,
+  dont_linger: true,
+  secure_context: authority.server_context,
+  upgrade: {
+    websocket: Websocket.handler(&method(:ws_handler))
+  }
+}
+
+HTML = IO.read(File.join(__dir__, 'wss_page.html'))
+
+server = HTTPServer.serve('0.0.0.0', 1234, opts) do |req|
+  req.respond(HTML, 'Content-Type' => 'text/html')
+end
+
+puts "pid: #{Process.pid}"
+puts "Listening on port 1234..."
+server.await
+puts "bye bye"
+