tipi 0.39 → 0.43

data/lib/tipi/digital_fabric/executive.rb

@@ -15,7 +15,7 @@ module DigitalFabric
       route[:executive] = true
       @service.mount(route, self)
       @current_request_count = 0
-      @updater = spin_loop(interval: 10) { update_service_stats }
+      # @updater = spin_loop(:executive_updater, interval: 10) { update_service_stats }
       update_service_stats
     end
 
@@ -33,9 +33,13 @@ module DigitalFabric
         req.respond(message.to_json, { 'Content-Type' => 'text.json' })
       when '/stream/stats'
         stream_stats(req)
+      when '/upload'
+        req.respond("body: #{req.read.inspect}")
       else
         req.respond('Invalid path', { ':status' => Qeweney::Status::NOT_FOUND })
       end
+    rescue => e
+      puts "Error: #{e.inspect}"
     ensure
       @current_request_count -= 1
     end
@@ -43,7 +47,7 @@ module DigitalFabric
     def stream_stats(req)
       req.send_headers({ 'Content-Type' => 'text/event-stream' })
 
-      @service.timer.every(10) do
+      every(10) do
         message = last_service_stats
         req.send_chunk(format_sse_event(message.to_json))
       end

data/lib/tipi/digital_fabric/protocol.rb

@@ -22,6 +22,9 @@ module DigitalFabric
 
     TRANSFER_COUNT = 'transfer_count'
 
+    STATS_REQUEST = 'stats_request'
+    STATS_RESPONSE = 'stats_response'
+
     SEND_TIMEOUT = 15
     RECV_TIMEOUT = SEND_TIMEOUT + 5
 
@@ -69,6 +72,10 @@ module DigitalFabric
         RX = 2
         TX = 3
       end
+
+      module Stats
+        STATS = 2
+      end
     end
 
     class << self
@@ -95,8 +102,8 @@ module DigitalFabric
         DF_UPGRADE_RESPONSE
       end
 
-      def http_request(id, req)
-        [ HTTP_REQUEST, id, req.headers, req.next_chunk, req.complete? ]
+      def http_request(id, headers, buffered_chunk, complete)
+        [ HTTP_REQUEST, id, headers, buffered_chunk, complete ]
       end
 
       def http_response(id, body, headers, complete, transfer_count_key = nil)
@@ -136,12 +143,20 @@ module DigitalFabric
       end
         
       def ws_close(id)
-        [WS_CLOSE, id ]
+        [ WS_CLOSE, id ]
       end
 
       def transfer_count(key, rx, tx)
         [ TRANSFER_COUNT, key, rx, tx ]
       end
+
+      def stats_request(id)
+        [ STATS_REQUEST, id ]
+      end
+
+      def stats_response(id, stats)
+        [ STATS_RESPONSE, id, stats ]
+      end
     end
   end
 end

data/lib/tipi/digital_fabric/request_adapter.rb

@@ -17,10 +17,6 @@ module DigitalFabric
       @agent.get_http_request_body(@id, 1)
     end
 
-    def consume_request(request)
-      @agent.get_http_request_body(@id, nil)
-    end
-
     def respond(request, body, headers)
       @agent.send_df_message(
         Protocol.http_response(@id, body, headers, 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,65 @@ 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
+
+      object_space_stats = ObjectSpace.count_objects
+
+      {
+        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,
+          objects_total: object_space_stats[:TOTAL],
+          objects_free:  object_space_stats[:FREE]
+        }
       }
     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,23 +115,25 @@ 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
@@ -120,10 +160,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
@@ -136,12 +180,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)
@@ -151,11 +199,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)
@@ -165,8 +208,6 @@ module DigitalFabric
       @executive = nil if route[:executive]
       @agents.delete(agent)
       @routing_changed = true
-
-      @waiting_lists[route] ||= []
     end
 
     INVALID_HOST = 'INVALID_HOST'
@@ -182,12 +223,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
 
@@ -202,13 +237,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
@@ -216,8 +244,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,9 +1,10 @@
 # frozen_string_literal: true
 
-require 'http/parser'
-require_relative './http2_adapter'
+require 'h1p'
 require 'qeweney/request'
 
+require_relative './http2_adapter'
+
 module Tipi
   # HTTP1 protocol implementation
   class HTTP1Adapter
@@ -14,123 +15,78 @@ module Tipi
       @conn = conn
       @opts = opts
       @first = true
-      @parser = ::HTTP::Parser.new(self)
+      @parser = H1P::Parser.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 H1P::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)
-      rx = data.bytesize
-      @parser << data
-      while (request = @requests_head)
-        request.headers[':rx'] = rx
-        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(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
-        
-        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)
-      request = @requests_head
-      @conn.recv_loop do |data|
-        request.rx_incr(data.bytesize)
-        @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
-    end
-    
-    def queue_request(request)
-      if @requests_head
-        @requests_tail.__next__ = request
-        @requests_tail = request
-      else
-        @requests_head = @requests_tail = request
-      end
+    def get_body(request)
+      @parser.read_body
     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
@@ -168,14 +124,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
     
@@ -208,7 +165,6 @@ module Tipi
     # @param body [String] response body
     # @param headers
     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
@@ -217,7 +173,23 @@ module Tipi
         @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
@@ -226,10 +198,14 @@ module Tipi
     # @param chunked [boolean] whether to use chunked transfer encoding
     # @return [void]
     def send_headers(request, headers, empty_response: false, chunked: true)
-      formatted_headers = format_headers(headers, !empty_response, @parser.http_minor == 1 && chunked)
+      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
@@ -248,6 +224,20 @@ module Tipi
       @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]
@@ -257,6 +247,7 @@ module Tipi
     end
     
     def close
+      @conn.shutdown if @conn.respond_to?(:shutdown) rescue nil
       @conn.close
     end
     
@@ -303,7 +294,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