tipi 0.40 → 0.41

data/ext/tipi/http1_parser.h

@@ -0,0 +1,18 @@
+#ifndef HTTP1_PARSER_H
+#define HTTP1_PARSER_H
+
+#include "ruby.h"
+
+// debugging
+#define OBJ_ID(obj) (NUM2LONG(rb_funcall(obj, rb_intern("object_id"), 0)))
+#define INSPECT(str, obj) { printf(str); VALUE s = rb_funcall(obj, rb_intern("inspect"), 0); printf(": %s\n", StringValueCStr(s)); }
+#define TRACE_CALLER() { VALUE c = rb_funcall(rb_mKernel, rb_intern("caller"), 0); INSPECT("caller: ", c); }
+#define TRACE_C_STACK() { \
+  void *entries[10]; \
+  size_t size = backtrace(entries, 10); \
+  char **strings = backtrace_symbols(entries, size); \
+  for (unsigned long i = 0; i < size; i++) printf("%s\n", strings[i]); \
+  free(strings); \
+}
+
+#endif /* HTTP1_PARSER_H */

data/ext/tipi/tipi_ext.c

@@ -0,0 +1,5 @@
+void Init_HTTP1_Parser();
+
+void Init_tipi_ext() {
+  Init_HTTP1_Parser();
+}

data/lib/tipi.rb

@@ -2,6 +2,7 @@
 
 require 'polyphony'
 require_relative './tipi/http1_adapter'
+# require_relative './tipi/http1_adapter_new'
 require_relative './tipi/http2_adapter'
 require_relative './tipi/configuration'
 require_relative './tipi/response_extensions'
@@ -52,7 +53,7 @@ module Tipi
     def protocol_adapter(socket, opts)
       use_http2 = socket.respond_to?(:alpn_protocol) &&
                   socket.alpn_protocol == H2_PROTOCOL
-      klass = use_http2 ? HTTP2Adapter : HTTP1Adapter
+      klass = use_http2 ? HTTP2Adapter : HTTP1Adapter#New
       klass.new(socket, opts)
     end
 

data/lib/tipi/digital_fabric/agent.rb

@@ -24,9 +24,11 @@ module DigitalFabric
     class GracefulShutdown < RuntimeError
     end
 
+    @@id = 0
+
     def run
       @fiber = Fiber.current
-      @keep_alive_timer = spin_loop(interval: 5) { keep_alive }
+      @keep_alive_timer = spin_loop("#{@fiber.tag}-keep_alive", interval: 5) { keep_alive }
       while true
         connect_and_process_incoming_requests
         return if @shutdown
@@ -166,7 +168,7 @@ module DigitalFabric
     def recv_http_request(msg)
       req = prepare_http_request(msg)
       id = msg[Protocol::Attribute::ID]
-      @requests[id] = spin do
+      @requests[id] = spin("#{Fiber.current.tag}.#{id}") do
         http_request(req)
       rescue IOError, Errno::ECONNREFUSED, Errno::EPIPE
         # ignore
@@ -204,7 +206,7 @@ module DigitalFabric
     def recv_ws_request(msg)
       req = Qeweney::Request.new(msg[Protocol::Attribute::WS::HEADERS], RequestAdapter.new(self, msg))
       id = msg[Protocol::Attribute::ID]
-      @requests[id] = @long_running_requests[id] = spin do
+      @requests[id] = @long_running_requests[id] = spin("#{Fiber.current.tag}.#{id}-ws") do
         ws_request(req)
       rescue IOError, Errno::ECONNREFUSED, Errno::EPIPE
         # ignore

data/lib/tipi/digital_fabric/agent_proxy.rb

@@ -32,13 +32,13 @@ module DigitalFabric
       @fiber = Fiber.current
       @service.mount(route, self)
       @mounted = true
-      keep_alive_timer = spin_loop(interval: 5) { keep_alive }
+      # keep_alive_timer = spin_loop("#{@fiber.tag}-keep_alive", 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
+      # keep_alive_timer&.stop
       unmount
     end
 
@@ -98,6 +98,8 @@ module DigitalFabric
         return
       when Protocol::UNMOUNT
         return unmount
+      when Protocol::STATS_REQUEST
+        return handle_stats_request(message[Protocol::Attribute::ID])
       end
 
       handler = @requests[message[Protocol::Attribute::ID]]
