tipi 0.31 → 0.36

data/lib/tipi/digital_fabric/request_adapter.rb

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

data/lib/tipi/digital_fabric/service.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+require_relative './protocol'
+require_relative './agent_proxy'
+require 'securerandom'
+
+module DigitalFabric
+  class Service
+    attr_reader :token
+    attr_reader :timer
+
+    def initialize(token: )
+      @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
+      @http_latency_accumulator = 0
+      @http_latency_counter = 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
+    end
+
+    def update_stats
+      now = Time.now.to_f
+      elapsed = now - @last_counters[:stamp]
+      connections = @counters[:connections] - @last_counters[:connections]
+      http_requests = @counters[:http_requests] - @last_counters[:http_requests]
+      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
+      @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
+      }
+    end
+
+    def incr_connection_count
+      @connection_count += 1
+    end
+
+    def decr_connection_count
+      @connection_count -= 1
+    end
+
+    attr_reader :stats
+
+    def total_request_count
+      count = 0
+      @agents.keys.each do |agent|
+        if agent.respond_to?(:current_request_count)
+          count += agent.current_request_count
+        end
+      end
+      count
+    end
+
+    def record_latency_measurement(latency)
+      @http_latency_accumulator += latency
+      @http_latency_counter += 1
+    end
+  
+    def http_request(req)
+      @current_request_count += 1
+      @counters[:http_requests] += 1
+      @counters[:connections] += 1 if req.headers[':first']
+
+      return upgrade_request(req) 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
+      @counters[:errors] += 1
+    rescue => e
+      @counters[:errors] += 1
+      p e
+      puts e.backtrace.join("\n")
+      req.respond(e.inspect, ':status' => Qeweney::Status::INTERNAL_SERVER_ERROR)
+    ensure
+      @current_request_count -= 1
+      req.adapter.conn.close if @shutdown
+    end
+
+    def inject_request_headers(req)
+      req.headers['x-request-id'] = SecureRandom.uuid
+      conn = req.adapter.conn
+      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)
+      case (protocol = req.upgrade_protocol)
+      when 'df'
+        df_upgrade(req)
+      else
+        agent = find_agent(req)
+        unless agent
+          @counters[:errors] += 1
+          return req.respond(nil, ':status' => Qeweney::Status::SERVICE_UNAVAILABLE)
+        end
+
+        agent.http_upgrade(req, protocol)
+      end
+    end
+  
+    def df_upgrade(req)
+      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)
+    end
+  
+    def mount(route, agent)
+      if route[:path]
+        route[:path_regexp] = path_regexp(route[:path])
+      end
+      @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)
+      route = @agents[agent]
+      return unless route
+
+      @executive = nil if route[:executive]
+      @agents.delete(agent)
+      @routing_changed = true
+
+      @waiting_lists[route] ||= []
+    end
+
+    INVALID_HOST = 'INVALID_HOST'
+    
+    def find_agent(req)
+      compile_agent_routes if @routing_changed
+
+      host = req.headers['host'] || INVALID_HOST
+      path = req.headers[':path']
+
+      route = @route_keys.find do |route|
+        (host == route[:host]) || (path =~ route[:path_regexp])
+      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
+
+    def compile_agent_routes
+      @routing_changed = false
+
+      @routes.clear
+      @agents.keys.reverse.each do |agent|
+        route = @agents[agent]
+        @routes[route] ||= agent
+      end
+      @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
+
+    def graceful_shutdown
+      @shutdown = true
+      @agents.keys.each do |agent|
+        if agent.respond_to?(:shutdown)
+          agent.shutdown
+        else
+          @agents.delete(agent)
+        end
+      end
+      move_on_after(60) do
+        while !@agents.empty?
+          sleep 0.25
+        end
+      end
+    end
+  end
+end

data/lib/tipi/http1_adapter.rb

@@ -1,21 +1,24 @@
 # frozen_string_literal: true
 
 require 'http/parser'
-require_relative './request'
 require_relative './http2_adapter'
+require 'qeweney/request'
 
 module Tipi
   # HTTP1 protocol implementation
   class HTTP1Adapter
+    attr_reader :conn
+
     # Initializes a protocol adapter instance
     def initialize(conn, opts)
       @conn = conn
       @opts = opts
+      @first = true
       @parser = ::HTTP::Parser.new(self)
     end
     
     def each(&block)
-      @conn.read_loop do |data|
+      @conn.recv_loop do |data|
         return if handle_incoming_data(data, &block)
       end
     rescue SystemCallError, IOError
