polyphony-http 0.24

data/examples/http2_raw.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+require 'http/2'
+
+# Response = import '../../lib/polyphony/http/client/response'
+
+url = 'https://realiteq.net/?q=time'
+uri = URI(url)
+uri_key = { scheme: uri.scheme, host: uri.host, port: uri.port }
+
+ctx = {
+  method: :GET,
+  uri:    uri,
+  opts:   {},
+  retry:  0
+}
+
+SECURE_OPTS = { secure: true, alpn_protocols: ['h2', 'http/1.1'] }.freeze
+socket = Polyphony::Net.tcp_connect(uri_key[:host], uri_key[:port], SECURE_OPTS)
+
+puts 'connected'
+
+$client = HTTP2::Client.new
+$client.on(:frame) { |bytes| socket << bytes }
+$client.on(:frame_received) do |frame|
+  puts "Received frame: #{frame.inspect}"
+end
+# $client.on(:frame_sent) do |frame|
+#   puts "Sent frame: #{frame.inspect}"
+# end
+
+reader = spin do
+  while (data = socket.readpartial(8192))
+    $client << data
+    snooze
+  end
+end
+
+stream = $client.new_stream
+
+$headers = nil
+$done = nil
+@buffered_chunks = []
+
+@waiting_headers_fiber = nil
+@waiting_chunk_fiber = nil
+@waiting_done_fiber = nil
+
+# send request
+headers = {
+  ':method'    => ctx[:method].to_s,
+  ':scheme'    => ctx[:uri].scheme,
+  ':authority' => [ctx[:uri].host, ctx[:uri].port].join(':'),
+  ':path'      => ctx[:uri].request_uri,
+  'User-Agent' => 'curl/7.54.0'
+}
+headers.merge!(ctx[:opts][:headers]) if ctx[:opts][:headers]
+
+if ctx[:opts][:payload]
+  stream.headers(headers, end_stream: false)
+  stream.data(ctx[:opts][:payload], end_stream: true)
+else
+  stream.headers(headers, end_stream: true)
+end
+
+stream.on(:headers) { |headers|
+  puts "got headers"
+  # if @waiting_headers_fiber
+  #   @waiting_headers_fiber.transfer headers.to_h
+  # else
+    $headers = headers.to_h
+  # end
+}
+stream.on(:data) { |chunk|
+  puts "got data"
+  # if @waiting_chunk_fiber
+  #   @waiting_chunk_fiber&.transfer c
+  # else
+    @buffered_chunks << chunk
+  # end
+}
+
+def close
+  puts "got close"
+  $done = true
+end
+
+stream.on(:close) { close }
+  # @waiting_done_fiber&.transfer
+# }
+
+stream.on(:active) { puts "* active" }
+stream.on(:half_close) { puts "* half_close" }
+
+
+
+# wait for response
+# unless $headers
+#   @waiting_headers_fiber = Fiber.current
+#   $headers = suspend
+# end
+# p $headers
+# response = Response.new(self, $headers[':status'].to_i, $headers)
+# p response
+
+puts "waiting for response"
+while !$done
+  puts "waiting..."
+  sleep 1
+end
+puts "done"
+
+#   def body
+#     @waiting_chunk_fiber = Fiber.current
+#     body = +''
+#     while !$done
+#       chunk = suspend
+#       body << chunk
+#     end
+#     body
+#   rescue => e
+#     p e
+#     puts e.backtrace.join("\n")
+#   end
+# end
+
+# adapter = StreamAdapter.new
+# resp = adapter.request(ctx)
+# puts "*" * 40
+# p resp
+
+# body = resp.body
+# p body

data/examples/http_client.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony/http'
+
+Exception.__disable_sanitized_backtrace__ = true
+
+TIME_URI = 'https://ui.realiteq.net/'
+
+def get_server_time
+  json = Polyphony::HTTP::Agent.get(TIME_URI, query: { q: :time }).json
+  puts "*" * 40
+  p json
+end
+
+X = 1
+puts "Making #{X} requests..."
+t0 = Time.now
+supervise do |s|
+  X.times {
+    s.spin {
+      get_server_time
+    }
+  }
+end
+# get_server_time
+elapsed = Time.now - t0
+puts "count: #{X} elapsed: #{elapsed} rate: #{X / elapsed} reqs/s"

data/examples/http_get.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony/http'
+require 'polyphony'
+
+Exception.__disable_sanitized_backtrace__ = true
+
+resp = Polyphony::HTTP::Agent.get('https://realiteq.net/?q=time')
+puts "*" * 40
+puts resp.body
+
+__END__
+
+X = 1
+Y = 1
+t0 = Time.now
+supervise { |s|
+  X.times {
+    s.spin {
+      Y.times {
+        resp = Polyphony::HTTP::Agent.get('http://about.gitlab.com/')
+        puts "*" * 40
+        p resp.headers
+        puts "*" * 40
+        puts resp.body
+        # puts "body size: #{resp.body.bytesize}"
+      }
+    }
+  }
+}
+elapsed = Time.now - t0
+puts "\nelapsed: #{elapsed} rate: #{(X * Y) / elapsed}"

