RubyGems - tipi - Versions diffs - 0.32 → 0.37 - Mend

tipi 0.32 → 0.37

Files changed (48) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +27 -0
data/Gemfile.lock +10 -4
data/LICENSE +1 -1
data/TODO.md +13 -47
data/bin/tipi +13 -0
data/df/agent.rb +63 -0
data/df/etc_benchmark.rb +15 -0
data/df/multi_agent_supervisor.rb +87 -0
data/df/multi_client.rb +84 -0
data/df/routing_benchmark.rb +60 -0
data/df/sample_agent.rb +89 -0
data/df/server.rb +54 -0
data/df/sse_page.html +29 -0
data/df/stress.rb +24 -0
data/df/ws_page.html +38 -0
data/e +0 -0
data/examples/http_request_ws_server.rb +35 -0
data/examples/http_server.rb +6 -6
data/examples/http_server_forked.rb +4 -5
data/examples/http_server_form.rb +23 -0
data/examples/http_server_throttled_accept.rb +23 -0
data/examples/http_unix_socket_server.rb +17 -0
data/examples/http_ws_server.rb +10 -12
data/examples/routing_server.rb +34 -0
data/examples/ws_page.html +1 -2
data/lib/tipi.rb +7 -5
data/lib/tipi/configuration.rb +1 -1
data/lib/tipi/digital_fabric.rb +7 -0
data/lib/tipi/digital_fabric/agent.rb +225 -0
data/lib/tipi/digital_fabric/agent_proxy.rb +265 -0
data/lib/tipi/digital_fabric/executive.rb +100 -0
data/lib/tipi/digital_fabric/executive/index.html +69 -0
data/lib/tipi/digital_fabric/protocol.rb +90 -0
data/lib/tipi/digital_fabric/request_adapter.rb +48 -0
data/lib/tipi/digital_fabric/service.rb +230 -0
data/lib/tipi/http1_adapter.rb +50 -16
data/lib/tipi/http2_adapter.rb +5 -3
data/lib/tipi/http2_stream.rb +19 -7
data/lib/tipi/rack_adapter.rb +11 -3
data/lib/tipi/version.rb +1 -1
data/lib/tipi/websocket.rb +33 -29
data/test/helper.rb +1 -2
data/test/test_http_server.rb +3 -2
data/test/test_request.rb +108 -0
data/tipi.gemspec +7 -3
metadata +59 -7
data/lib/tipi/request.rb +0 -118

data/examples/http_ws_server.rb CHANGED Viewed

@@ -5,14 +5,14 @@ require 'tipi'
 require 'tipi/websocket'
 def ws_handler(conn)
-  timer = spin do
-    throttled_loop(1) do
-      conn << Time.now.to_s
-    end
+  timer = spin_loop(interval: 1) do
+    conn << Time.now.to_s
   end
   while (msg = conn.recv)
     conn << "you said: #{msg}"
   end
+rescue Exception => e
+  p e
 ensure
   timer.stop
 end
@@ -21,17 +21,15 @@ opts = {
   reuse_addr:  true,
   dont_linger: true,
   upgrade:     {
-    websocket: Polyphony::Websocket.handler(&method(:ws_handler))
+    websocket: Tipi::Websocket.handler(&method(:ws_handler))
   }
 }
 HTML = IO.read(File.join(__dir__, 'ws_page.html'))
-spin do
-  Tipi.serve('0.0.0.0', 1234, opts) do |req|
-    req.respond(HTML, 'Content-Type' => 'text/html')
-  end
-end
 puts "pid: #{Process.pid}"
-puts 'Listening on port 1234...'
+puts 'Listening on port 4411...'
+Tipi.serve('0.0.0.0', 4411, opts) do |req|
+  req.respond(HTML, 'Content-Type' => 'text/html')
+end

data/examples/routing_server.rb ADDED Viewed

@@ -0,0 +1,34 @@
+# 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...'
+app = Tipi.route do |r|
+  r.root do
+    r.redirect '/hello'
+  end
+  r.on 'hello' do
+    r.get 'world' do
+      r.respond 'Hello world'
+    end
+    r.get do
+      r.respond 'Hello'
+    end
+    r.post do
+      puts 'Someone said Hello'
+      r.redirect '/'
+    end
+  end
+end
+spin do
+  Tipi.serve('0.0.0.0', 4411, opts, &app)
+end.await

