tipi 0.38 → 0.39

data/lib/tipi/digital_fabric/agent_proxy.rb

@@ -31,6 +31,7 @@ module DigitalFabric
     def run
       @fiber = Fiber.current
       @service.mount(route, self)
+      @mounted = true
       keep_alive_timer = spin_loop(interval: 5) { keep_alive }
       process_incoming_messages(false)
     rescue GracefulShutdown
@@ -38,7 +39,7 @@ module DigitalFabric
       process_incoming_messages(true)
     ensure
       keep_alive_timer&.stop
-      @service.unmount(self)
+      unmount
     end
 
     def process_incoming_messages(shutdown = false)
@@ -48,7 +49,15 @@ module DigitalFabric
         recv_df_message(msg)
         return if shutdown && @requests.empty?
       end
-    rescue TimeoutError, IOError
+    rescue TimeoutError, IOError, SystemCallError
+      # ignore and just return in order to terminate the proxy
+    end
+
+    def unmount
+      return unless @mounted
+
+      @service.unmount(self) 
+      @mounted = nil
     end
 
     def shutdown
@@ -82,9 +91,16 @@ module DigitalFabric
 
     def recv_df_message(message)
       @last_recv = Time.now
-      return if message['kind'] == Protocol::PING
+      # puts "<<< #{message.inspect}"
 
-      handler = @requests[message['id']]
+      case message[Protocol::Attribute::KIND]
+      when Protocol::PING
+        return
+      when Protocol::UNMOUNT
+        return unmount
+      end
+
+      handler = @requests[message[Protocol::Attribute::ID]]
       if !handler
         # puts "Unknown request id in #{message}"
         return
@@ -94,6 +110,8 @@ module DigitalFabric
     end
 
     def send_df_message(message)
+      # puts ">>> #{message.inspect}" unless message[Protocol::Attribute::KIND] == Protocol::PING
+
       @last_send = Time.now
       @conn << message.to_msgpack
     end
@@ -130,46 +148,51 @@ module DigitalFabric
             t1 = Time.now
             @service.record_latency_measurement(t1 - t0)
           end
-          return if http_request_message(id, req, message)
+          kind = message[Protocol::Attribute::KIND]
+          attributes = message[Protocol::Attribute::HttpRequest::HEADERS..-1]
+          return if http_request_message(id, req, kind, attributes)
         end
       end
     rescue => e
-      req.respond("Error: #{e.inspect}", ':status' => Qeweney::Status::INTERNAL_SERVER_ERROR)
+      p "Internal server error: #{e.inspect}"
+      puts e.backtrace.join("\n")
+      http_request_send_error_response(e)
+    end
+
+    def http_request_send_error_response(error)
+      response = format("Error: %s\n%s", error.inspect, error.backtrace.join("\n"))
+      req.respond(response, ':status' => Qeweney::Status::INTERNAL_SERVER_ERROR)
+    rescue IOError, SystemCallError
+      # ignore
     end
 
     # @return [Boolean] true if response is complete
-    def http_request_message(id, req, message)
-      case message['kind']
+    def http_request_message(id, req, kind, message)
+      case kind
       when Protocol::HTTP_UPGRADE
-        http_custom_upgrade(id, req, message)
+        http_custom_upgrade(id, req, *message)
         true
       when Protocol::HTTP_GET_REQUEST_BODY
-        http_get_request_body(id, req, message)
+        http_get_request_body(id, req, *message)
         false
       when Protocol::HTTP_RESPONSE
-        headers = message['headers']
-        body = message['body']
-        done = message['complete']
-        if !req.headers_sent? && done
-          req.respond(body, headers|| {})
-          true
-        else
-          req.send_headers(headers) if headers && !req.headers_sent?
-          req.send_chunk(body, done: done) if body or done
-          done
-        end
+        http_response(id, req, *message)
       else
         # invalid message
         true
       end
     end
 
