tp2 0.6 → 0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02dcea75056239e37b8cd92705737bf8516719723b63f6610667f657b9d42667
-  data.tar.gz: 22660d26e8e6c92c84b033b12f8a095e1eb35d5273067020bb9393dc2560581f
+  metadata.gz: ed2dc84d547495b29f7f569f5898e14a29ea7114683374d10150618d6fed6ba7
+  data.tar.gz: 6cfb58517566700905799005ff089e951f3c5f728310c2c3e5f4fdb6307c3033
 SHA512:
-  metadata.gz: '0783815bf52da7c2f1cb813022f2717adaa2cd6b169923d72c5817b255a1a4d2139b46e47b0f46ff085080af4b8fcf3c5065ac2d3b29a974f7417ce13f0cd1e6'
-  data.tar.gz: f9720342b6c7a9b78b70c45fadbd5f9dc95ed7720f0c40a60716a963e935acdeb01bc8d338b5cce759b81c4b76ee6e0361e37f519f89a9fca3e03a5b5395654a
+  metadata.gz: d2785997104626457256a3dc48326b3e37783a21e2f5e8c06d20e7a2afb4443227258f50c0a33fda0e0703f280f44a95ea4b9fbc327c8d971750baef4f9af87b
+  data.tar.gz: 5540476e00ce0787c3f967c9a9621bcfd09e629ba0617c9853be04d523e9d530f113cab95afc60b67378017ecd9d9e62731762576eb13e7035c035d4fbb3e6ea

data/CHANGELOG.md

@@ -1,6 +1,14 @@
+# Version 0.7 2025-06-03
+
+- Introduce tp2 binary
+- Add support for loading tp2 apps and Rack apps
+- Add support for binding to multiple addresses
+- Show banner when running binary
+
 # Version 0.6 2025-05-05
 
 - Update UringMachine to 0.10
+- UseUM::Stream for HTTP parsing
 
 # Version 0.5.2 2025-05-05
 

data/bin/tp2

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "tp2"
+require "optparse"
+
+
+opts = {}
+
+parser = OptionParser.new do |o|
+  o.banner = "Usage: tp2 [options]"
+
+  o.on("-c", "--config CONFIG_FILE", String, "TP2 config file to use (default: app.rb)") {
+    opts[:app_type] = :tp2
+    opts[:app_location] = it
+  }
+  o.on("-r", "--rack RACK_FILE", String, "Rack config file to use (default: config.ru)") {
+    opts[:app_type] = :rack
+    opts[:app_location] = it
+  }
+  o.on("-d", "--dir PATH", String, "Static files at path") {
+    opts[:app_type] = :static
+    opts[:app_location] = it
+  }
+
+  o.on("-b", "--bind BIND", String, "Bind address (default: http://0.0.0.0:1234). You can specify this flag multiple times to bind to multiple addresses.") {
+    opts[:bind] ||= []
+    opts[:bind] << it
+  }
+
+  o.on("-h", "--help", "Show this help message") do
+    puts o
+    exit
+  end
+
+  o.on("-v", "--version", "Show version") do
+    puts "TP2 version #{TP2::VERSION}"
+    exit
+  end
+end
+
+begin
+  parser.parse!
+rescue StandardError => e
+  puts e.message
+  puts e.backtrace.join("\n")
+  exit
+end
+
+opts[:location] = ARGV.shift || '.'
+
+def check_app_file(opts, fn, type)
+  fn = File.join(opts[:location], fn)
+  return false if !File.file?(fn)
+  
+  opts[:app_type] = type
+  opts[:app_location] = File.expand_path(fn)
+end
+
+def detect_app(opts)
+  if File.file?(opts[:location])
+    case File.extname(opts[:location])
+    when '.rb'
+      opts[:app_type] = :tp2
+      opts[:app_location] = File.expand_path(opts[:location])
+    when '.ru'
+      opts[:app_type] = :rack
+      opts[:app_location] = File.expand_path(opts[:location])
+    else
+      raise "Don't know how to serve #{opts[:location]}"
+    end
+    return
+  end
+
+  if File.directory?(opts[:location])
+    return if check_app_file(opts, 'app.rb', :tp2)
+    return if check_app_file(opts, 'config.ru', :rack)
+  end
+
+  opts[:app_type] = :static
+  opts[:app_location] = Dir.pwd
+end
+
+detect_app(opts) if !opts[:app_type]
+
+puts TP2::BANNER
+TP2.run(opts)

data/examples/app.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+TP2.config(
+
+) do |req|
+  req.respond('Hello, world!')
+end

data/examples/rack.ru

