tipi 0.38 → 0.42

data/lib/tipi/digital_fabric/request_adapter.rb

@@ -6,40 +6,36 @@ 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
-      @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

@@ -13,26 +13,22 @@ module DigitalFabric
       @token = token
       @agents = {}
       @routes = {}
-      @waiting_lists = {} # hash mapping routes to arrays of requests waiting for an agent to mount
       @counters = {
         connections: 0,
         http_requests: 0,
         errors: 0
       }
       @connection_count = 0
+      @current_request_count = 0
       @http_latency_accumulator = 0
       @http_latency_counter = 0
+      @http_latency_max = 0
       @last_counters = @counters.merge(stamp: Time.now.to_f - 1)
       @fiber = Fiber.current
-      @timer = Polyphony::Timer.new(resolution: 1)
-
-      stats_updater = spin { @timer.every(10) { update_stats } }
-      @stats = {}
-
-      @current_request_count = 0
+      # @timer = Polyphony::Timer.new('service_timer', resolution: 5)
     end
 
-    def update_stats
+    def calculate_stats
       now = Time.now.to_f
       elapsed = now - @last_counters[:stamp]
       connections = @counters[:connections] - @last_counters[:connections]
@@ -40,23 +36,61 @@ module DigitalFabric
       errors = @counters[:errors] - @last_counters[:errors]
       @last_counters = @counters.merge(stamp: now)
 
-      average_latency = @http_latency_counter > 0 ?
-                        @http_latency_accumulator / @http_latency_counter :
-                        0
+      average_latency = @http_latency_counter == 0 ? 0 :
+                        @http_latency_accumulator / @http_latency_counter
       @http_latency_accumulator = 0
       @http_latency_counter = 0
-
-      @stats = {
-        connection_rate: connections / elapsed,
-        http_request_rate: http_requests / elapsed,
-        error_rate: errors / elapsed,
-        average_latency: average_latency,
-        agent_count: @agents.size,
-        connection_count: @connection_count,
-        concurrent_requests: @current_request_count
+      max_latency = @http_latency_max
+      @http_latency_max = 0
+
+      cpu, rss = pid_cpu_and_rss(Process.pid)
+
+      backend_stats = Thread.backend.stats
+      op_rate = backend_stats[:op_count] / elapsed
+      switch_rate = backend_stats[:switch_count] / elapsed
+      poll_rate = backend_stats[:poll_count] / elapsed
+
+      {
+        service: {
+          agent_count: @agents.size,
+          connection_count: @connection_count,
+          connection_rate: connections / elapsed,
+          error_rate: errors / elapsed,
+          http_request_rate: http_requests / elapsed,
+          latency_avg: average_latency,
+          latency_max: max_latency,
+          pending_requests: @current_request_count,
+          },
+        backend: {
+          op_rate: op_rate,
+          pending_ops: backend_stats[:pending_ops],
+          poll_rate: poll_rate,
+          runqueue_size: backend_stats[:runqueue_size],
+          runqueue_high_watermark: backend_stats[:runqueue_max_length],
+          switch_rate: switch_rate,
+
+        },
+        process: {
+          cpu_usage: cpu,
+          rss: rss.to_f / 1024,
+        }
       }
     end
 
+    def pid_cpu_and_rss(pid)
+      s = `ps -p #{pid} -o %cpu,rss`
+      cpu, rss = s.lines[1].chomp.strip.split(' ')
+      [cpu.to_f, rss.to_i]
+    rescue Polyphony::BaseException
+      raise
+    rescue Exception
+      [nil, nil]
+    end
+    
+    def get_stats
+      calculate_stats
+    end
+
     def incr_connection_count
       @connection_count += 1
     end
@@ -77,32 +111,36 @@ module DigitalFabric
       count
     end
 
-    def record_latency_measurement(latency)
+    def record_latency_measurement(latency, req)
       @http_latency_accumulator += latency
       @http_latency_counter += 1
+      @http_latency_max = latency if latency > @http_latency_max
+      return if latency < 1.0
+
+      puts format('slow request (%.1f): %p', latency, req.headers)
     end
   
-    def http_request(req)
+    def http_request(req, allow_df_upgrade = false)
       @current_request_count += 1
       @counters[:http_requests] += 1
       @counters[:connections] += 1 if req.headers[':first']
 
-      return upgrade_request(req) if req.upgrade_protocol
+      return upgrade_request(req, allow_df_upgrade) if req.upgrade_protocol
  
       inject_request_headers(req)
       agent = find_agent(req)
       unless agent
-        return req.respond('pong') if req.query[:q] == 'ping'
-
         @counters[:errors] += 1
         return req.respond(nil, ':status' => Qeweney::Status::SERVICE_UNAVAILABLE)
       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)