+    def send_transfer_count(key, rx, tx)
+      send_df_message(Protocol.transfer_count(key, rx, tx))
+    end
+
     HTTP_RESPONSE_UPGRADE_HEADERS = { ':status' => Qeweney::Status::SWITCHING_PROTOCOLS }
 
-    def http_custom_upgrade(id, req, message)
+    def http_custom_upgrade(id, req, headers)
       # send upgrade response
-      upgrade_headers = message['headers'] ?
-        message['headers'].merge(HTTP_RESPONSE_UPGRADE_HEADERS) :
+      upgrade_headers = headers ?
+       headers.merge(HTTP_RESPONSE_UPGRADE_HEADERS) :
         HTTP_RESPONSE_UPGRADE_HEADERS
       req.send_headers(upgrade_headers, true)
 
@@ -187,9 +210,9 @@ module DigitalFabric
     end
 
     def http_custom_upgrade_message(conn, message)
-      case message['kind']
+      case message[Protocol::Attribute::KIND]
       when Protocol::CONN_DATA
-        conn << message['data']
+        conn << message[:Protocol::Attribute::ConnData::DATA]
         false
       when Protocol::CONN_CLOSE
         true
@@ -199,8 +222,30 @@ module DigitalFabric
       end
     end
 
-    def http_get_request_body(id, req, message)
-      case (limit = message['limit'])
+    def http_response(id, req, body, headers, complete, transfer_count_key)
+      if !req.headers_sent? && complete
+        req.respond(body, headers|| {})
+        if transfer_count_key
+          rx, tx = req.transfer_counts
+          send_transfer_count(transfer_count_key, rx, tx)
+        end
+        true
+      else
+        req.send_headers(headers) if headers && !req.headers_sent?
+        req.send_chunk(body, done: complete) if body or complete
+        
+        if complete && transfer_count_key
+          rx, tx = req.transfer_counts
+          send_transfer_count(transfer_count_key, rx, tx)
+        end
+        complete
+      end
+    rescue IOError, SystemCallError
+      # ignore error
+    end
+
+    def http_get_request_body(id, req, limit)
+      case limit
       when nil
         body = req.read
       else
@@ -230,9 +275,9 @@ module DigitalFabric
       with_request do |id|
         send_df_message(Protocol.ws_request(id, req.headers))
         response = receive
-        case response['kind']
+        case response[0]
         when Protocol::WS_RESPONSE
-          headers = response['headers'] || {} 
+          headers = response[2] || {} 
           status = headers[':status'] || Qeweney::Status::SWITCHING_PROTOCOLS
           if status != Qeweney::Status::SWITCHING_PROTOCOLS
             req.respond(nil, headers)
@@ -244,6 +289,8 @@ module DigitalFabric
           req.respond(nil, ':status' => Qeweney::Status::SERVICE_UNAVAILABLE)
         end
       end
+    rescue IOError, SystemCallError
+      # ignore
     end
 
     def run_websocket_connection(id, websocket)
@@ -253,9 +300,9 @@ module DigitalFabric
         end
       end
       while (message = receive)
-        case message['kind']
+        case message[Protocol::Attribute::KIND]
         when Protocol::WS_DATA
-          websocket << message['data']
+          websocket << message[Protocol::Attribute::WS::DATA]
         when Protocol::WS_CLOSE
           return
         else

data/lib/tipi/digital_fabric/protocol.rb

@@ -4,6 +4,7 @@ module DigitalFabric
   module Protocol
     PING = 'ping'
     SHUTDOWN = 'shutdown'
+    UNMOUNT = 'unmount'
 
     HTTP_REQUEST = 'http_request'
     HTTP_RESPONSE = 'http_response'
@@ -19,16 +20,68 @@ module DigitalFabric
     WS_DATA = 'ws_data'
     WS_CLOSE = 'ws_close'
 
