tipi 0.41 → 0.46

data/lib/tipi/digital_fabric/agent_proxy.rb

@@ -36,7 +36,7 @@ module DigitalFabric
       process_incoming_messages(false)
     rescue GracefulShutdown
       puts "Proxy got graceful shutdown, left: #{@requests.size} requests" if @requests.size > 0
-      process_incoming_messages(true)
+      move_on_after(15) { process_incoming_messages(true) }
     ensure
       # keep_alive_timer&.stop
       unmount
@@ -56,11 +56,11 @@ module DigitalFabric
     def unmount
       return unless @mounted
 
-      @service.unmount(self) 
+      @service.unmount(self)
       @mounted = nil
     end
 
-    def shutdown
+    def send_shutdown
       send_df_message(Protocol.shutdown)
       @fiber.raise GracefulShutdown.new
     end
@@ -144,13 +144,20 @@ module DigitalFabric
       t0 = Time.now
       t1 = nil
       with_request do |id|
-        send_df_message(Protocol.http_request(id, req))
+        msg = Protocol.http_request(id, req.headers, req.next_chunk(true), req.complete?)
+        send_df_message(msg)
         while (message = receive)
+          kind = message[Protocol::Attribute::KIND]
           unless t1
             t1 = Time.now
-            @service.record_latency_measurement(t1 - t0, req)
+            if kind == Protocol::HTTP_RESPONSE
+              headers = message[Protocol::Attribute::HttpResponse::HEADERS]
+              status = (headers && headers[':status']) || 200
+              if status < Qeweney::Status::BAD_REQUEST
+                @service.record_latency_measurement(t1 - t0, req)
+              end
+            end
           end
-          kind = message[Protocol::Attribute::KIND]
           attributes = message[Protocol::Attribute::HttpRequest::HEADERS..-1]
           return if http_request_message(id, req, kind, attributes)
         end
@@ -240,7 +247,7 @@ module DigitalFabric
       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)
@@ -284,7 +291,7 @@ module DigitalFabric
         response = receive
         case response[0]
         when Protocol::WS_RESPONSE
-          headers = response[2] || {} 
+          headers = response[2] || {}
           status = headers[':status'] || Qeweney::Status::SWITCHING_PROTOCOLS
           if status != Qeweney::Status::SWITCHING_PROTOCOLS
             req.respond(nil, headers)

data/lib/tipi/digital_fabric/executive.rb

@@ -16,7 +16,7 @@ module DigitalFabric
       @service.mount(route, self)
       @current_request_count = 0
       # @updater = spin_loop(:executive_updater, interval: 10) { update_service_stats }
-      # update_service_stats
+      update_service_stats
     end
 
     def current_request_count
@@ -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
@@ -79,7 +83,7 @@ module DigitalFabric
         raise 'Invalid output from top (cpu)'
       end
       cpu_utilization = 100 - Regexp.last_match(1).to_i
-      
+
       unless top =~ TOP_MEM_REGEXP && Regexp.last_match(1) =~ TOP_MEM_FREE_REGEXP
         raise 'Invalid output from top (mem)'
       end

data/lib/tipi/digital_fabric/protocol.rb

@@ -102,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)
@@ -141,7 +141,7 @@ module DigitalFabric
       def ws_data(id, data)
         [ WS_DATA, id, data ]
       end
-        
+
       def ws_close(id)
         [ WS_CLOSE, id ]
       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

@@ -25,7 +25,7 @@ module DigitalFabric
       @http_latency_max = 0
       @last_counters = @counters.merge(stamp: Time.now.to_f - 1)
       @fiber = Fiber.current
-      @timer = Polyphony::Timer.new('service_timer', resolution: 5)
+      # @timer = Polyphony::Timer.new('service_timer', resolution: 5)
     end
 
     def calculate_stats
@@ -50,6 +50,8 @@ module DigitalFabric
       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,
@@ -73,6 +75,8 @@ module DigitalFabric
         process: {
           cpu_usage: cpu,
           rss: rss.to_f / 1024,
+          objects_total: object_space_stats[:TOTAL],
+          objects_free:  object_space_stats[:FREE]
         }
       }
     end