@@ -0,0 +1,3 @@
+run do |env|
+  [200, {}, ["Hello World"]]
+end

data/examples/simple.rb

@@ -12,23 +12,5 @@ app = ->(req) {
   req.respond('foobar', ':status' => Qeweney::Status::TEAPOT)
 }
 
-machine = UM.new
-server = TP2::Server.new(machine, '0.0.0.0', 1234, &app)
-puts "Listening on port 1234..."
-
-server_fiber = machine.spin { server.run }
-
-sig_queue = UM::Queue.new
-trap('SIGINT') { machine.push(sig_queue, :SIGINT) }
-
-puts "Running... (pid: #{Process.pid})"
-STDOUT.flush
-
-# wait for signal
-sig = machine.shift(sig_queue)
-
-puts "Got signal (#{sig}), shutting down gracefully..."
-machine.schedule(server_fiber, UM::Terminate.new)
-machine.join(server_fiber)
-
-puts
+TP2.config(&app)
+TP2.run

data/lib/tp2/http1_adapter.rb

@@ -10,8 +10,7 @@ module TP2
     def initialize(machine, fd, &app)
       @machine = machine
       @fd = fd
-      @buffer = String.new('', capacity: 4096)
-      @sio = StringIO.new(@buffer)
+      @stream = UM::Stream.new(machine, fd)
       @app = app
     end
 
@@ -80,10 +79,6 @@ module TP2
 
     # response API
 
-    CRLF = "\r\n"
-    ZERO_CRLF_CRLF = "0\r\n\r\n"
-    CRLF_ZERO_CRLF_CRLF = "\r\n0\r\n\r\n"
-
     SEND_FLAGS = UM::MSG_NOSIGNAL | UM::MSG_WAITALL
 
     # Sends response including headers and body. Waits for the request to complete
@@ -139,13 +134,16 @@ module TP2
     # @return [void]
     def finish(_request)
       # request.tx_incr(5)
-      @machine.send(@fd, ZERO_CRLF_CRLF, ZERO_CRLF_CRLF.bytesize, SEND_FLAGS)
+      @machine.send(@fd, "0\r\n\r\n", "0\r\n\r\n".bytesize, SEND_FLAGS)
     end
 
     private
 
-    RE_REQUEST_LINE = /^([a-z]+)\s+([^\s]+)\s+(http\/[0-9\.]{1,3})/i
-    RE_HEADER_LINE = /^([a-z0-9\-]+)\:\s+(.+)/i
+    RE_REQUEST_LINE = /^([a-z]+)\s+([^\s]+)\s+(http\/[0-9\.]{1,3})/i.freeze
+    RE_HEADER_LINE = /^([a-z0-9\-]+)\:\s+(.+)/i.freeze
+    MAX_REQUEST_LINE_LEN = 1 << 14 # 16KB
+    MAX_HEADER_LINE_LEN = 1 << 10 # 1KB
+    MAX_CHUNK_SIZE_LEN = 16
 
     class ProtocolError < StandardError
     end
@@ -160,11 +158,12 @@ module TP2
     end
 
     def parse_headers
-      headers = get_request_line
+      buf = String.new(capacity: 4096)
+      headers = get_request_line(buf)
       return nil if !headers
 
       while true
-        line = get_line
+        line = @stream.get_line(buf, MAX_HEADER_LINE_LEN)
         break if line.nil? || line.empty?
 
         m = line.match(RE_HEADER_LINE)
@@ -176,18 +175,8 @@ module TP2
       headers
     end
 
-    def get_line
-      while true
-        line = @sio.gets(chomp: true)
-        return line if line
-
-        res = @machine.read(@fd, @buffer, 65536, -1)
-        return nil if res == 0
-      end
-    end
-
-    def get_request_line
-      line = get_line
+    def get_request_line(buf)
+      line = @stream.get_line(buf, MAX_REQUEST_LINE_LEN)
       return nil if !line
 
       m = line.match(RE_REQUEST_LINE)
@@ -209,48 +198,30 @@ module TP2
     end
 
     def read(len, buf = nil, raise_on_eof = true)
-      from_sio = @sio.read(len)
-      if from_sio
-        left = len - from_sio&.bytesize
-        if buf
-          buf << from_sio
-        else
-          buf = +from_sio
-        end
-      else
-        left = len
-        buf ||= +''
+      str = @stream.get_string(buf, len)
+      if !str && raise_on_eof
+        raise ProtocolError, "Missing data"
       end
 
