RubyGems - tipi - Versions diffs - 0.33 → 0.37.1 - Mend

tipi 0.33 → 0.37.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (44) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +22 -0
data/Gemfile.lock +10 -4
data/LICENSE +1 -1
data/TODO.md +11 -47
data/df/agent.rb +63 -0
data/df/etc_benchmark.rb +15 -0
data/df/multi_agent_supervisor.rb +87 -0
data/df/multi_client.rb +84 -0
data/df/routing_benchmark.rb +60 -0
data/df/sample_agent.rb +89 -0
data/df/server.rb +54 -0
data/df/sse_page.html +29 -0
data/df/stress.rb +24 -0
data/df/ws_page.html +38 -0
data/e +0 -0
data/examples/http_request_ws_server.rb +35 -0
data/examples/http_server.rb +6 -6
data/examples/http_server_form.rb +23 -0
data/examples/http_unix_socket_server.rb +17 -0
data/examples/http_ws_server.rb +10 -12
data/examples/routing_server.rb +34 -0
data/examples/ws_page.html +1 -2
data/lib/tipi.rb +5 -1
data/lib/tipi/digital_fabric.rb +7 -0
data/lib/tipi/digital_fabric/agent.rb +225 -0
data/lib/tipi/digital_fabric/agent_proxy.rb +265 -0
data/lib/tipi/digital_fabric/executive.rb +100 -0
data/lib/tipi/digital_fabric/executive/index.html +69 -0
data/lib/tipi/digital_fabric/protocol.rb +90 -0
data/lib/tipi/digital_fabric/request_adapter.rb +48 -0
data/lib/tipi/digital_fabric/service.rb +230 -0
data/lib/tipi/http1_adapter.rb +50 -14
data/lib/tipi/http2_adapter.rb +4 -2
data/lib/tipi/http2_stream.rb +20 -8
data/lib/tipi/rack_adapter.rb +1 -1
data/lib/tipi/version.rb +1 -1
data/lib/tipi/websocket.rb +33 -29
data/test/helper.rb +1 -2
data/test/test_http_server.rb +10 -12
data/test/test_request.rb +108 -0
data/tipi.gemspec +7 -3
metadata +57 -6
data/lib/tipi/request.rb +0 -118

data/lib/tipi/digital_fabric/executive.rb ADDED Viewed

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+require 'tipi/digital_fabric'
+require 'json'
+module DigitalFabric
+  # agent for managing DF service
+  class Executive
+    INDEX_HTML = IO.read(File.join(__dir__, 'executive/index.html'))
+    attr_reader :last_service_stats
+    def initialize(service, route = { path: '/executive' })
+      @service = service
+      route[:executive] = true
+      @service.mount(route, self)
+      @current_request_count = 0
+      @updater = spin_loop(interval: 10) { update_service_stats }
+      update_service_stats
+    end
+    def current_request_count
+      @current_request_count
+    end
+    def http_request(req)
+      @current_request_count += 1
+      case req.path
+      when '/'
+        req.respond(INDEX_HTML, 'Content-Type' => 'text/html')
+      when '/stats'
+        message = last_service_stats
+        req.respond(message.to_json, { 'Content-Type' => 'text.json' })
+      when '/stream/stats'
+        stream_stats(req)
+      else
+        req.respond('Invalid path', { ':status' => Qeweney::Status::NOT_FOUND })
+      end
+    ensure
+      @current_request_count -= 1
+    end
+    def stream_stats(req)
+      req.send_headers({ 'Content-Type' => 'text/event-stream' })
+      @service.timer.every(10) do
+        message = last_service_stats
+        req.send_chunk(format_sse_event(message.to_json))
+      end
+    rescue IOError, SystemCallError
+      # ignore
+    ensure
+      req.send_chunk("retry: 0\n\n", true) rescue nil
+    end
+    def format_sse_event(data)
+      "data: #{data}\n\n"
+    end
+    def update_service_stats
+      @last_service_stats = {
+        service: @service.stats,
+        machine: machine_stats
+      }
+    end
+    TOP_CPU_REGEXP = /%Cpu(.+)/.freeze
+    TOP_CPU_IDLE_REGEXP = /([\d\.]+) id/.freeze
+    TOP_MEM_REGEXP = /MiB Mem(.+)/.freeze
+    TOP_MEM_FREE_REGEXP = /([\d\.]+) free/.freeze
+    LOADAVG_REGEXP = /^([\d\.]+)/.freeze
+    def machine_stats
+      top = `top -bn1 | head -n4`
+      unless top =~ TOP_CPU_REGEXP && Regexp.last_match(1) =~ TOP_CPU_IDLE_REGEXP
+        p top =~ TOP_CPU_REGEXP
+        p Regexp.last_match(1)
+        p Regexp.last_match(1) =~ TOP_CPU_IDLE_REGEXP
+        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
+      mem_free = Regexp.last_match(1).to_f
+      stats = `cat /proc/loadavg`
+      raise 'Invalid output from /proc/loadavg' unless stats =~ LOADAVG_REGEXP
+      load_avg = Regexp.last_match(1).to_f
+      {
+        mem_free: mem_free,
+        cpu_utilization: cpu_utilization,
+        load_avg: load_avg
+      }
+    end
+  end
+end