@@ -81,10 +85,12 @@ module DigitalFabric
       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
@@ -117,14 +123,14 @@ module DigitalFabric
 
       puts format('slow request (%.1f): %p', latency, req.headers)
     end
-  
+
     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, allow_df_upgrade) if req.upgrade_protocol
- 
+
       inject_request_headers(req)
       agent = find_agent(req)
       unless agent
@@ -153,7 +159,7 @@ module DigitalFabric
       req.headers['x-forwarded-for'] = conn.peeraddr(false)[2]
       req.headers['x-forwarded-proto'] ||= conn.is_a?(OpenSSL::SSL::SSLSocket) ? 'https' : 'http'
     end
-  
+
     def upgrade_request(req, allow_df_upgrade)
       case (protocol = req.upgrade_protocol)
       when 'df'
@@ -172,7 +178,7 @@ module DigitalFabric
         agent.http_upgrade(req, protocol)
       end
     end
-  
+
     def df_upgrade(req)
       # we don't want to count connected agents
       @current_request_count -= 1
@@ -185,7 +191,7 @@ module DigitalFabric
     ensure
       @current_request_count += 1
     end
-  
+
     def mount(route, agent)
       if route[:path]
         route[:path_regexp] = path_regexp(route[:path])
@@ -194,7 +200,7 @@ module DigitalFabric
       @agents[agent] = route
       @routing_changed = true
     end
-  
+
     def unmount(agent)
       route = @agents[agent]
       return unless route
@@ -205,7 +211,7 @@ module DigitalFabric
     end
 
     INVALID_HOST = 'INVALID_HOST'
-    
+
     def find_agent(req)
       compile_agent_routes if @routing_changed
 
@@ -231,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
@@ -245,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/handler.rb

@@ -20,14 +20,14 @@ module Tipi
     ensure
       socket.close
     end
-    
+
     ALPN_PROTOCOLS = %w[h2 http/1.1].freeze
     H2_PROTOCOL = 'h2'
 
     def protocol_adapter(socket, opts)
       use_http2 = socket.respond_to?(:alpn_protocol) &&
                   socket.alpn_protocol == H2_PROTOCOL
-      
+
       klass = use_http2 ? HTTP2Adapter : HTTP1Adapter
       klass.new(socket, opts)
     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,127 +15,83 @@ 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, ArgumentError
+      # an ArgumentError might be raised in the parser if an invalid input
+      # string is given as the HTTP method (String#upcase will raise on invalid HTTP string)
+      #
+      # 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
-      nil
+
+      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
+    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
     # given. By default the only supported upgrade protocol is HTTP2. Additional
     # protocols, notably WebSocket, can be specified by passing a hash to the
@@ -160,27 +117,28 @@ module Tipi
     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
+      @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
-    
+
     # Returns headers for HTTP2 upgrade
     # @param headers [Hash] request headers
     # @return [Hash] headers for HTTP2 upgrade
@@ -198,10 +156,10 @@ module Tipi
     def scheme_from_connection
       @conn.is_a?(OpenSSL::SSL::SSLSocket) ? 'https' : 'http'
     end
-    
+
     # response API
 
-    CRLF = "\r\n"    
+    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
@@ -210,7 +168,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
@@ -220,19 +177,19 @@ module Tipi
       end
     end
 
-    def respond_from_io(request, io, headers, chunk_size = 2**14)
-      consume_request(request) if @parsing
+    CHUNK_LENGTH_PROC = ->(len) { "#{len.to_s(16)}\r\n" }
 
+    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" },
+        CHUNK_LENGTH_PROC,
         "\r\n",
         chunk_size
       )
@@ -246,11 +203,15 @@ 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
     # will be sent to signal response completion to the client.
@@ -267,7 +228,7 @@ module Tipi
       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
@@ -289,12 +250,12 @@ module Tipi
       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
@@ -311,13 +272,13 @@ module Tipi
       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)
@@ -325,7 +286,7 @@ module Tipi
         with_body_status_line(status, body, chunked)
       end
     end
-    
+
     def empty_status_line(status)
       if status == 204
         +"HTTP/1.1 #{status}\r\n"
@@ -333,7 +294,7 @@ module Tipi
         +"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"