@@ -118,10 +156,14 @@ module DigitalFabric
       req.headers['x-forwarded-proto'] ||= conn.is_a?(OpenSSL::SSL::SSLSocket) ? 'https' : 'http'
     end
   
-    def upgrade_request(req)
+    def upgrade_request(req, allow_df_upgrade)
       case (protocol = req.upgrade_protocol)
       when 'df'
-        df_upgrade(req)
+        if allow_df_upgrade
+          df_upgrade(req)
+        else
+          req.respond(nil, ':status' => Qeweney::Status::SERVICE_UNAVAILABLE)
+        end
       else
         agent = find_agent(req)
         unless agent
@@ -134,12 +176,16 @@ module DigitalFabric
     end
   
     def df_upgrade(req)
+      # we don't want to count connected agents
+      @current_request_count -= 1
       if req.headers['df-token'] != @token
         return req.respond(nil, ':status' => Qeweney::Status::FORBIDDEN)
       end
 
       req.adapter.conn << Protocol.df_upgrade_response
       AgentProxy.new(self, req)
+    ensure
+      @current_request_count += 1
     end
   
     def mount(route, agent)
@@ -149,11 +195,6 @@ module DigitalFabric
       @executive = agent if route[:executive]
       @agents[agent] = route
       @routing_changed = true
-
-      if (waiting = @waiting_lists[route])
-        waiting.each { |f| f.schedule(agent) }
-        @waiting_lists.delete(route)
-      end
     end
   
     def unmount(agent)
@@ -163,8 +204,6 @@ module DigitalFabric
       @executive = nil if route[:executive]
       @agents.delete(agent)
       @routing_changed = true
-
-      @waiting_lists[route] ||= []
     end
 
     INVALID_HOST = 'INVALID_HOST'
@@ -172,7 +211,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,12 +219,6 @@ 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
-
       nil
     end
 
@@ -200,13 +233,6 @@ module DigitalFabric
       @route_keys = @routes.keys
     end
 
-    def wait_for_agent(wait_list)
-      wait_list << Fiber.current
-      @timer.move_on_after(10) { suspend }
-    ensure
-      wait_list.delete(self)
-    end
-
     def path_regexp(path)
       /^#{path}/
     end
@@ -214,8 +240,8 @@ module DigitalFabric
     def graceful_shutdown
       @shutdown = true
       @agents.keys.each do |agent|
-        if agent.respond_to?(:shutdown)
-          agent.shutdown
+        if agent.respond_to?(:send_shutdown)
+          agent.send_shutdown
         else
           @agents.delete(agent)
         end

data/lib/tipi/http1_adapter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'http/parser'
+require 'tipi_ext'
 require_relative './http2_adapter'
 require 'qeweney/request'
 
@@ -14,119 +14,78 @@ module Tipi
       @conn = conn
       @opts = opts
       @first = true
-      @parser = ::HTTP::Parser.new(self)
+      @parser = Tipi::HTTP1Parser.new(@conn)
     end
     
     def each(&block)
-      @conn.recv_loop do |data|
-        return if handle_incoming_data(data, &block)
+      while true
+        headers = @parser.parse_headers
+        break unless headers
+        
+        # handle_request returns true if connection is not persistent or was
+        # upgraded
+        break if handle_request(headers, &block)
       end
+    rescue Tipi::HTTP1Parser::Error
+      # ignore
     rescue SystemCallError, IOError
       # ignore
     ensure
       finalize_client_loop
     end
     
-    # return [Boolean] true if client loop should stop
-    def handle_incoming_data(data, &block)
-      @parser << data
-      while (request = @requests_head)
-        if @first
-          request.headers[':first'] = true
-          @first = nil
-        end
-        return true if upgrade_connection(request.headers, &block)
-        
-        @requests_head = request.__next__
-        block.call(request)
-        return true unless request.keep_alive?
+    def handle_request(headers, &block)
+      scheme = (proto = headers['x-forwarded-proto']) ?
+                proto.downcase : scheme_from_connection
+      headers[':scheme'] = scheme
+      @protocol = headers[':protocol']
+      if @first
+        headers[':first'] = true
+        @first = nil
+      end
+      
+      return true if upgrade_connection(headers, &block)
+      
+      request = Qeweney::Request.new(headers, self)
+      if !@parser.complete?
+        request.buffer_body_chunk(@parser.read_body_chunk(true))
+      end
+      block.call(request)
+      return !persistent_connection?(headers)
+    end
+
+    def persistent_connection?(headers)
+      if headers[':protocol'] == 'http/1.1'
+        return headers['connection'] != 'close'
+      else
+        connection = headers['connection']
+        return connection && connection != 'close'
       end
-      nil
     end
     
     def finalize_client_loop
-      # release references to various objects
-      @requests_head = @requests_tail = nil
       @parser = nil
+      @splicing_pipe = nil
+      @conn.shutdown if @conn.respond_to?(:shutdown) rescue nil
       @conn.close
     end
     
     # 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
