tp2 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0722207c7f88a7f070a40e0257c41c557a1e59c7c3dc7768eefc9aed52fd7c04
+  data.tar.gz: 80003148244f0278b56cf4fa99f966d9d4cfc88a72b69744c8120e91c70f74e6
+SHA512:
+  metadata.gz: 1efa96a8ae2adfd2a4cd46bb0086e927cbe5c54819d68ff2051096130ecbdae89b7ff73501d7c058962bce931471961e74bcc3c53b190f07b83b5ddc6d3a36ec
+  data.tar.gz: fd111961e0c152b30cafcf22b718c541c8d977e7bf6bd0219b5a17fc6bcae55b9d95d9b2ed3d123d9711ec0111e56aeb913675c06de235da2a8853b3d08fd739

data/.gitignore

@@ -0,0 +1,56 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+# Ignore Byebug command history file.
+.byebug_history
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# Used by RuboCop. Remote config files pulled in from inherit_from directive.
+# .rubocop-https?--*

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+gemspec name: 'tp2'
+
+group :development do
+  gem 'listen',         '3.9.0'
+  gem 'minitest',       '5.25.4'
+  gem 'rake',           '13.2.1'
+  gem 'rake-compiler',  '1.2.9'
+  gem 'simplecov',      '0.22.0'
+  gem 'yard',           '0.9.37'
+end

data/Gemfile.lock

@@ -0,0 +1,64 @@
+PATH
+  remote: .
+  specs:
+    tp2 (0.1)
+      http_parser.rb (= 0.8.0)
+      qeweney (= 0.21)
+      uringmachine (= 0.5.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    docile (1.4.1)
+    escape_utils (1.3.0)
+    ffi (1.17.1-aarch64-linux-gnu)
+    ffi (1.17.1-aarch64-linux-musl)
+    ffi (1.17.1-arm-linux-gnu)
+    ffi (1.17.1-arm-linux-musl)
+    ffi (1.17.1-arm64-darwin)
+    ffi (1.17.1-x86_64-darwin)
+    ffi (1.17.1-x86_64-linux-gnu)
+    ffi (1.17.1-x86_64-linux-musl)
+    http_parser.rb (0.8.0)
+    listen (3.9.0)
+      rb-fsevent (~> 0.10, >= 0.10.3)
+      rb-inotify (~> 0.9, >= 0.9.10)
+    minitest (5.25.4)
+    qeweney (0.21)
+      escape_utils (= 1.3.0)
+    rake (13.2.1)
+    rake-compiler (1.2.9)
+      rake
+    rb-fsevent (0.11.2)
+    rb-inotify (0.11.1)
+      ffi (~> 1.0)
+    simplecov (0.22.0)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.13.1)
+    simplecov_json_formatter (0.1.4)
+    uringmachine (0.5.1)
+    yard (0.9.37)
+
+PLATFORMS
+  aarch64-linux-gnu
+  aarch64-linux-musl
+  arm-linux-gnu
+  arm-linux-musl
+  arm64-darwin
+  x86_64-darwin
+  x86_64-linux-gnu
+  x86_64-linux-musl
+
+DEPENDENCIES
+  listen (= 3.9.0)
+  minitest (= 5.25.4)
+  rake (= 13.2.1)
+  rake-compiler (= 1.2.9)
+  simplecov (= 0.22.0)
+  tp2!
+  yard (= 0.9.37)
+
+BUNDLED WITH
+   2.6.2

data/README.md