@@ -146,7 +148,7 @@ module DigitalFabric
         while (message = receive)
           unless t1
             t1 = Time.now
-            @service.record_latency_measurement(t1 - t0)
+            @service.record_latency_measurement(t1 - t0, req)
           end
           kind = message[Protocol::Attribute::KIND]
           attributes = message[Protocol::Attribute::HttpRequest::HEADERS..-1]
@@ -187,6 +189,11 @@ module DigitalFabric
       send_df_message(Protocol.transfer_count(key, rx, tx))
     end
 
+    def handle_stats_request(id)
+      stats = @service.get_stats
+      send_df_message(Protocol.stats_response(id, stats))
+    end
+
     HTTP_RESPONSE_UPGRADE_HEADERS = { ':status' => Qeweney::Status::SWITCHING_PROTOCOLS }
 
     def http_custom_upgrade(id, req, headers)
@@ -197,7 +204,7 @@ module DigitalFabric
       req.send_headers(upgrade_headers, true)
 
       conn = req.adapter.conn
-      reader = spin do
+      reader = spin("#{Fiber.current.tag}.#{id}") do
         conn.recv_loop do |data|
           send_df_message(Protocol.conn_data(id, data))
         end
@@ -294,7 +301,7 @@ module DigitalFabric
     end
 
     def run_websocket_connection(id, websocket)
-      reader = spin do
+      reader = spin("#{Fiber.current}.#{id}-ws") do
         websocket.recv_loop do |data|
           send_df_message(Protocol.ws_data(id, data))
         end

data/lib/tipi/digital_fabric/executive.rb

@@ -15,8 +15,8 @@ module DigitalFabric
       route[:executive] = true
       @service.mount(route, self)
       @current_request_count = 0
-      @updater = spin_loop(interval: 10) { update_service_stats }
-      update_service_stats
+      # @updater = spin_loop(:executive_updater, interval: 10) { update_service_stats }
+      # update_service_stats
     end
 
     def current_request_count

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
@@ -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/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,59 @@ 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 Exception
+      [nil, nil]
+    end
+    
+    def get_stats
+      calculate_stats
+    end
+
     def incr_connection_count
       @connection_count += 1
     end
@@ -77,23 +109,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 +154,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 +174,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 +193,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 +202,6 @@ module DigitalFabric
       @executive = nil if route[:executive]
       @agents.delete(agent)
       @routing_changed = true
-
-      @waiting_lists[route] ||= []
     end
 
     INVALID_HOST = 'INVALID_HOST'
@@ -182,12 +217,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
 

data/lib/tipi/http1_adapter.rb

@@ -19,7 +19,7 @@ module Tipi
     
     def each(&block)
       @conn.recv_loop do |data|
-        return if handle_incoming_data(data, &block)
+        return if handle_incoming_data(data, &block) 
       end
     rescue SystemCallError, IOError
       # ignore
@@ -234,7 +234,7 @@ module Tipi
         "0\r\n\r\n",
         ->(len) { "#{len.to_s(16)}\r\n" },
         "\r\n",
-        16384    
+        chunk_size
       )
     end
 