@@ -28,6 +31,10 @@ module Tipi
     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__
@@ -65,14 +72,9 @@ module Tipi
     # callback
     def consume_request
       request = @requests_head
-      loop do
-        data = @conn.readpartial(8192)
+      @conn.recv_loop do |data|
         @parser << data
         return if request.complete?
-        
-        snooze
-      rescue EOFError
-        break
       end
     end
     
@@ -82,9 +84,23 @@ module Tipi
     end
     
     def on_headers_complete(headers)
+      headers = normalize_headers(headers)
       headers[':path'] = @parser.request_url
-      headers[':method'] = @parser.http_method
-      queue_request(Request.new(headers, self))
+      headers[':method'] = @parser.http_method.downcase
+      queue_request(Qeweney::Request.new(headers, self))
+    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)
@@ -125,7 +141,7 @@ module Tipi
     # @param headers [Hash] request headers
     # @return [boolean] truthy if the connection has been upgraded
     def upgrade_connection(headers, &block)
-      upgrade_protocol = headers['Upgrade']
+      upgrade_protocol = headers['upgrade']
       return nil unless upgrade_protocol
       
       upgrade_protocol = upgrade_protocol.downcase.to_sym
@@ -154,12 +170,15 @@ module Tipi
     def http2_upgraded_headers(headers)
       headers.merge(
         ':scheme'    => 'http',
-        ':authority' => headers['Host']
+        ':authority' => headers['host']
       )
     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 body [String] response body
@@ -168,15 +187,15 @@ module Tipi
       consume_request if @parsing
       data = format_headers(headers, body)
       if body
-        data << if @parser.http_minor == 0
-          body
+        if @parser.http_minor == 0
+          data << body
         else
-          "#{body.bytesize.to_s(16)}\r\n#{body}\r\n0\r\n\r\n"
+          data << body.bytesize.to_s(16) << CRLF << body << CRLF_ZERO_CRLF_CRLF
         end
       end
-      @conn << data
+      @conn.write(data.join)
     end
-    
+      
     DEFAULT_HEADERS_OPTS = {
       empty_response:  false,
       consume_request: true
@@ -188,7 +207,8 @@ module Tipi
     # @param empty_response [boolean] whether a response body will be sent
     # @return [void]
     def send_headers(headers, opts = DEFAULT_HEADERS_OPTS)
-      @conn << format_headers(headers, !opts[:empty_response])
+      data = format_headers(headers, true)
+      @conn.write(data.join)
     end
     
     # Sends a response body chunk. If no headers were sent, default headers are
@@ -198,9 +218,10 @@ module Tipi
     # @param done [boolean] whether the response is completed
     # @return [void]
     def send_chunk(chunk, done: false)
-      data = +"#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n"
+      data = []
+      data << "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n" if chunk
       data << "0\r\n\r\n" if done
-      @conn << data
+      @conn.write(data.join)
     end
     
     # Finishes the response to the current request. If no headers were sent,
@@ -215,30 +236,23 @@ module Tipi
     end
     
     private
-    
-    # Formats response headers. If empty_response is true(thy), the response
-    # status code will default to 204, otherwise to 200.
+
+    # 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 empty_response [boolean] whether a response body will be sent
     # @return [String] formatted response headers
     def format_headers(headers, body)
-      status = headers[':status'] || (body ? 200 : 204)
-      data = format_status_line(body, status)
-      
+      status = headers[':status']
+      status ||= (body ? Qeweney::Status::OK : Qeweney::Status::NO_CONTENT)
+      lines = [format_status_line(body, status)]
       headers.each do |k, v|
         next if k =~ /^:/
         
-        data << format_header_lines(k, v)
-      end
-      data << "\r\n"
-    end
-    
-    def format_header_lines(key, value)
-      if value.is_a?(Array)
-        value.inject(+'') { |data, item| data << "#{key}: #{item}\r\n" }
-      else
-        "#{key}: #{value}\r\n"
+        collect_header_lines(lines, k, v)
       end
+      lines << CRLF
+      lines
     end
     
     def format_status_line(body, status)
@@ -264,5 +278,13 @@ module Tipi
         +"HTTP/1.1 #{status}\r\nTransfer-Encoding: chunked\r\n"
       end
     end
+
+    def collect_header_lines(lines, key, value)
+      if value.is_a?(Array)
+        value.inject(lines) { |lines, item| data << "#{key}: #{item}\r\n" }
+      else
+        lines << "#{key}: #{value}\r\n"
+      end
+    end
   end
 end