+    TRANSFER_COUNT = 'transfer_count'
+
     SEND_TIMEOUT = 15
     RECV_TIMEOUT = SEND_TIMEOUT + 5
 
+    module Attribute
+      KIND = 0
+      ID = 1
+
+      module HttpRequest
+        HEADERS = 2
+        BODY_CHUNK = 3
+        COMPLETE = 4
+      end
+
+      module HttpResponse
+        BODY = 2
+        HEADERS = 3
+        COMPLETE = 4
+        TRANSFER_COUNT_KEY = 5
+      end
+
+      module HttpUpgrade
+        HEADERS = 2
+      end
+
+      module HttpGetRequestBody
+        LIMIT = 2
+      end
+
+      module HttpRequestBody
+        BODY = 2
+        COMPLETE = 3
+      end
+
+      module ConnectionData
+        DATA = 2
+      end
+
+      module WS
+        HEADERS = 2
+        DATA = 2
+      end
+
+      module TransferCount
+        KEY = 1
+        RX = 2
+        TX = 3
+      end
+    end
+
     class << self
       def ping
-        { kind: PING }
+        [ PING ]
       end
 
       def shutdown
-        { kind: SHUTDOWN }
+        [ SHUTDOWN ]
+      end
+
+      def unmount
+        [ UNMOUNT ]
       end
 
       DF_UPGRADE_RESPONSE = <<~HTTP.gsub("\n", "\r\n")
@@ -43,47 +96,51 @@ module DigitalFabric
       end
 
       def http_request(id, req)
-        { kind: HTTP_REQUEST, id: id, headers: req.headers, body: req.next_chunk, complete: req.complete? }
+        [ HTTP_REQUEST, id, req.headers, req.next_chunk, req.complete? ]
       end
 
-      def http_response(id, body, headers, complete)
-        { kind: HTTP_RESPONSE, id: id, body: body, headers: headers, complete: complete }
+      def http_response(id, body, headers, complete, transfer_count_key = nil)
+        [ HTTP_RESPONSE, id, body, headers, complete, transfer_count_key ]
       end
 
       def http_upgrade(id, headers)
-        { kind: HTTP_UPGRADE, id: id }
+        [ HTTP_UPGRADE, id, headers ]
       end
 
       def http_get_request_body(id, limit = nil)
-        { kind: HTTP_GET_REQUEST_BODY, id: id, limit: limit }
+        [ HTTP_GET_REQUEST_BODY, id, limit ]
       end
 
       def http_request_body(id, body, complete)
-        { kind: HTTP_REQUEST_BODY, id: id, body: body, complete: complete }
+        [ HTTP_REQUEST_BODY, id, body, complete ]
       end
 
       def connection_data(id, data)
-        { kind: CONN_DATA, id: id, data: data }
+        [ CONN_DATA, id, data ]
       end
 
       def connection_close(id)
-        { kind: CONN_CLOSE, id: id }
+        [ CONN_CLOSE, id ]
       end
 
       def ws_request(id, headers)
-        { kind: WS_REQUEST, id: id, headers: headers }
+        [ WS_REQUEST, id, headers ]
       end
 
       def ws_response(id, headers)
-        { kind: WS_RESPONSE, id: id, headers: headers }
+        [ WS_RESPONSE, id, headers ]
       end
 
       def ws_data(id, data)
-        { id: id, kind: WS_DATA, data: data }
+        [ WS_DATA, id, data ]
       end
         
       def ws_close(id)
-        { id: id, kind: WS_CLOSE }
+        [WS_CLOSE, id ]
+      end
+
+      def transfer_count(key, rx, tx)
+        [ TRANSFER_COUNT, key, rx, tx ]
       end
     end
   end

data/lib/tipi/digital_fabric/request_adapter.rb

@@ -6,40 +6,40 @@ module DigitalFabric
   class RequestAdapter
     def initialize(agent, msg)
       @agent = agent