-      @waiting_for_body_chunk = true
-      @next_chunk = nil
-      while !@requests_tail.complete? && (data = @conn.readpartial(8192))
-        @parser << data
-        return @next_chunk if @next_chunk
-        
-        snooze
-      end
-      nil
-    ensure
-      @waiting_for_body_chunk = nil
-    end
-    
-    # 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
-      request = @requests_head
-      @conn.recv_loop do |data|
-        @parser << data
-        return if request.complete?
-      end
-    end
-    
-    def protocol
-      version = @parser.http_version
-      "HTTP #{version.join('.')}"
-    end
-    
-    def on_headers_complete(headers)
-      headers = normalize_headers(headers)
-      headers[':path'] = @parser.request_url
-      headers[':method'] = @parser.http_method.downcase
-      scheme = (proto = headers['x-forwarded-proto']) ?
-                proto.downcase : scheme_from_connection
-      headers[':scheme'] = scheme
-      queue_request(Qeweney::Request.new(headers, self))
+    def get_body_chunk(request, buffered_only = false)
+      @parser.read_body_chunk(buffered_only)
     end
 
-    def normalize_headers(headers)
-      headers.each_with_object({}) do |(k, v), h|
-        k = k.downcase
-        hk = h[k]
-        if hk
-          hk = h[k] = [hk] unless hk.is_a?(Array)
-          v.is_a?(Array) ? hk.concat(v) : hk << v
-        else
-          h[k] = v
-        end
-      end
+    def get_body(request)
+      @parser.read_body
     end
-    
-    def queue_request(request)
-      if @requests_head
-        @requests_tail.__next__ = request
-        @requests_tail = request
-      else
-        @requests_head = @requests_tail = request
-      end
-    end
-    
-    def on_body(chunk)
-      if @waiting_for_body_chunk
-        @next_chunk = chunk
-        @waiting_for_body_chunk = nil
-      else
-        @requests_tail.buffer_body_chunk(chunk)
-      end
+
+    def complete?(request)
+      @parser.complete?
     end
     
-    def on_message_complete
-      @waiting_for_body_chunk = nil
-      @requests_tail.complete!(@parser.keep_alive?)
+    def protocol
+      @protocol
     end
     
     # Upgrades the connection to a different protocol, if the 'Upgrade' header is
@@ -164,14 +123,15 @@ module Tipi
     end
     
     def upgrade_with_handler(handler, headers)
-      @parser = @requests_head = @requests_tail = nil
+      @parser = nil
       handler.(self, headers)
       true
     end
     
     def upgrade_to_http2(headers, &block)
-      @parser = @requests_head = @requests_tail = nil
-      HTTP2Adapter.upgrade_each(@conn, @opts, http2_upgraded_headers(headers), &block)
+      headers = http2_upgraded_headers(headers)
+      body = @parser.read_body
+      HTTP2Adapter.upgrade_each(@conn, @opts, headers, body, &block)
       true
     end
     
@@ -185,8 +145,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,61 +160,100 @@ 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)
+      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
+
+    def respond_from_io(request, io, headers, chunk_size = 2**14)
+      formatted_headers = format_headers(headers, true, true)
+      request.tx_incr(formatted_headers.bytesize)
       
+      # assume chunked encoding
+      Thread.current.backend.splice_chunks(
+        io,
+        @conn,
+        formatted_headers,
+        "0\r\n\r\n",
+        ->(len) { "#{len.to_s(16)}\r\n" },
+        "\r\n",
+        chunk_size
+      )
+    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, http1_1?(request) && chunked)
+      request.tx_incr(formatted_headers.bytesize)
+      @conn.write(formatted_headers)
+    end
+
+    def http1_1?(request)
+      request.headers[':protocol'] == 'http/1.1'
     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
     
+    def send_chunk_from_io(request, io, r, w, chunk_size)
+      len = w.splice(io, chunk_size)
+      if len > 0
+        Thread.current.backend.chain(
+          [:write, @conn, "#{len.to_s(16)}\r\n"],
+          [:splice, r, @conn, len],
+          [:write, @conn, "\r\n"]
+        )
+      else
+        @conn.write("0\r\n\r\n")
+      end
+      len
+    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
     
     def close
+      @conn.shutdown if @conn.respond_to?(:shutdown) rescue nil
       @conn.close
     end
     
     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 +265,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
@@ -294,7 +293,7 @@ module Tipi
       if chunked
         +"HTTP/1.1 #{status}\r\nTransfer-Encoding: chunked\r\n"
       else
-        +"HTTP/1.1 #{status}\r\nContent-Length: #{body.bytesize}\r\n"
+        +"HTTP/1.1 #{status}\r\nContent-Length: #{body.is_a?(String) ? body.bytesize : body.to_i}\r\n"
       end
     end