-      while left > 0
-        res = @machine.read(@fd, buf, left, -1)
-        if res == 0
-          raise ProtocolError, "Incomplete body" if raise_on_eof
-
-          return buf
-        end
-
-
-        left -= res
-      end
-      buf
+      str
     end
 
-    def read_chunk(headers, buf)
-      chunk_size = get_line
-      return nil if !chunk_size
+    def read_chunk(headers, buffer)
+      tmp = String.new(capacity: 256)
+      chunk_size_str = @stream.get_line(tmp, MAX_CHUNK_SIZE_LEN)
+      return nil if !chunk_size_str
 
-      chunk_size = chunk_size.to_i(16)
+      chunk_size = chunk_size_str.to_i(16)
       if chunk_size == 0
         headers[':body-done-reading'] = true
-        get_line
+        @stream.get_line(tmp, 0)
         return nil
       end
 
-      chunk = read(chunk_size, buf)
-      get_line
+      chunk = @stream.get_string(nil, chunk_size)
+      @stream.get_line(tmp, 0)
 
-      chunk
+      buffer ? (buffer << chunk) : chunk
     end
 
     def http1_1?(request)
@@ -274,7 +245,7 @@ module TP2
 
         collect_header_lines(lines, k, v)
       end
-      lines << CRLF
+      lines << "\r\n"
       lines
     end
 
@@ -298,7 +269,7 @@ module TP2
       if chunked
         +"HTTP/1.1 #{status}\r\nTransfer-Encoding: chunked\r\n"
       else
-        +"HTTP/1.1 #{status}\r\nContent-Length: #{body.is_a?(String) ? body.bytesize : body.to_i}\r\n"
+        +"HTTP/1.1 #{status}\r\nContent-Length: #{body.bytesize}\r\n"
       end
     end
 

data/lib/tp2/rack_adapter.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'rack'
+
+module TP2
+  module RackAdapter
+    class << self
+      def run(&app)
+        ->(req) { respond(req, app.(env(req))) }
+      end
+
+      def load(path)
+        src = IO.read(path)
+        instance_eval(src, path, 1)
+      end
+
+      def env(request)
+        Qeweney.rack_env_from_request(request)
+      end
+
+      def respond(request, (status_code, headers, body))
+        headers[':status'] = status_code.to_s
+
+        content =
+          if body.respond_to?(:to_path)
+            File.open(body.to_path, 'rb') { |f| f.read }
+          else
+            body.first
+          end
+
+        request.respond(content, headers)
+      end
+    end
+  end
+end

data/lib/tp2/server.rb

@@ -2,22 +2,57 @@
 
 require 'tp2/http1_adapter'
 require 'tp2/request_extensions'
+require 'tp2/rack_adapter'
 
 module TP2
   class Server
     PENDING_REQUESTS_GRACE_PERIOD = 0.1
     PENDING_REQUESTS_TIMEOUT_PERIOD = 5
 
-    def initialize(machine, hostname, port, &app)
+    def self.rack_app(opts)
+      raise "Missing app location" if !opts[:app_location]
+
+      TP2::RackAdapter.load(opts[:app_location])
+    end
+
+    def self.tp2_app(opts)
+      if opts[:app_location]
+        puts "Loading app at #{opts[:app_location]}"
+        require opts[:app_location]
+
+        opts.merge!(TP2.config)
+      end
+      opts[:app]
+    end
+
+    def self.static_app(opts)
+    end
+
+
+    def initialize(machine, opts, &app)
       @machine = machine
-      @hostname = hostname
-      @port = port
-      @app = app
+      @opts = opts
+      @app = app || app_from_opts
+      @server_fds = []
+      @accept_fibers = []
     end
 
+    def app_from_opts
+      case @opts[:app_type]
+      when nil, :tp2
+        Server.tp2_app(@opts)
+      when :rack
+        Server.rack_app(@opts)
+      when :static
+        Server.static_app(@opts)
+      else
+        raise "Invalid app type #{@opts[:app_type].inspect}"
+      end
+    end
+  
     def run
       setup
-      accept_incoming
+      @machine.join(*@accept_fibers)
     rescue UM::Terminate
       graceful_shutdown
     end
@@ -25,51 +60,85 @@ module TP2
     private
 
     def setup