-      @id = msg['id']
+      @id = msg[Protocol::Attribute::ID]
     end
 
     def protocol
       'df'
     end
 
-    def get_body_chunk
+    def get_body_chunk(request)
       @agent.get_http_request_body(@id, 1)
     end
 
-    def consume_request
+    def consume_request(request)
       @agent.get_http_request_body(@id, nil)
     end
 
-    def respond(body, headers)
+    def respond(request, body, headers)
       @agent.send_df_message(
         Protocol.http_response(@id, body, headers, true)
       )
     end
 
-    def send_headers(headers, opts = {})
+    def send_headers(request, headers, opts = {})
       @agent.send_df_message(
         Protocol.http_response(@id, nil, headers, false)
       )
   end
 
-    def send_chunk(body, done: )
+    def send_chunk(request, body, done: )
       @agent.send_df_message(
         Protocol.http_response(@id, body, nil, done)
       )
     end
 
-    def finish
+    def finish(request)
       @agent.send_df_message(
         Protocol.http_response(@id, nil, nil, true)
       )

data/lib/tipi/digital_fabric/service.rb

@@ -99,10 +99,12 @@ module DigitalFabric
       end
 
       agent.http_request(req)
-    rescue IOError, SystemCallError
+    rescue IOError, SystemCallError, HTTP2::Error::StreamClosed
       @counters[:errors] += 1
     rescue => e
       @counters[:errors] += 1
+      puts '*' * 40
+      p req
       p e
       puts e.backtrace.join("\n")
       req.respond(e.inspect, ':status' => Qeweney::Status::INTERNAL_SERVER_ERROR)
@@ -172,7 +174,7 @@ module DigitalFabric
     def find_agent(req)
       compile_agent_routes if @routing_changed
 
-      host = req.headers['host'] || INVALID_HOST
+      host = req.headers[':authority'] || req.headers['host'] || INVALID_HOST
       path = req.headers[':path']
 
       route = @route_keys.find do |route|
@@ -180,11 +182,11 @@ module DigitalFabric
       end
       return @routes[route] if route
 
-      # search for a known route for an agent that recently unmounted
-      route, wait_list = @waiting_lists.find do |route, _|
-        (host == route[:host]) || (path =~ route[:path_regexp])
-      end
-      return wait_for_agent(wait_list) if route
+      # # search for a known route for an agent that recently unmounted
+      # route, wait_list = @waiting_lists.find do |route, _|
+      #   (host == route[:host]) || (path =~ route[:path_regexp])
+      # end
+      # return wait_for_agent(wait_list) if route
 
       nil
     end

data/lib/tipi/http1_adapter.rb

@@ -29,8 +29,10 @@ module Tipi
     
     # return [Boolean] true if client loop should stop
     def handle_incoming_data(data, &block)
+      rx = data.bytesize
       @parser << data
       while (request = @requests_head)
+        request.headers[':rx'] = rx
         if @first
           request.headers[':first'] = true
           @first = nil
@@ -53,10 +55,11 @@ module Tipi
     
     # Reads a body chunk for the current request. Transfers control to the parse
     # loop, and resumes once the parse_loop has fired the on_body callback
-    def get_body_chunk
+    def get_body_chunk(request)
       @waiting_for_body_chunk = true
       @next_chunk = nil
       while !@requests_tail.complete? && (data = @conn.readpartial(8192))
+        request.rx_incr(data.bytesize)
         @parser << data
         return @next_chunk if @next_chunk
         
@@ -70,9 +73,10 @@ module Tipi
     # Waits for the current request to complete. Transfers control to the parse
     # loop, and resumes once the parse_loop has fired the on_message_complete
     # callback
-    def consume_request
+    def consume_request(request)
       request = @requests_head
       @conn.recv_loop do |data|
+        request.rx_incr(data.bytesize)
         @parser << data
         return if request.complete?
       end
@@ -185,8 +189,8 @@ module Tipi
       )
     end
 