@@ -0,0 +1,5 @@
+# tp2
+
+TP2 is an experimental HTTP server based on
+[UringMachine](https://github.com/digital-fabric/uringmachine) and [Qeweney](https://github.com/digital-fabric/qeweney). 
+

data/Rakefile

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "rake/testtask"
+
+task :default => [:test]
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task :release do
+  require_relative './lib/tp2/version'
+  version = TP2::VERSION
+  
+  puts 'Building tp2...'
+  `gem build tp2.gemspec`
+
+  puts "Pushing tp2 #{version}..."
+  `gem push tp2-#{version}.gem`
+
+  puts "Cleaning up..."
+  `rm *.gem`
+end

data/TODO.md

@@ -0,0 +1 @@
+- Write some tests.

data/examples/simple.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  gem 'tp2', path: '.'
+end
+
+require 'tp2'
+
+app = ->(req) {
+  req.respond('foobar', ':status' => Qeweney::Status::TEAPOT)
+}
+
+machine = UM.new
+server = TP2::Server.new(machine, '0.0.0.0', 1234, &app)
+
+machine.spin { server.run }
+
+main = Fiber.current
+trap('SIGINT') { machine.schedule(main, nil) }
+
+puts "Running... (pid: #{Process.pid})"
+STDOUT.flush
+machine.yield # wait for termination
+puts

data/lib/tp2/http.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require 'http/parser'
+require 'qeweney'
+
+module TP2
+  # Encapsulates a HTTP/1 connection
+  class HTTP1Connection # rubocop:disable Metrics/ClassLength
+    SEND_FLAGS = UM::MSG_NOSIGNAL | UM::MSG_WAITALL
+
+    def initialize(machine, fd, bgid, &app) # rubocop:disable Naming/MethodParameterName
+      @machine = machine
+      @fd = fd
+      @bgid = bgid
+      @parser = Http::Parser.new(self)
+      @app = app
+    end
+
+    def on_headers_complete(headers) # rubocop:disable Metrics/MethodLength
+      headers = normalize_headers(headers)
+      headers[':path'] = @parser.request_url
+      headers[':method'] = @parser.http_method.downcase
+      headers[':scheme'] = get_scheme_from_headers(headers)
+      headers[':protocol'] = "http/#{@parser.http_major}.#{@parser.http_minor}"
+      @request = Qeweney::Request.new(headers, self)
+    end
+
+    def get_scheme_from_headers(headers)
+      if (proto = headers['x-forwarded-proto'])
+        proto.downcase
+      else
+        'http'
+      end
+    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 on_body(chunk)
+      @request.buffer_body_chunk(chunk)
+    end
+
+    def on_message_complete
+      @done = @request.headers[':protocol'] != 'http/1.1'
+      @app.call(@request)
+    end
+
+    def run
+      @machine.recv_each(@fd, @bgid, 0) do |buf|
+        @parser << buf
+        break if @done
+      end
+    rescue SystemCallError
+      # do nothing
+    ensure
+      @machine.close(@fd)
+    end
+
+    # response API
+
+    CRLF = "\r\n"
+    ZERO_CRLF_CRLF = "0\r\n\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 request [Qeweney::Request] HTTP request
+    # @param body [String] response body
+    # @param headers
+    def respond(_request, body, headers)
+      formatted_headers = format_headers(headers, body, false)
+      # request.tx_incr(formatted_headers.bytesize + (body ? body.bytesize : 0))
+      if body
+        buf = formatted_headers + body
+        @machine.send(@fd, buf, buf.bytesize, SEND_FLAGS)
+        # handle_write(formatted_headers + body)
+      else
+        @machine.send(@fd, formatted_headers, formatted_headers.bytesize, SEND_FLAGS)
+      end
+    end
+
+    # Sends response headers. If empty_response is truthy, the response status
+    # code will default to 204, otherwise to 200.
+    # @param request [Qeweney::Request] HTTP request
+    # @param headers [Hash] response headers
+    # @param empty_response [boolean] whether a response body will be sent
+    # @param chunked [boolean] whether to use chunked transfer encoding
+    # @return [void]
+    def send_headers(request, headers, empty_response: false, chunked: true)
+      formatted_headers = format_headers(headers, !empty_response, http1_1?(request) && chunked)
+      # request.tx_incr(formatted_headers.bytesize)
+      #
+      @machine.send(@fd, formatted_headers, formatted_headers.bytesize, SEND_FLAGS)
+    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 request [Qeweney::Request] HTTP request
+    # @param chunk [String] response body chunk
+    # @param done [boolean] whether the response is completed
+    # @return [void]
+    def send_chunk(_request, chunk, done: false)
+      data = +''
+      data << "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n" if chunk
+      data << "0\r\n\r\n" if done
+      return if data.empty?
+
+      # request.tx_incr(data.bytesize)
+      @machine.send(@fd, data, data.bytesize, SEND_FLAGS)
+    end
+
+    # Finishes the response to the current request. If no headers were sent,
+    # default headers are sent using #send_headers.
+    # @return [void]
+    def finish(_request)
+      # request.tx_incr(5)
+      @machine.send(@fd, ZERO_CRLF_CRLF, ZERO_CRLF_CRLF.bytesize, SEND_FLAGS)
+    end
+
+    def http1_1?(request)
+      request.headers[':protocol'] == 'http/1.1'
+    end
+
+    INTERNAL_HEADER_REGEXP = /^:/.freeze
+
+    # 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 body [boolean] whether a response body will be sent
+    # @param chunked [boolean] whether to use chunked transfer encoding
+    # @return [String] formatted response headers
+    def format_headers(headers, body, chunked)
+      status = headers[':status']
+      status ||= (body ? Qeweney::Status::OK : Qeweney::Status::NO_CONTENT)
+      lines = format_status_line(body, status, chunked)
+      headers.each do |k, v|
+        next if k =~ INTERNAL_HEADER_REGEXP
+
+        collect_header_lines(lines, k, v)
+      end
+      lines << CRLF
+      lines
+    end
+
+    def format_status_line(body, status, chunked)
+      if !body
+        empty_status_line(status)
+      else
+        with_body_status_line(status, body, chunked)
+      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, chunked)
+      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"
+      end
+    end
+
+    def collect_header_lines(lines, key, value)
+      if value.is_a?(Array)
+        value.inject(lines) { |_, item| lines << "#{key}: #{item}\r\n" }
+      else
+        lines << "#{key}: #{value}\r\n"
+      end
+    end
+  end
+end