data/examples/ws_page.html CHANGED Viewed

@@ -6,14 +6,13 @@
 <body>
   <script>
     var connect = function () {
-      var exampleSocket = new WebSocket("ws://localhost:1234");
+      var exampleSocket = new WebSocket("wss://dev.realiteq.net/");
       exampleSocket.onopen = function (event) {
         document.querySelector('#status').innerText = 'connected';
         exampleSocket.send("Can you hear me?");
       };
       exampleSocket.onclose = function (event) {
-        console.log('onclose');
         document.querySelector('#status').innerText = 'disconnected';
         setTimeout(function () {
           // exampleSocket.removeAllListeners();

data/lib/tipi.rb CHANGED Viewed

@@ -28,10 +28,8 @@ module Tipi
     end
     def accept_loop(server, opts, &handler)
-      loop do
-        client = server.accept
+      server.accept_loop do |client|
         spin { client_loop(client, opts, &handler) }
-        snooze
       rescue OpenSSL::SSL::SSLError
         # disregard
       end
@@ -42,14 +40,18 @@ module Tipi
       adapter = protocol_adapter(client, opts)
       adapter.each(&handler)
     ensure
-      client.close
+      client.close rescue nil
     end
     def protocol_adapter(socket, opts)
       use_http2 = socket.respond_to?(:alpn_protocol) &&
-      socket.alpn_protocol == H2_PROTOCOL
+                  socket.alpn_protocol == H2_PROTOCOL
       klass = use_http2 ? HTTP2Adapter : HTTP1Adapter
       klass.new(socket, opts)
     end
+    def route(&block)
+      proc { |req| req.route(&block) }
+    end
   end
 end

data/lib/tipi/configuration.rb CHANGED Viewed

@@ -19,7 +19,7 @@ module Tipi
       end
       def start_listeners(config)
-        puts "listening on port 1234"
+        puts "Listening on port 1234"
         @server = Polyphony::Net.tcp_listen('0.0.0.0', 1234, { reuse_addr: true, dont_linger: true })
       end

data/lib/tipi/digital_fabric.rb ADDED Viewed

@@ -0,0 +1,7 @@
+module DigitalFabric
+end
+::DF = DigitalFabric
+require_relative 'digital_fabric/service'
+require_relative 'digital_fabric/agent_proxy'

data/lib/tipi/digital_fabric/agent.rb ADDED Viewed

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+require_relative './protocol'
+require_relative './request_adapter'
+require 'msgpack'
+require 'tipi/websocket'
+require 'tipi/request'
+module DigitalFabric
+  class Agent
+    def initialize(server_url, route, token)
+      @server_url = server_url
+      @route = route
+      @token = token
+      @requests = {}
+      @long_running_requests = {}
+      @name = '<unknown>'
+    end
+    class TimeoutError < RuntimeError
+    end
+    class GracefulShutdown < RuntimeError
+    end
+    def run
+      @fiber = Fiber.current
+      @keep_alive_timer = spin_loop(interval: 5) { keep_alive }
+      while true
+        connect_and_process_incoming_requests
+        return if @shutdown
+        sleep 5
+      end
+    ensure
+      @keep_alive_timer.stop
+    end
+    def connect_and_process_incoming_requests
+      # log 'Connecting...'
+      @socket = connect_to_server
+      @last_recv = @last_send = Time.now
+      df_upgrade
+      @connected = true
+      @msgpack_reader = MessagePack::Unpacker.new
+      process_incoming_requests
+    rescue IOError, Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::EPIPE, TimeoutError
+      log 'Disconnected' if @connected
+      @connected = nil
+    end
+    def connect_to_server
+      if @server_url =~ /^([^\:]+)\:(\d+)$/
+        host = Regexp.last_match(1)
+        port = Regexp.last_match(2)
+        Polyphony::Net.tcp_connect(host, port)
+      else
+        UNIXSocket.new(@server_url)
+      end
+    end
+    UPGRADE_REQUEST = <<~HTTP
+    GET / HTTP/1.1
+    Host: localhost
+    Connection: upgrade
+    Upgrade: df
+    DF-Token: %s
+    DF-Mount: %s
+    HTTP
+    def df_upgrade
+      @socket << format(UPGRADE_REQUEST, @token, mount_point)
+      while (line = @socket.gets)
+        break if line.chomp.empty?
+      end
+      # log 'Connection upgraded'
+    end
+    def mount_point
+      if @route[:host]
+        "host=#{@route[:host]}"
+      elsif @route[:path]
+        "path=#{@route[:path]}"
+      else
+        nil
+      end
+    end
+    def log(msg)
+      puts "#{Time.now} (#{@name}) #{msg}"
+    end
+    def process_incoming_requests
+      @socket.feed_loop(@msgpack_reader, :feed_each) do |msg|
+        recv_df_message(msg)
+        return if @shutdown && @requests.empty?
+      end
+    rescue IOError, SystemCallError, TimeoutError
+      # ignore
+    end
+    def keep_alive
+      return unless @connected
+      now = Time.now
+      if now - @last_send >= Protocol::SEND_TIMEOUT
+        send_df_message(Protocol.ping)
+      end
+      # if now - @last_recv >= Protocol::RECV_TIMEOUT
+      #   raise TimeoutError
+      # end
+    rescue IOError, SystemCallError => e
+      # transmit exception to fiber running the agent
+      @fiber.raise(e)
+    end
+    def recv_df_message(msg)
+      @last_recv = Time.now
+      case msg['kind']
+      when Protocol::SHUTDOWN
+        recv_shutdown
+      when Protocol::HTTP_REQUEST
+        recv_http_request(msg)
+      when Protocol::HTTP_REQUEST_BODY
+        recv_http_request_body(msg)
+      when Protocol::WS_REQUEST
+        recv_ws_request(msg)
+      when Protocol::CONN_DATA, Protocol::CONN_CLOSE,
+           Protocol::WS_DATA, Protocol::WS_CLOSE
+        fiber = @requests[msg['id']]
+        fiber << msg if fiber
+      end
+    end
+    def send_df_message(msg)
+      # we mark long-running requests by applying simple heuristics to sent DF
+      # messages. This is so we can correctly stop long-running requests
+      # upon graceful shutdown
+      if is_long_running_request_response?(msg)
+        id = msg[:id]
+        @long_running_requests[id] = @requests[id]
+      end
+      @last_send = Time.now
+      @socket << msg.to_msgpack
+    end
+    def is_long_running_request_response?(msg)
+      case msg[:kind]
+      when Protocol::HTTP_UPGRADE
+        true
+      when Protocol::HTTP_RESPONSE
+        msg[:body] && !msg[:complete]
+      end
+    end
+    def recv_shutdown
+      # puts "Received shutdown message (#{@requests.size} pending requests)"
+      # puts "  (Long running requests: #{@long_running_requests.size})"
+      @shutdown = true
+      @long_running_requests.values.each { |f| f.terminate(true) }
+    end
+    def recv_http_request(msg)
+      req = prepare_http_request(msg)
+      id = msg['id']
+      @requests[id] = spin do
+        http_request(req)
+      rescue IOError, Errno::ECONNREFUSED, Errno::EPIPE
+        # ignore
+      rescue Polyphony::Terminate
+        req.respond(nil, { ':status' => Qeweney::Status::SERVICE_UNAVAILABLE }) if Fiber.current.graceful_shutdown?
+      ensure
+        @requests.delete(id)
+        @long_running_requests.delete(id)
+        @fiber.terminate if @shutdown && @requests.empty?
+      end
+    end
+    def prepare_http_request(msg)
+      req = Qeweney::Request.new(msg['headers'], RequestAdapter.new(self, msg))
+      req.buffer_body_chunk(msg['body']) if msg['body']
+      req.complete! if msg['complete']
+      req
+    end
+    def recv_http_request_body(msg)
+      fiber = @requests[msg['id']]
+      return unless fiber
+      fiber << msg['body']
+    end
+    def get_http_request_body(id, limit)
+      send_df_message(Protocol.http_get_request_body(id, limit))
+      receive
+    end
+    def recv_ws_request(msg)
+      req = Qeweney::Request.new(msg['headers'], RequestAdapter.new(self, msg))
+      id = msg['id']
+      @requests[id] = @long_running_requests[id] = spin do
+        ws_request(req)
+      rescue IOError, Errno::ECONNREFUSED, Errno::EPIPE
+        # ignore
+      ensure
+        @requests.delete(id)
+        @long_running_requests.delete(id)
+        @fiber.terminate if @shutdown && @requests.empty?
+      end
+    end
+    # default handler for HTTP request
+    def http_request(req)
+      req.respond(nil, { ':status': Qeweney::Status::SERVICE_UNAVAILABLE })
+    end
+    # default handler for WS request
+    def ws_request(req)
+      req.respond(nil, { ':status': Qeweney::Status::SERVICE_UNAVAILABLE })
+    end
+  end
+end

data/lib/tipi/digital_fabric/agent_proxy.rb ADDED Viewed

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+require_relative './protocol'
+require 'msgpack'
+require 'tipi/websocket'
+module DigitalFabric
+  class AgentProxy
+    def initialize(service, req)
+      @service = service
+      @req = req
+      @conn = req.adapter.conn
+      @msgpack_reader = MessagePack::Unpacker.new
+      @requests = {}
+      @current_request_count = 0
+      @last_request_id = 0
+      @last_recv = @last_send = Time.now
+      run
+    end
+    def current_request_count
+      @current_request_count
+    end
+    class TimeoutError < RuntimeError
+    end
+    class GracefulShutdown < RuntimeError
+    end
+    def run
+      @fiber = Fiber.current
+      @service.mount(route, self)
+      keep_alive_timer = spin_loop(interval: 5) { keep_alive }
+      process_incoming_messages(false)
+    rescue GracefulShutdown
+      puts "Proxy got graceful shutdown, left: #{@requests.size} requests" if @requests.size > 0
+      process_incoming_messages(true)
+    ensure
+      keep_alive_timer&.stop
+      @service.unmount(self)
+    end
+    def process_incoming_messages(shutdown = false)
+      return if shutdown && @requests.empty?
+      @conn.feed_loop(@msgpack_reader, :feed_each) do |msg|
+        recv_df_message(msg)
+        return if shutdown && @requests.empty?
+      end
+    rescue TimeoutError, IOError
+    end
+    def shutdown
+      send_df_message(Protocol.shutdown)
+      @fiber.raise GracefulShutdown.new
+    end
+    def keep_alive
+      now = Time.now
+      if now - @last_send >= Protocol::SEND_TIMEOUT
+        send_df_message(Protocol.ping)
+      end
+      # if now - @last_recv >= Protocol::RECV_TIMEOUT
+      #   raise TimeoutError
+      # end
+    rescue TimeoutError, IOError
+    end
+    def route
+      case @req.headers['df-mount']
+      when /^\s*host\s*=\s*([^\s]+)/
+        { host: Regexp.last_match(1) }
+      when /^\s*path\s*=\s*([^\s]+)/
+        { path: Regexp.last_match(1) }
+      when /catch_all/
+        { catch_all: true }
+      else
+        nil
+      end
+    end
+    def recv_df_message(message)
+      @last_recv = Time.now
+      return if message['kind'] == Protocol::PING
+      handler = @requests[message['id']]
+      if !handler
+        # puts "Unknown request id in #{message}"
+        return
+      end
+      handler << message
+    end
+    def send_df_message(message)
+      @last_send = Time.now
+      @conn << message.to_msgpack
+    end
+    # HTTP / WebSocket
+    def register_request_fiber
+      id = (@last_request_id += 1)
+      @requests[id] = Fiber.current
+      id
+    end
+    def unregister_request_fiber(id)
+      @requests.delete(id)
+    end
+    def with_request
+      @current_request_count += 1
+      id = (@last_request_id += 1)
+      @requests[id] = Fiber.current
+      yield id
+    ensure
+      @current_request_count -= 1
+      @requests.delete(id)
+    end
+    def http_request(req)
+      t0 = Time.now
+      t1 = nil
+      with_request do |id|
+        send_df_message(Protocol.http_request(id, req))
+        while (message = receive)
+          unless t1
+            t1 = Time.now
+            @service.record_latency_measurement(t1 - t0)
+          end
+          return if http_request_message(id, req, message)
+        end
+      end
+    rescue => e
+      req.respond("Error: #{e.inspect}", ':status' => Qeweney::Status::INTERNAL_SERVER_ERROR)
+    end
+    # @return [Boolean] true if response is complete
+    def http_request_message(id, req, message)
+      case message['kind']
+      when Protocol::HTTP_UPGRADE
+        http_custom_upgrade(id, req, message)
+        true
+      when Protocol::HTTP_GET_REQUEST_BODY
+        http_get_request_body(id, req, message)
+        false
+      when Protocol::HTTP_RESPONSE
+        headers = message['headers']
+        body = message['body']
+        done = message['complete']
+        req.send_headers(headers) if headers && !req.headers_sent?
+        req.send_chunk(body, done: done) if body or done
+        done
+      else
+        # invalid message
+        true
+      end
+    end
+    HTTP_RESPONSE_UPGRADE_HEADERS = { ':status' => Qeweney::Status::SWITCHING_PROTOCOLS }
+    def http_custom_upgrade(id, req, message)
+      # send upgrade response
+      upgrade_headers = message['headers'] ?
+        message['headers'].merge(HTTP_RESPONSE_UPGRADE_HEADERS) :
+        HTTP_RESPONSE_UPGRADE_HEADERS
+      req.send_headers(upgrade_headers, true)
+      conn = req.adapter.conn
+      reader = spin do
+        conn.recv_loop do |data|
+          send_df_message(Protocol.conn_data(id, data))
+        end
+      end
+      while (message = receive)
+        return if http_custom_upgrade_message(conn, message)
+      end
+    ensure
+      reader.stop
+    end
+    def http_custom_upgrade_message(conn, message)
+      case message['kind']
+      when Protocol::CONN_DATA
+        conn << message['data']
+        false
+      when Protocol::CONN_CLOSE
+        true
+      else
+        # invalid message
+        true
+      end
+    end
+    def http_get_request_body(id, req, message)
+      case (limit = message['limit'])
+      when nil
+        body = req.read
+      else
+        limit = limit.to_i
+        body = nil
+        req.each_chunk do |chunk|
+          (body ||= +'') << chunk
+          break if body.bytesize >= limit
+        end
+      end
+      send_df_message(Protocol.http_request_body(id, body, req.complete?))
+    end
+    def http_upgrade(req, protocol)
+      if protocol == 'websocket'
+        handle_websocket_upgrade(req)
+      else
+        # other protocol upgrades should be handled by the agent, so we just run
+        # the request normally. The agent is expected to upgrade the connection
+        # using a http_upgrade message. From that moment on, two-way
+        # communication is handled using conn_data and conn_close messages.
+        http_request(req)
+      end
+    end
+    def handle_websocket_upgrade(req)
+      with_request do |id|
+        send_df_message(Protocol.ws_request(id, req.headers))
+        response = receive
+        case response['kind']
+        when Protocol::WS_RESPONSE
+          headers = response['headers'] || {}
+          status = headers[':status'] || Qeweney::Status::SWITCHING_PROTOCOLS
+          if status != Qeweney::Status::SWITCHING_PROTOCOLS
+            req.respond(nil, headers)
+            return
+          end
+          ws = Tipi::Websocket.new(req.adapter.conn, req.headers)
+          run_websocket_connection(id, ws)
+        else
+          req.respond(nil, ':status' => Qeweney::Status::SERVICE_UNAVAILABLE)
+        end
+      end
+    end
+    def run_websocket_connection(id, websocket)
+      reader = spin do
+        websocket.recv_loop do |data|
+          send_df_message(Protocol.ws_data(id, data))
+        end
+      end
+      while (message = receive)
+        case message['kind']
+        when Protocol::WS_DATA
+          websocket << message['data']
+        when Protocol::WS_CLOSE
+          return
+        else
+          raise "Unexpected websocket message #{message.inspect}"
+        end
+      end
+    ensure
+      reader.stop
+      websocket.close
+    end
+  end
+end