-      @server_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
-      @machine.setsockopt(@server_fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
-      @machine.bind(@server_fd, @hostname, @port)
-      @machine.listen(@server_fd, UM::SOMAXCONN)
-
+      bind_info = get_bind_entries
+      bind_info.each do |(host, port)|
+        fd = setup_server_socket(host, port)
+        @server_fds << fd
+        @accept_fibers << @machine.spin { accept_incoming(fd) }
+      end
+      bind_string = bind_info.map { it.join(':') }.join(", ")
+      puts "Listening on #{bind_string}"
+      
       # map fibers
-      @fiber_map = {}
+      @connection_fiber_map = {}
+    end
+
+    def get_bind_entries
+      bind = @opts[:bind]
+      case bind
+      when Array
+        bind.map { bind_info(it) }
+      when String
+        [bind_info(bind)]
+      else
+        # default
+        [['0.0.0.0', 1234]]
+      end
+    end
 
-      # puts "Listening on #{@hostname}:#{@port}"
+    def bind_info(bind_string)
+      parts = bind_string.split(':')
+      [parts[0], parts[1].to_i]
     end
 
-    def accept_incoming
-      @machine.accept_each(@server_fd) do |fd|
+    def setup_server_socket(host, port)
+      fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+      @machine.setsockopt(fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
+      @machine.setsockopt(fd, UM::SOL_SOCKET, UM::SO_REUSEPORT, true)
+      @machine.bind(fd, host, port)
+      @machine.listen(fd, UM::SOMAXCONN)
+      fd
+    end
+
+    def accept_incoming(listen_fd)
+      @machine.accept_each(listen_fd) do |fd|
         conn = HTTP1Adapter.new(@machine, fd, &@app)
         f = @machine.spin(conn) do
           it.run
         ensure
-          @fiber_map.delete(f)
+          @connection_fiber_map.delete(f)
         end
-        @fiber_map[f] = true
+        @connection_fiber_map[f] = true
       end
     end
 
+    def close_all_server_fds
+      @server_fds.each { @machine.close(it) }
+    end
+
     def graceful_shutdown
       # stop listening
-      @machine.close(@server_fd)
+      close_all_server_fds
+      @machine.snooze
 
-      return if @fiber_map.empty?
+      return if @connection_fiber_map.empty?
 
       # sleep for a bit, let requests finish
       @machine.sleep(PENDING_REQUESTS_GRACE_PERIOD)
-      return if @fiber_map.empty?
+      return if @connection_fiber_map.empty?
 
       # terminate pending fibers
-      pending = @fiber_map.keys
+      pending = @connection_fiber_map.keys
       signal = UM::Terminate.new
       pending.each { @machine.schedule(it, signal) }
 
       @machine.timeout(PENDING_REQUESTS_TIMEOUT_PERIOD, UM::Terminate) do
-        @machine.join(*@fiber_map.keys)
-      rescue UM::Terminate
+        @machine.join(*@connection_fiber_map.keys)
+    rescue UM::Terminate
         # timeout on waiting for adapters to finish running, do nothing
       end
     ensure
-      @machine.close(@server_fd)
+      @machine.close(@server_fd) rescue nil
     end
   end
 end

data/lib/tp2/version.rb

@@ -1,3 +1,3 @@
 module TP2
-  VERSION = '0.6'
+  VERSION = '0.7'
 end

data/lib/tp2.rb

@@ -1,4 +1,61 @@
 # frozen_string_literal: true
 
 require 'uringmachine'
+require 'tp2/version'
 require 'tp2/server'
+
+module TP2
+  BANNER = (
+    "\n" +
+    "         ooo\n" +
+    "       oo\n" +
+    "     o\n" +
+    "   \\|/    TP2 - a modern web server for Ruby apps\n" +
+    "   / \\       \n" +
+    "  /   \\      https://github.com/noteflakes/tp2\n" +
+    "⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺\n"
+  )
+
+  
+  class << self
+    def run(opts = nil, &app)
+      return if @in_run
+
+      opts ||= @config || {}
+      begin
+        @in_run = true
+        machine = UM.new
+        server = Server.new(machine, opts, &app)
+
+        setup_signal_handling(machine)
+
+        server.run
+      ensure
+        @in_run = false
+      end
+    end
+
+    def config(opts = nil, &app)
+      return @config if !opts && !app
+        
+      @config = opts || {}
+      @config[:app] = app if app
+    end
+
+    private
+
+    def setup_signal_handling(machine)
+      queue = UM::Queue.new
+      trap('SIGINT') { machine.push(queue, :SIGINT) }
+      machine.spin { terminate_on_signal(machine, queue, Fiber.current) }
+    end
+
+    # waits for signal from queue, then terminates given fiber
+    # to be done
+    def terminate_on_signal(machine, queue, fiber)
+      sig = machine.shift(queue)
+      puts "\nGot signal (#{sig}), shutting down gracefully..."
+      machine.schedule(fiber, UM::Terminate.new)
+    end
+  end
+end

data/test/test_http1_adapter.rb

@@ -69,13 +69,16 @@ class HTTP1AdapterTest < Minitest::Test
   end
 
   def test_pipelined_requests
-    write_http_request <<~HTTP.crlf_lines
+    msg = <<~HTTP.crlf_lines
       GET /foo HTTP/1.1
       Server: foo.com
 
       SCHMET /bar HTTP/1.1
 
+
+
     HTTP
+    write_http_request msg
 
     @adapter.run
     assert_equal 2, @reqs.size
@@ -142,7 +145,7 @@ class HTTP1AdapterTest < Minitest::Test
   end
 
   def test_pipelined_requests_with_body_chunked
-    write_http_request <<~HTTP.crlf_lines
+    msg = <<~HTTP.crlf_lines
       POST /foo HTTP/1.1
       Server: foo.com
       Transfer-Encoding: chunked
@@ -161,7 +164,10 @@ class HTTP1AdapterTest < Minitest::Test
       123456789abcdefghijklmnopqrstuv
       0
 
+
+
     HTTP
+    write_http_request(msg)
 
     @bodies = []
     @hook = ->(req) { @bodies << req.read }
@@ -197,6 +203,8 @@ class HTTP1AdapterTest < Minitest::Test
   end
 
   def test_body_to_eof
+    skip
+
     write_http_request <<~HTTP.crlf_lines
       POST /foo HTTP/1.1
       Server: foo.com

data/test/test_server.rb

@@ -2,9 +2,6 @@
 
 require_relative './helper'
 
-class String
-end
-
 class ServerTest < Minitest::Test
   def make_socket_pair
     port = 10000 + rand(30000)
@@ -28,7 +25,7 @@ class ServerTest < Minitest::Test
   def setup
     @machine = UM.new
     @port = 10000 + rand(30000)
-    @server = TP2::Server.new(@machine, '127.0.0.1', @port) { @app&.call(it) }
+    @server = TP2::Server.new(@machine, { bind: "127.0.0.1:#{@port}" }) { @app&.call(it) }
     @f_server = @machine.spin do
       @server.run
     rescue STOP
@@ -106,9 +103,17 @@ class ServerTest < Minitest::Test
   end
 
   def test_pipelined_requests_with_body
-    skip
+    # skip
 
-    write_http_request <<~HTTP.crlf_lines
+    @bodies = []
+    @reqs = []
+    @app = ->(req) {
+      @reqs << req
+      @bodies << req.read
+      req.respond("method: #{req.method}")
+    }
+
+    msg = <<~HTTP.crlf_lines
       POST /foo HTTP/1.1
       Server: foo.com
       Content-Length: 3
@@ -119,12 +124,10 @@ class ServerTest < Minitest::Test
 
       defghi
     HTTP
+    write_http_request msg
 
-    @bodies = []
-    @hook = ->(req) { @bodies << req.read }
-
-    @adapter.run
-    assert_equal 2, @reqs.size
+    read_client_side
+    assert_equal 2, @bodies.size
 
     req0 = @reqs.shift
     headers = req0.headers

data/tp2.gemspec

@@ -18,7 +18,9 @@ Gem::Specification.new do |s|
   s.extra_rdoc_files = ['README.md']
   s.require_paths = ['lib']
   s.required_ruby_version = '>= 3.4'
+  s.executables   = ['tp2']
 
-  s.add_dependency 'uringmachine',    '0.10'
+  s.add_dependency 'uringmachine',    '0.12'
   s.add_dependency 'qeweney',         '0.21'
+  s.add_dependency 'rack',            '3.1.15'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tp2
 version: !ruby/object:Gem::Version
-  version: '0.6'
+  version: '0.7'
 platform: ruby
 authors:
 - Sharon Rosner
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0.12'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0.12'
 - !ruby/object:Gem::Dependency
   name: qeweney
   requirement: !ruby/object:Gem::Requirement
@@ -37,8 +37,23 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: '0.21'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.1.15
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.1.15
 email: sharon@noteflakes.com
-executables: []
+executables:
+- tp2
 extensions: []
 extra_rdoc_files:
 - README.md
@@ -50,9 +65,13 @@ files:
 - README.md
 - Rakefile
 - TODO.md
+- bin/tp2
+- examples/app.rb
+- examples/rack.ru
 - examples/simple.rb
 - lib/tp2.rb
 - lib/tp2/http1_adapter.rb
+- lib/tp2/rack_adapter.rb
 - lib/tp2/request_extensions.rb
 - lib/tp2/server.rb
 - lib/tp2/version.rb