data/lib/tp2/request_extensions.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+p "request_extensions"
+
+class Qeweney::Request
+  def serve_io(io, opts)
+    # TODO: implement using UM
+
+    raise NotImplementedError
+  end
+end

data/lib/tp2/server.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'tp2/http'
+require 'tp2/request_extensions'
+
+module TP2
+  class Server
+    def initialize(machine, hostname, port, &app)
+      @machine = machine
+      @hostname = hostname
+      @port = port
+      @app = app
+    end
+
+    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)
+
+      @bgid = @machine.setup_buffer_ring(4096, 1024)
+      puts "Listening on #{@hostname}:#{@port}"
+    end
+
+    def run
+      setup
+      @machine.accept_each(@server_fd) do |fd|
+        conn = HTTP1Connection.new(@machine, fd, @bgid, &@app)
+        @machine.spin(conn) { it.run }
+      end
+    end
+  end
+end

data/lib/tp2/version.rb

@@ -0,0 +1,3 @@
+module TP2
+  VERSION = '0.1'
+end

data/lib/tp2.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'uringmachine'
+require 'tp2/server'

data/tp2.gemspec

@@ -0,0 +1,25 @@
+require_relative './lib/tp2/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'tp2'
+  s.summary     = ''
+  s.version     = TP2::VERSION
+  s.licenses    = ['MIT']
+  s.author      = 'Sharon Rosner'
+  s.email       = 'sharon@noteflakes.com'
+  s.files       = `git ls-files`.split
+  s.homepage    = 'https://github.com/noteflakes/tp2'
+  s.metadata    = {
+    'homepage_uri' => 'https://github.com/noteflakes/tp2',
+    'documentation_uri' => 'https://www.rubydoc.info/gems/tp2',
+    'changelog_uri' => 'https://github.com/noteflakes/tp2/blob/master/CHANGELOG.md'
+  }
+  s.rdoc_options = ['--title', 'TP2', '--main', 'README.md']
+  s.extra_rdoc_files = ['README.md']
+  s.require_paths = ['lib']
+  s.required_ruby_version = '>= 3.4'
+
+  s.add_dependency 'http_parser.rb',  '0.8.0'
+  s.add_dependency 'uringmachine',    '0.5.1'
+  s.add_dependency 'qeweney',         '0.21'
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: tp2
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Sharon Rosner
+bindir: bin
+cert_chain: []
+date: 2025-02-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: http_parser.rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+- !ruby/object:Gem::Dependency
+  name: uringmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+- !ruby/object:Gem::Dependency
+  name: qeweney
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.21'
+email: sharon@noteflakes.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- TODO.md
+- examples/simple.rb
+- lib/tp2.rb
+- lib/tp2/http.rb
+- lib/tp2/request_extensions.rb
+- lib/tp2/server.rb
+- lib/tp2/version.rb
+- tp2.gemspec
+homepage: https://github.com/noteflakes/tp2
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/noteflakes/tp2
+  documentation_uri: https://www.rubydoc.info/gems/tp2
+  changelog_uri: https://github.com/noteflakes/tp2/blob/master/CHANGELOG.md
+rdoc_options:
+- "--title"
+- TP2
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: ''
+test_files: []