-    def websocket_connection(req)
-      Tipi::Websocket.new(@conn, req.headers)
+    def websocket_connection(request)
+      Tipi::Websocket.new(@conn, request.headers)
     end
 
     def scheme_from_connection
@@ -200,52 +204,55 @@ module Tipi
 
     # Sends response including headers and body. Waits for the request to complete
     # if not yet completed. The body is sent using chunked transfer encoding.
+    # @param request [Qeweney::Request] HTTP request
     # @param body [String] response body
     # @param headers
-    def respond(body, headers)
-      consume_request if @parsing
-      data = [format_headers(headers, body, false), body]
-
-      # if body
-      #   if @parser.http_minor == 0
-      #     data << body
-      #   else
-      #     # data << body.bytesize.to_s(16) << CRLF << body << CRLF_ZERO_CRLF_CRLF
-      #     data << "#{body.bytesize.to_s(16)}\r\n#{body}\r\n0\r\n\r\n"
-      #   end
-      # end
-      # Polyphony.backend_sendv(@conn, data, 0)
-      @conn.write(*data)
+    def respond(request, body, headers)
+      consume_request(request) if @parsing
+      formatted_headers = format_headers(headers, body, false)
+      request.tx_incr(formatted_headers.bytesize + (body ? body.bytesize : 0))
+      if body
+        @conn.write(formatted_headers, body)
+      else
+        @conn.write(formatted_headers)
+      end
     end
       
     # Sends response headers. If empty_response is truthy, the response status
     # code will default to 204, otherwise to 200.
+    # @param request [Qeweney::Request] HTTP request
     # @param headers [Hash] response headers
     # @param empty_response [boolean] whether a response body will be sent
     # @param chunked [boolean] whether to use chunked transfer encoding
     # @return [void]
-    def send_headers(headers, empty_response: false, chunked: true)
-      data = format_headers(headers, !empty_response, @parser.http_minor == 1 && chunked)
-      @conn.write(data)
+    def send_headers(request, headers, empty_response: false, chunked: true)
+      formatted_headers = format_headers(headers, !empty_response, @parser.http_minor == 1 && chunked)
+      request.tx_incr(formatted_headers.bytesize)
+      @conn.write(formatted_headers)
     end
     
     # Sends a response body chunk. If no headers were sent, default headers are
     # sent using #send_headers. if the done option is true(thy), an empty chunk
     # will be sent to signal response completion to the client.
+    # @param request [Qeweney::Request] HTTP request
     # @param chunk [String] response body chunk
     # @param done [boolean] whether the response is completed
     # @return [void]
-    def send_chunk(chunk, done: false)
-      data = []
+    def send_chunk(request, chunk, done: false)
+      data = +''
       data << "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n" if chunk
       data << "0\r\n\r\n" if done
-      @conn.write(data.join) unless data.empty?
+      return if data.empty?
+
+      request.tx_incr(data.bytesize)
+      @conn.write(data)
     end
     
     # Finishes the response to the current request. If no headers were sent,
     # default headers are sent using #send_headers.
     # @return [void]
-    def finish
+    def finish(request)
+      request.tx_incr(5)
       @conn << "0\r\n\r\n"
     end
     
@@ -255,6 +262,8 @@ module Tipi
     
     private
 
+    INTERNAL_HEADER_REGEXP = /^:/.freeze
+
     # Formats response headers into an array. If empty_response is true(thy),
     # the response status code will default to 204, otherwise to 200.
     # @param headers [Hash] response headers
@@ -266,7 +275,7 @@ module Tipi
       status ||= (body ? Qeweney::Status::OK : Qeweney::Status::NO_CONTENT)
       lines = format_status_line(body, status, chunked)
       headers.each do |k, v|
-        next if k =~ /^:/
+        next if k =~ INTERNAL_HEADER_REGEXP
         
         collect_header_lines(lines, k, v)
       end