RubyGems - tipi - Versions diffs - 0.30 - Mend

tipi 0.30

Files changed (48) hide show

checksums.yaml +7 -0
data/.github/workflows/test.yml +27 -0
data/.gitignore +56 -0
data/CHANGELOG.md +33 -0
data/Gemfile +3 -0
data/Gemfile.lock +50 -0
data/LICENSE +21 -0
data/README.md +23 -0
data/Rakefile +12 -0
data/TODO.md +66 -0
data/bin/tipi +12 -0
data/docs/README.md +62 -0
data/docs/summary.md +60 -0
data/examples/cuba.ru +23 -0
data/examples/hanami-api.ru +23 -0
data/examples/http_server.js +24 -0
data/examples/http_server.rb +21 -0
data/examples/http_server_forked.rb +29 -0
data/examples/http_server_graceful.rb +27 -0
data/examples/http_server_simple.rb +11 -0
data/examples/http_server_throttled.rb +15 -0
data/examples/http_server_timeout.rb +35 -0
data/examples/http_ws_server.rb +37 -0
data/examples/https_server.rb +24 -0
data/examples/https_server_forked.rb +32 -0
data/examples/https_wss_server.rb +39 -0
data/examples/rack_server.rb +12 -0
data/examples/rack_server_https.rb +19 -0
data/examples/rack_server_https_forked.rb +27 -0
data/examples/websocket_secure_server.rb +27 -0
data/examples/websocket_server.rb +24 -0
data/examples/ws_page.html +34 -0
data/examples/wss_page.html +34 -0
data/lib/tipi.rb +54 -0
data/lib/tipi/http1_adapter.rb +268 -0
data/lib/tipi/http2_adapter.rb +74 -0
data/lib/tipi/http2_stream.rb +134 -0
data/lib/tipi/rack_adapter.rb +67 -0
data/lib/tipi/request.rb +118 -0
data/lib/tipi/version.rb +5 -0
data/lib/tipi/websocket.rb +61 -0
data/test/coverage.rb +45 -0
data/test/eg.rb +27 -0
data/test/helper.rb +51 -0
data/test/run.rb +5 -0
data/test/test_http_server.rb +321 -0
data/tipi.gemspec +34 -0
metadata +241 -0

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+require 'bundler/setup'
+require 'tipi'
+def ws_handler(conn)
+  while (msg = conn.recv)
+    conn << "you said: #{msg}"
+  end
+end
+opts = {
+  reuse_addr:  true,
+  dont_linger: true,
+  upgrade:     {
+    websocket: Polyphony::Websocket.handler(&method(:ws_handler))
+  }
+}
+puts "pid: #{Process.pid}"
+puts 'Listening on port 1234...'
+Tipi.serve('0.0.0.0', 1234, opts) do |req|
+  req.respond("Hello world!\n")
+end

data/examples/ws_page.html ADDED

@@ -0,0 +1,34 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <title>Websocket Client</title>
+</head>
+<body>
+  <script>
+    var connect = function () {
+      var exampleSocket = new WebSocket("ws://localhost:1234");
+      exampleSocket.onopen = function (event) {
+        document.querySelector('#status').innerText = 'connected';
+        exampleSocket.send("Can you hear me?");
+      };
+      exampleSocket.onclose = function (event) {
+        console.log('onclose');
+        document.querySelector('#status').innerText = 'disconnected';
+        setTimeout(function () {
+          // exampleSocket.removeAllListeners();
+          connect();
+        }, 1000);
+      }
+      exampleSocket.onmessage = function (event) {
+        document.querySelector('#msg').innerText = event.data;
+        console.log(event.data);
+      }
+    };
+    connect();
+  </script>
+  <h1 id="status">disconnected</h1>
+  <h1 id="msg"></h1>
+</body>
+</html>

data/examples/wss_page.html ADDED