data/examples/http_parse_experiment.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+require 'http/parser'
+require 'fiber'
+
+i, o = IO.pipe
+
+class ParseLoop
+  def initialize(conn)
+    @parser = HTTP::Parser.new(self)
+    @conn = conn
+    @parse_fiber = Fiber.new do
+      while (data = conn.readpartial(8192))
+        @parser << data
+        snooze
+      end
+    rescue StandardError => e
+      conn.close
+      e
+    ensure
+      @message_in_train = nil
+    end
+    @state = nil
+  end
+
+  def on_headers_complete(headers)
+    @calling_fiber.transfer(headers)
+  end
+
+  def on_body(chunk)
+    @calling_fiber.transfer(chunk) if @read_body
+  end
+
+  def on_message_begin
+    @message_in_train = true
+  end
+
+  def on_message_complete
+    @message_in_train = nil
+    @calling_fiber.transfer nil
+  end
+
+  def parse_headers
+    @calling_fiber = Fiber.current
+    @parse_fiber.safe_transfer
+  end
+
+  def parse_body_chunk
+    @calling_fiber = Fiber.current
+    @read_body = true
+    @parse_fiber.safe_transfer
+  end
+
+  def consume_request
+    return unless @message_in_train
+
+    @calling_fiber = Fiber.current
+    @read_body = false
+    @parse_fiber.safe_transfer while @message_in_train
+  end
+
+  def alive?
+    @parse_fiber.alive?
+  end
+
+  def busy?
+    @message_in_train
+  end
+end
+
+def handle(parser)
+  headers = parser.parse_headers
+  return unless headers
+
+  puts "headers: #{headers.inspect}"
+  headers['Content-Length']
+  # if content_length && (content_length.to_i < 1000)
+  while (chunk = parser.parse_body_chunk)
+    puts "chunk: #{chunk.inspect}"
+  end
+  # else
+  #   parser.consume_request
+  # end
+  puts 'end of request'
+rescue StandardError => e
+  puts "error: #{e.inspect}"
+  raise e
+end
+
+writer = spin do
+  o << "POST / HTTP/1.1\r\nHost: example.com\r\nContent-Length: 6\r\n\r\n"
+  o << 'Hello!'
+
+  o << "POST / HTTP/1.1\r\nHost: example.com\r\n\r\n"
+
+  # o << "POST / HTTP/1.1\r\nHost: example.com\r\nContent-Length: 8192\r\n\r\n"
+  # o << ("Bye!" * 2048)
+
+  o << "POST / HTTP/1.1\r\nHost: example.com\r\nContent-Length: 4\r\n\r\n"
+  o << 'Bye!'
+
+  begin
+    (o << ('BLAH' * 100_000))
+  rescue StandardError
+    nil
+  end
+  o.close
+end
+
+begin
+  parse_loop = ParseLoop.new(i)
+  while parse_loop.alive?
+    puts '*' * 40
+    handle(parse_loop)
+  end
+rescue StandardError => e
+  writer.stop
+  puts "#{e.class}: #{e.message}"
+  puts e.backtrace
+end

data/examples/http_proxy.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony/http'
+require 'localhost/authority'
+
+# p Polyphony::HTTP::Agent.get('https://ui.realiteq.net/', q: :time)
+
+BASE_URL = 'http://realiteq.net'
+
+CACHE = {}.freeze
+
+def proxy(uri, opts)
+  now = Time.now
+  uri = BASE_URL + uri
+  entry = CACHE[uri]
+  return entry[:response] if entry && entry[:expires] >= now
+
+  puts "proxy => #{uri} (#{opts.inspect})"
+  response = Polyphony::HTTP::Agent.get(uri, opts)
+  # CACHE[uri] = {
+  #   expires: now + 60,
+  #   response: response
+  # }
+  response
+end
+
+HEADERS_BLACK_LIST = %w[
+  Transfer-Encoding Date Server Connection Content-Length Cache-Control
+  :method :authority :scheme :path
+].freeze
+
+def sanitize_headers(headers)
+  headers.reject { |k, _v| HEADERS_BLACK_LIST.include?(k) }
+end
+
+def sanitize_html(html)
+  # html.gsub('http://martigny-le-comte.fr/', '/')
+end
+
+# authority = Localhost::Authority.fetch
+
+rsa_cert = OpenSSL::X509::Certificate.new(
+  IO.read('../reality/aws/config/ssl/full_chain.pem')
+)
+rsa_pkey = OpenSSL::PKey.read(
+  IO.read('../reality/aws/config/ssl/private_key.pem')
+)
+ctx = OpenSSL::SSL::SSLContext.new
+ctx.add_certificate(rsa_cert, rsa_pkey)
+
+opts = {
+  reuse_addr:     true,
+  dont_linger:    true,
+  secure_context: ctx # authority.server_context
+}
+
+spin do
+  Polyphony::HTTP::Server.serve('0.0.0.0', 1234, opts) do |req|
+    puts "#{req.method} #{req.uri}"
+    puts "headers <: #{req.headers.inspect}"
+    # h = {
+    #   uri: req.uri.to_s,
+    #   protocol: req.protocol,
+    #   headers: req.headers,
+    #   body: req.body,
+    # }
+    response = proxy(req.uri.to_s, headers: sanitize_headers(req.headers))
+    headers = sanitize_headers(response[:headers])
+    body = response[:body]
+    # puts "body class: #{body.class}"
+    puts "headers >: #{response[:headers].inspect}"
+    # body = sanitize_html(body) if headers['Content-Type'] =~ /text\/html/
+    req.respond(body, headers)
+  rescue StandardError => e
+    puts 'error'
+    p e
+    puts e.backtrace.join("\n")
+  end
+end
+
+puts "pid: #{Process.pid}"
+puts 'Listening on port 1234...'

data/examples/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/http_server.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony/http'
+
+opts = {
+  reuse_addr:  true,
+  dont_linger: true
+}
+
+spin do
+  Polyphony::HTTP::Server.serve('0.0.0.0', 1234, 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