tipi 0.33 → 0.37.1

data/lib/tipi/digital_fabric.rb

@@ -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

@@ -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

@@ -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