@@ -0,0 +1,34 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <title>Websocket Client</title>
+</head>
+<body>
+  <script>
+    var connect = function () {
+      var exampleSocket = new WebSocket("/");
+      exampleSocket.onopen = function (event) {
+        document.querySelector('#status').innerText = 'connected';
+        exampleSocket.send("Can you hear me?");
+      };
+      exampleSocket.onclose = function (event) {
+        console.log('onclose');
+        document.querySelector('#status').innerText = 'disconnected';
+        setTimeout(function () {
+          // exampleSocket.removeAllListeners();
+          connect();
+        }, 1000);
+      }
+      exampleSocket.onmessage = function (event) {
+        document.querySelector('#msg').innerText = event.data;
+        console.log(event.data);
+      }
+    };
+    connect();
+  </script>
+  <h1 id="status">disconnected</h1>
+  <h1 id="msg"></h1>
+</body>
+</html>

data/lib/tipi.rb ADDED

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+require 'polyphony'
+require_relative './tipi/http1_adapter'
+require_relative './tipi/http2_adapter'
+module Tipi
+  ALPN_PROTOCOLS = %w[h2 http/1.1].freeze
+  H2_PROTOCOL = 'h2'
+  class << self
+    def serve(host, port, opts = {}, &handler)
+      opts[:alpn_protocols] = ALPN_PROTOCOLS
+      server = Polyphony::Net.tcp_listen(host, port, opts)
+      accept_loop(server, opts, &handler)
+    ensure
+      server&.close
+    end
+    def listen(host, port, opts = {})
+      opts[:alpn_protocols] = ALPN_PROTOCOLS
+      Polyphony::Net.tcp_listen(host, port, opts).tap do |socket|
+        socket.define_singleton_method(:each) do |&block|
+          ::Tipi.accept_loop(socket, opts, &block)
+        end
+      end
+    end
+    def accept_loop(server, opts, &handler)
+      loop do
+        client = server.accept
+        spin { client_loop(client, opts, &handler) }
+        snooze
+      rescue OpenSSL::SSL::SSLError
+        # disregard
+      end
+    end
+    def client_loop(client, opts, &handler)
+      client.no_delay if client.respond_to?(:no_delay)
+      adapter = protocol_adapter(client, opts)
+      adapter.each(&handler)
+    ensure
+      client.close
+    end
+    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
+  end
+end

