RubyGems - tipi - Versions diffs - 0.30 - Mend

tipi 0.30

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

data/examples/websocket_server.rb ADDED

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