data/lib/tipi/http1_adapter_new.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+require 'tipi_ext'
+require_relative './http2_adapter'
+require 'qeweney/request'
+
+module Tipi
+  # HTTP1 protocol implementation
+  class HTTP1AdapterNew
+    attr_reader :conn
+
+    # Initializes a protocol adapter instance
+    def initialize(conn, opts)
+      @conn = conn
+      @opts = opts
+      @first = true
+      @parser = Tipi::HTTP1Parser.new(@conn)
+    end
+    
+    def each(&block)
+      while true
+        headers = @parser.parse_headers
+        break unless headers
+        
+        # handle_request should return false if connection is persistent
+        # break if handle_request(headers, &block)
+        handle_request(headers, &block)
+      end
+    rescue Tipi::HTTP1Parser::Error
+      # ignore
+    rescue SystemCallError, IOError
+      # ignore
+    ensure
+      finalize_client_loop
+    end
+    
+    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
+      
+      request = Qeweney::Request.new(headers, self)
+      return true if upgrade_connection(request.headers, &block)
+        
+      block.call(request)
+      return !request.keep_alive?
+    end
+    
+    def finalize_client_loop
+      @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)
+      raise NotImplementedError
+    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)
+      raise NotImplementedError
+    end
+    
+    def protocol
+      @protocol      
+    end
+    
+    # Upgrades the connection to a different protocol, if the 'Upgrade' header is
+    # given. By default the only supported upgrade protocol is HTTP2. Additional
+    # protocols, notably WebSocket, can be specified by passing a hash to the
+    # :upgrade option when starting a server:
+    #
+    #     def ws_handler(conn)
+    #       conn << 'hi'
+    #       msg = conn.recv
+    #       conn << "You said #{msg}"
+    #       conn << 'bye'
+    #       conn.close
+    #     end
+    #
+    #     opts = {
+    #       upgrade: {
+    #         websocket: Tipi::Websocket.handler(&method(:ws_handler))
+    #       }
+    #     }
+    #     Tipi.serve('0.0.0.0', 1234, opts) { |req| ... }
+    #
+    # @param headers [Hash] request headers
+    # @return [boolean] truthy if the connection has been upgraded
+    def upgrade_connection(headers, &block)
+      upgrade_protocol = headers['upgrade']
+      return nil unless upgrade_protocol
+      
+      upgrade_protocol = upgrade_protocol.downcase.to_sym
+      upgrade_handler = @opts[:upgrade] && @opts[:upgrade][upgrade_protocol]
+      return upgrade_with_handler(upgrade_handler, headers) if upgrade_handler
+      return upgrade_to_http2(headers, &block) if upgrade_protocol == :h2c
+      
+      nil
+    end
+    
+    def upgrade_with_handler(handler, headers)
+      @parser = @requests_head = @requests_tail = 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)
+      true
+    end
+    
+    # Returns headers for HTTP2 upgrade
+    # @param headers [Hash] request headers
+    # @return [Hash] headers for HTTP2 upgrade
+    def http2_upgraded_headers(headers)
+      headers.merge(
+        ':scheme'    => 'http',
+        ':authority' => headers['host']
+      )
+    end
+
+    def websocket_connection(request)
+      Tipi::Websocket.new(@conn, request.headers)
+    end
+
+    def scheme_from_connection
+      @conn.is_a?(OpenSSL::SSL::SSLSocket) ? 'https' : 'http'
+    end
+    
+    # response API
+
+    CRLF = "\r\n"    
+    CRLF_ZERO_CRLF_CRLF = "\r\n0\r\n\r\n"
+
+    # 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(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
+
+    def respond_from_io(request, io, headers, chunk_size = 2**14)
+      consume_request(request) if @parsing
+
+      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(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(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
+      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(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
+    # @param body [boolean] whether a response body will be sent
+    # @param chunked [boolean] whether to use chunked transfer encoding
+    # @return [String] formatted response headers
+    def format_headers(headers, body, chunked)
+      status = headers[':status']
+      status ||= (body ? Qeweney::Status::OK : Qeweney::Status::NO_CONTENT)
+      lines = format_status_line(body, status, chunked)
+      headers.each do |k, v|
+        next if k =~ INTERNAL_HEADER_REGEXP
+        
+        collect_header_lines(lines, k, v)
+      end
+      lines << CRLF
+      lines
+    end
+    
+    def format_status_line(body, status, chunked)
+      if !body
+        empty_status_line(status)
+      else
+        with_body_status_line(status, body, chunked)
+      end
+    end
+    
+    def empty_status_line(status)
+      if status == 204
+        +"HTTP/1.1 #{status}\r\n"
+      else
+        +"HTTP/1.1 #{status}\r\nContent-Length: 0\r\n"
+      end
+    end
+    
+    def with_body_status_line(status, body, chunked)
+      if chunked
+        +"HTTP/1.1 #{status}\r\nTransfer-Encoding: chunked\r\n"
+      else
+        +"HTTP/1.1 #{status}\r\nContent-Length: #{body.is_a?(String) ? body.bytesize : body.to_i}\r\n"
+      end
+    end
+
+    def collect_header_lines(lines, key, value)
+      if value.is_a?(Array)
+        value.inject(lines) { |_, item| lines << "#{key}: #{item}\r\n" }
+      else
+        lines << "#{key}: #{value}\r\n"
+      end
+    end
+  end
+end