data/lib/tipi/http1_adapter.rb ADDED

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+require 'http/parser'
+require_relative './request'
+require_relative './http2_adapter'
+module Tipi
+  # HTTP1 protocol implementation
+  class HTTP1Adapter
+    # Initializes a protocol adapter instance
+    def initialize(conn, opts)
+      @conn = conn
+      @opts = opts
+      @parser = ::HTTP::Parser.new(self)
+    end
+    def each(&block)
+      @conn.read_loop do |data|
+        return if handle_incoming_data(data, &block)
+      end
+    rescue SystemCallError, IOError
+      # ignore
+    ensure
+      finalize_client_loop
+    end
+    # return [Boolean] true if client loop should stop
+    def handle_incoming_data(data, &block)
+      @parser << data
+      while (request = @requests_head)
+        return true if upgrade_connection(request.headers, &block)
+        @requests_head = request.__next__
+        block.call(request)
+        return true unless request.keep_alive?
+      end
+      nil
+    end
+    def finalize_client_loop
+      # release references to various objects
+      @requests_head = @requests_tail = nil
+      @parser = 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
+      @waiting_for_body_chunk = true
+      @next_chunk = nil
+      while !@requests_tail.complete? && (data = @conn.readpartial(8192))
+        @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 = @requests_head
+      loop do
+        data = @conn.readpartial(8192)
+        @parser << data
+        return if request.complete?
+        snooze
+      rescue EOFError
+        break
+      end
+    end
+    def protocol
+      version = @parser.http_version
+      "HTTP #{version.join('.')}"
+    end
+    def on_headers_complete(headers)
+      headers[':path'] = @parser.request_url
+      headers[':method'] = @parser.http_method
+      queue_request(Request.new(headers, self))
+    end
+    def queue_request(request)
+      if @requests_head
+        @requests_tail.__next__ = request
+        @requests_tail = request
+      else
+        @requests_head = @requests_tail = request
+      end
+    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
+    end
+    def on_message_complete
+      @waiting_for_body_chunk = nil
+      @requests_tail.complete!(@parser.keep_alive?)
+    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:
+    #
+    #     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.(@conn, 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
+    # response API
+    # 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
+    # @param headers
+    def respond(body, headers)
+      consume_request if @parsing
+      data = format_headers(headers, body)
+      if body
+        data << if @parser.http_minor == 0
+          body
+        else
+          "#{body.bytesize.to_s(16)}\r\n#{body}\r\n0\r\n\r\n"
+        end
+      end
+      @conn << data
+    end
+    DEFAULT_HEADERS_OPTS = {
+      empty_response:  false,
+      consume_request: true
+    }.freeze
+    # Sends response headers. If empty_response is truthy, 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 [void]
+    def send_headers(headers, opts = DEFAULT_HEADERS_OPTS)
+      @conn << format_headers(headers, !opts[:empty_response])
+    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 chunk [String] response body chunk
+    # @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 << "0\r\n\r\n" if done
+      @conn << data
+    end
+    # Finishes the response to the current request. If no headers were sent,
+    # default headers are sent using #send_headers.
+    # @return [void]
+    def finish
+      @conn << "0\r\n\r\n"
+    end
+    def close
+      @conn.close
+    end
+    private
+    # Formats response headers. 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)
+      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"
+      end
+    end
+    def format_status_line(body, status)
+      if !body
+        empty_status_line(status)
+      else
+        with_body_status_line(status, body)
+      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)
+      if @parser.http_minor == 0
+        +"HTTP/1.0 #{status}\r\nContent-Length: #{body.bytesize}\r\n"
+      else
+        +"HTTP/1.1 #{status}\r\nTransfer-Encoding: chunked\r\n"
+      end
+    end
+  end
+end

data/lib/tipi/http2_adapter.rb ADDED

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+require 'http/2'
+require_relative './http2_stream'
+module Tipi
+  # HTTP2 server adapter
+  class HTTP2Adapter
+    def self.upgrade_each(socket, opts, headers, &block)
+      adapter = new(socket, opts, headers)
+      adapter.each(&block)
+    end
+    def initialize(conn, opts, upgrade_headers = nil)
+      @conn = conn
+      @opts = opts
+      @upgrade_headers = upgrade_headers
+      @interface = ::HTTP2::Server.new
+      @connection_fiber = Fiber.current
+      @interface.on(:frame, &method(:send_frame))
+      @streams = {}
+    end
+    def send_frame(data)
+      @conn << data
+    rescue Exception => e
+      @connection_fiber.transfer e
+    end
+    UPGRADE_MESSAGE = <<~HTTP.gsub("\n", "\r\n")
+    HTTP/1.1 101 Switching Protocols
+    Connection: Upgrade
+    Upgrade: h2c
+    HTTP
+    def upgrade
+      @conn << UPGRADE_MESSAGE
+      settings = @upgrade_headers['HTTP2-Settings']
+      Fiber.current.schedule(nil)
+      @interface.upgrade(settings, @upgrade_headers, '')
+    ensure
+      @upgrade_headers = nil
+    end
+    # Iterates over incoming requests
+    def each(&block)
+      @interface.on(:stream) { |stream| start_stream(stream, &block) }
+      upgrade if @upgrade_headers
+      @conn.read_loop(&@interface.method(:<<))
+    rescue SystemCallError, IOError
+      # ignore
+    ensure
+      finalize_client_loop
+    end
+    def start_stream(stream, &block)
+      stream = HTTP2StreamHandler.new(stream, &block)
+      @streams[stream] = true
+    end
+    def finalize_client_loop
+      @interface = nil
+      @streams.each_key(&:stop)
+      @conn.close
+    end
+    def close
+      @conn.close
+    end
+  end
+end