data/lib/tipi/digital_fabric/executive/index.html ADDED Viewed

@@ -0,0 +1,69 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <title>Digital Fabric Executive</title>
+  <style>
+    .hidden { display: none }
+  </style>
+</head>
+<body>
+  <h1>Digital Fabric Executive</h1>
+  <script>
+    function updateStats(update) {
+      for (let k in update.service) {
+        let v = update.service[k];
+        let e = document.querySelector('#' + k);
+        if (e) e.innerText = v;
+      }
+      for (let k in update.machine) {
+        let v = update.machine[k];
+        let e = document.querySelector('#' + k);
+        if (e) e.innerText = v;
+      }
+    }
+    function connect() {
+      console.log("connecting...");
+      window.eventSource = new EventSource("/stream/stats");
+      window.eventSource.onopen = function(e) {
+        console.log("connected");
+        document.querySelector('#status').innerText = 'connected';
+        document.querySelector('#stats').className = '';
+        return false;
+      }
+      window.eventSource.onmessage = function(e) {
+        console.log("message", e.data);
+        updateStats(JSON.parse(e.data));
+      }
+      window.eventSource.onerror = function(e) {
+        console.log("error", e);
+        document.querySelector('#status').innerText = 'disconnected';
+        document.querySelector('#stats').className = 'hidden';
+        window.eventSource.close();
+        window.eventSource = null;
+        setTimeout(connect, 5000);
+      }
+    };
+    window.onload = connect;
+  </script>
+  <h2 id="status"></h2>
+  <div id="stats" class="hidden">
+    <h2>Service</h2>
+    <p>Request rate: <span id="http_request_rate"></span></p>
+    <p>Error rate: <span id="error_rate"></span></p>
+    <p>Average Latency: <span id="average_latency"></span>s</p>
+    <p>Connected agents: <span id="agent_count"></span></p>
+    <p>Connected clients: <span id="connection_count"></span></p>
+    <p>Concurrent requests: <span id="concurrent_requests"></span></p>
+    <h2>Machine</h2>
+    <p>CPU utilization: <span id="cpu_utilization"></span>%</p>
+    <p>Free memory: <span id="mem_free"></span>MB</p>
+    <p>Load average: <span id="load_avg"></span></p>
+  </div>
+</body>
+</html>

data/lib/tipi/digital_fabric/protocol.rb ADDED Viewed

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+module DigitalFabric
+  module Protocol
+    PING = 'ping'
+    SHUTDOWN = 'shutdown'
+    HTTP_REQUEST = 'http_request'
+    HTTP_RESPONSE = 'http_response'
+    HTTP_UPGRADE = 'http_upgrade'
+    HTTP_GET_REQUEST_BODY = 'http_get_request_body'
+    HTTP_REQUEST_BODY = 'http_request_body'
+    CONN_DATA = 'conn_data'
+    CONN_CLOSE = 'conn_close'
+    WS_REQUEST = 'ws_request'
+    WS_RESPONSE = 'ws_response'
+    WS_DATA = 'ws_data'
+    WS_CLOSE = 'ws_close'
+    SEND_TIMEOUT = 15
+    RECV_TIMEOUT = SEND_TIMEOUT + 5
+    class << self
+      def ping
+        { kind: PING }
+      end
+      def shutdown
+        { kind: SHUTDOWN }
+      end
+      DF_UPGRADE_RESPONSE = <<~HTTP.gsub("\n", "\r\n")
+        HTTP/1.1 101 Switching Protocols
+        Upgrade: df
+        Connection: Upgrade
+      HTTP
+      def df_upgrade_response
+        DF_UPGRADE_RESPONSE
+      end
+      def http_request(id, req)
+        { kind: HTTP_REQUEST, id: id, headers: req.headers, body: req.next_chunk, complete: req.complete? }
+      end
+      def http_response(id, body, headers, complete)
+        { kind: HTTP_RESPONSE, id: id, body: body, headers: headers, complete: complete }
+      end
+      def http_upgrade(id, headers)
+        { kind: HTTP_UPGRADE, id: id }
+      end
+      def http_get_request_body(id, limit = nil)
+        { kind: HTTP_GET_REQUEST_BODY, id: id, limit: limit }
+      end
+      def http_request_body(id, body, complete)
+        { kind: HTTP_REQUEST_BODY, id: id, body: body, complete: complete }
+      end
+      def connection_data(id, data)
+        { kind: CONN_DATA, id: id, data: data }
+      end
+      def connection_close(id)
+        { kind: CONN_CLOSE, id: id }
+      end
+      def ws_request(id, headers)
+        { kind: WS_REQUEST, id: id, headers: headers }
+      end
+      def ws_response(id, headers)
+        { kind: WS_RESPONSE, id: id, headers: headers }
+      end
+      def ws_data(id, data)
+        { id: id, kind: WS_DATA, data: data }
+      end
+      def ws_close(id)
+        { id: id, kind: WS_CLOSE }
+      end
+    end
+  end
+end

data/lib/tipi/digital_fabric/request_adapter.rb ADDED Viewed

@@ -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 ADDED Viewed

@@ -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