tep 0.11.0

data/public/hello.txt

@@ -0,0 +1 @@
+tep static file serving works.

data/public/style.css

@@ -0,0 +1,4 @@
+body { font-family: system-ui, sans-serif; margin: 2em; max-width: 50em; }
+h1 { color: #b00; border-bottom: 1px solid #ccc; }
+ul { line-height: 1.6; }
+code { background: #f0f0f0; padding: 0.1em 0.4em; border-radius: 3px; }

data/spinel-ext.json

@@ -0,0 +1,33 @@
+[
+  {
+    "name": "sphttp",
+    "placeholder": "@TEP_SPHTTP_O@",
+    "source": "lib/tep/sphttp.c",
+    "cflags": ["-O2"]
+  },
+  {
+    "name": "sqlite",
+    "placeholder": "@TEP_SQLITE_O@",
+    "source": "lib/tep/tep_sqlite.c",
+    "cflags": ["-O2"],
+    "pkg_config": "sqlite3",
+    "pkg_config_fallback": "-lsqlite3",
+    "optional": true,
+    "disabled_cflags": "-DNO_SQLITE"
+  },
+  {
+    "name": "pg",
+    "placeholder": "@TEP_PG_O@",
+    "source": "lib/tep/tep_pg.c",
+    "cflags": ["-O2"],
+    "optional": true,
+    "disabled_cflags": "-DNO_PG"
+  },
+  {
+    "name": "pg",
+    "placeholder": "@TEP_PG_CFLAGS@",
+    "pkg_config": "libpq",
+    "optional": true,
+    "disabled_cflags": "-lc"
+  }
+]

data/test/helper.rb

@@ -0,0 +1,248 @@
+# Test harness for the Sinatra compatibility checklist.
+#
+# Each test class declares one app source via `app_source <<~RB ... RB`,
+# the harness compiles it once with bin/tep (Sinatra-classic style) or
+# spinel directly (subclass style), starts the binary on a fresh port,
+# and runs N tests against the live server. Cleanup happens at_exit.
+#
+# Per-class boot keeps total wall time reasonable -- one ~1s spinel
+# compile per file, not per test.
+
+ENV["MT_NO_PLUGINS"] ||= "1"   # avoid Rails minitest plugin autoload pulling in railties
+require "minitest/autorun"
+# Force serial execution -- per-class boot expects only one thread
+# touching the class state at a time.
+Minitest.parallel_executor = Minitest::Parallel::Executor.new(1) if defined?(Minitest::Parallel::Executor)
+require "net/http"
+require "uri"
+require "socket"
+require "fileutils"
+require "tmpdir"
+
+module TepHarness
+  TEP_BIN = File.expand_path("../bin/tep", __dir__)
+  SPINEL  = ENV.fetch("SPINEL", "spinel")
+
+  @running = []
+  @port    = (ENV["TEP_TEST_PORT_BASE"] || "4900").to_i
+
+  class << self
+    attr_reader :port
+  end
+
+  def self.next_port
+    p = @port
+    @port += 1
+    p
+  end
+
+  # Compile `source` (Sinatra-classic by default) and return the bound
+  # port. Pass `workers: N` to launch the binary in prefork mode --
+  # used by tests that need to exercise cross-worker behaviour (e.g.
+  # the #128 parent-only run_end emission).
+  def self.spawn_app(source, mode: :sinatra, workers: 1)
+    tmp  = Dir.mktmpdir("tep-test")
+    src  = File.join(tmp, "app.rb")
+    File.write(src, source)
+    bin  = File.join(tmp, "app")
+    case mode
+    when :sinatra
+      out = `#{TEP_BIN} build #{src} -o #{bin} 2>&1`
+      raise "tep build failed:\n#{out}" unless $?.success?
+    when :direct
+      out = `#{SPINEL} #{src} -o #{bin} 2>&1`
+      raise "spinel failed:\n#{out}" unless $?.success?
+    else
+      raise "unknown mode: #{mode}"
+    end
+    port = next_port
+    log  = File.join(tmp, "app.log")
+    args = [bin, "-p", port.to_s]
+    args += ["-w", workers.to_s] if workers > 1
+    # Spawn the app as its own process-group leader (pgroup: true ->
+    # pgid == this pid). The server's shutdown contract is SIGTERM-to-
+    # the-pgroup (lib/tep/server.rb): in prefork mode the parent forks
+    # workers that block in accept(), and only a GROUP-wide signal
+    # reaches them. Teardown signals the group (see #reap); the group
+    # being distinct from the test runner's keeps that signal off us.
+    pid  = Process.spawn(*args, out: log, err: [:child, :out], pgroup: true)
+    wait_for_port(port, tmp: tmp, pid: pid)
+    @running << { pid: pid, tmp: tmp, log: log, port: port }
+    port
+  end
+
+  # Find the spawned record for a given bound port (used by tests
+  # that need to send signals to the process they booted, e.g.
+  # shutdown-hook tests asserting on run_end emission).
+  def self.find_by_port(port)
+    @running.find { |s| s[:port] == port }
+  end
+
+  # SIGTERM the process bound to `port` + wait for exit. Removes the
+  # entry from @running so kill_all's at_exit doesn't double-reap.
+  def self.terminate(port, timeout: 5.0)
+    s = find_by_port(port)
+    return unless s
+    reap(s[:pid], timeout: timeout)
+    @running.delete(s)
+  end
+
+  def self.kill_all
+    @running.each do |s|
+      reap(s[:pid])
+      FileUtils.rm_rf(s[:tmp])
+    end
+    @running.clear
+  end
+
+  # Gracefully stop a spawned app and wait for it to exit, BOUNDED.
+  # Signals the whole process group (negative pid) so prefork workers
+  # blocked in accept() actually receive the signal -- a bare
+  # `Process.kill("TERM", pid)` hits only the parent, leaving workers
+  # wedged and the parent stuck in wait_any, which used to hang the
+  # at_exit reap forever (test process in do_wait). Escalates to
+  # SIGKILL if the graceful stop doesn't land in time, so no
+  # misbehaving server can stall the suite.
+  def self.reap(pid, timeout: 5.0)
+    signal_group(pid, "TERM")
+    return if wait_exit(pid, timeout)
+    signal_group(pid, "KILL")
+    wait_exit(pid, 2.0)
+  end
+
+  # Signal `pid`'s process group; fall back to the bare pid if the
+  # group is already gone. Swallows ESRCH (already dead).
+  def self.signal_group(pid, sig)
+    begin
+      Process.kill(sig, -pid)
+    rescue Errno::ESRCH
+      begin
+        Process.kill(sig, pid)
+      rescue Errno::ESRCH
+      end
+    end
+  end
+
+  # Poll-wait for `pid` to exit, up to `timeout` seconds. Returns true
+  # if it was reaped (or is already gone), false on timeout.
+  def self.wait_exit(pid, timeout)
+    deadline = Time.now + timeout
+    loop do
+      begin
+        got, _ = Process.waitpid2(pid, Process::WNOHANG)
+        return true if got
+      rescue Errno::ECHILD
+        return true
+      end
+      return false if Time.now > deadline
+      sleep 0.02
+    end
+  end
+
+  def self.wait_for_port(port, timeout: 5.0, tmp: nil, pid: nil)
+    deadline = Time.now + timeout
+    loop do
+      begin
+        TCPSocket.new("127.0.0.1", port).close
+        return
+      rescue Errno::ECONNREFUSED
+        sleep 0.05
+        if Time.now > deadline
+          msg = "tep server failed to bind :#{port}"
+          if tmp
+            log = File.join(tmp, "app.log")
+            if File.exist?(log)
+              msg += "\n--- app log (#{log}) ---\n" + File.read(log)
+            end
+          end
+          alive = pid && (Process.kill(0, pid) rescue false)
+          msg += "\n--- pid #{pid} alive=#{!!alive}" if pid
+          raise msg
+        end
+      end
+    end
+  end
+end
+
+# Tear down spawned apps AFTER Minitest finishes. A bare `at_exit`
+# would fire BEFORE the test runner (Ruby at_exit is LIFO and
+# require "minitest/autorun" registers its at_exit first), so
+# @running would be empty and apps would leak as orphans to PID 1
+# when ruby exits. Minitest.after_run fires post-suite, with the
+# @running list populated. See #117 for the original investigation.
+Minitest.after_run { TepHarness.kill_all }
+
+# Kill any zombie tep test processes leaking from previous runs.
+# Skip on hosts that don't ship `pgrep` (some slim containers don't).
+if system("which pgrep >/dev/null 2>&1")
+  `pgrep -f tep-test 2>/dev/null`.split.each do |pid|
+    Process.kill("TERM", pid.to_i) rescue nil
+  end
+end
+
+class TepTest < Minitest::Test
+  # Class-level: capture `app_source` and `app_mode`. Boot lazily on
+  # first `setup`. Per-class @port memoises the bound port.
+  def self.app_source(src = nil, mode: :sinatra)
+    if src
+      @app_source = src
+      @app_mode   = mode
+    else
+      [@app_source, @app_mode]
+    end
+  end
+
+  # Number of prefork workers to launch the test binary with.
+  # Defaults to 1 (the existing single-process shape). Tests that
+  # need to exercise multi-worker behaviour (e.g. #128 run_end
+  # aggregation across workers) call `workers 2` at class scope.
+  def self.workers(n = nil)
+    if n
+      @workers = n
+    else
+      @workers || 1
+    end
+  end
+
+  @@boot_lock = Mutex.new
+
+  def self.boot!
+    @@boot_lock.synchronize do
+      return @port if @port
+      src, mode = app_source
+      raise "#{name}: app_source not set" unless src
+      @port = TepHarness.spawn_app(src, mode: mode, workers: workers)
+    end
+  end
+
+  def setup
+    @port = self.class.boot!
+  end
+
+  # ---- HTTP helpers ----
+  def get(path, headers = {})         req(:get,    path, nil, headers); end
+  def post(path, body = "", headers = {}) req(:post,   path, body, headers); end
+  def put(path, body = "", headers = {})  req(:put,    path, body, headers); end
+  def patch(path, body = "", headers = {}) req(:patch,  path, body, headers); end
+  def delete(path, headers = {})      req(:delete, path, nil, headers); end
+  def head(path, headers = {})        req(:head,   path, nil, headers); end
+
+  def req(method, path, body, headers)
+    uri = URI("http://127.0.0.1:#{@port}#{path}")
+    klass = {
+      get:     Net::HTTP::Get,
+      post:    Net::HTTP::Post,
+      put:     Net::HTTP::Put,
+      patch:   Net::HTTP::Patch,
+      delete:  Net::HTTP::Delete,
+      head:    Net::HTTP::Head,
+      options: Net::HTTP::Options,
+    }.fetch(method)
+    Net::HTTP.start(uri.host, uri.port, read_timeout: 3) do |http|
+      r = klass.new(uri)
+      r.body = body if body && %i[post put patch].include?(method)
+      headers.each { |k, v| r[k] = v }
+      http.request(r)
+    end
+  end
+end

data/test/real_world/01_simple.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby -I ../lib -I lib
+# frozen_string_literal: true
+
+require 'sinatra'
+get('/') { 'this is a simple app' }

data/test/real_world/02_lifecycle.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby -I ../lib -I lib
+# frozen_string_literal: true
+
+require 'sinatra'
+
+get('/') do
+  'This shows how lifecycle events work'
+end
+
+on_start do
+  puts "=============="
+  puts "  Booting up"
+  puts "=============="
+end
+
+on_stop do
+  puts "================="
+  puts "  Shutting down"
+  puts "================="
+end

data/test/real_world/03_chat.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby -I ../lib -I lib
+# frozen_string_literal: true
+
+# This example does *not* work properly with WEBrick or other
+# servers that buffer output. To shut down the server, close any
+# open browser tabs that are connected to the chat server.
+
+require 'sinatra'
+set :server, :puma
+connections = Set.new
+
+get '/' do
+  halt erb(:login) unless params[:user]
+  erb :chat, locals: { user: params[:user].gsub(/\W/, '') }
+end
+
+get '/stream', provides: 'text/event-stream' do
+  stream :keep_open do |out|
+    if connections.add?(out)
+      out.callback { connections.delete(out) }
+    end
+    out << "heartbeat:\n"
+    sleep 1
+  rescue
+    out.close
+  end
+end
+
+post '/' do
+  connections.each do |out|
+    out << "data: #{params[:msg]}\n\n"
+  rescue
+    out.close
+  end
+  204 # response without entity body
+end
+
+__END__
+
+@@ layout
+<html>
+  <head>
+    <title>Super Simple Chat with Sinatra</title>
+    <meta charset="utf-8" />
+    <script src="http://ajax.googleapis.com/ajax/libs/jquery/1/jquery.min.js"></script>
+  </head>
+  <body><%= yield %></body>
+</html>
+
+@@ login
+<form action="/">
+  <label for='user'>User Name:</label>
+  <input name="user" value="" />
+  <input type="submit" value="GO!" />
+</form>
+
+@@ chat
+<pre id='chat'></pre>
+<form>
+  <input id='msg' placeholder='type message here...' />
+</form>
+
+<script>
+  // reading
+  var es = new EventSource('/stream');
+  es.onmessage = function(e) { $('#chat').append(e.data + "\n") };
+
+  // writing
+  $("form").on('submit',function(e) {
+    $.post('/', {msg: "<%= user %>: " + $('#msg').val()});
+    $('#msg').val(''); $('#msg').focus();
+    e.preventDefault();
+  });
+</script>
+

data/test/real_world/04_health_api.rb

@@ -0,0 +1,25 @@
+# Common pattern: tiny health/version JSON API. Exercises content_type,
+# multiple routes, no params, no body parsing.
+require 'sinatra'
+
+VERSION = '1.4.2'
+
+before do
+  content_type 'application/json'
+end
+
+get '/healthz' do
+  '{"status":"ok"}'
+end
+
+get '/version' do
+  '{"version":"' + VERSION + '"}'
+end
+
+get '/' do
+  '{"endpoints":["/healthz","/version"]}'
+end
+
+not_found do
+  '{"error":"not found","path":"' + request.path + '"}'
+end

data/test/real_world/05_todo_api.rb

@@ -0,0 +1,57 @@
+# In-memory todo list. Exercises GET / POST / DELETE, path params,
+# top-level mutable state, and JSON responses.
+require 'sinatra'
+
+# Two parallel arrays as the store. Spinel won't let us push procs
+# into a hash, but plain typed arrays are first-class. Seed-and-clear
+# so spinel infers the element type (`[]` defaults to int_array).
+$todos_id   = [0]
+$todos_id.delete_at(0)
+$todos_text = [""]
+$todos_text.delete_at(0)
+$next_id    = 1
+
+before do
+  content_type 'application/json'
+end
+
+get '/todos' do
+  out = '['
+  i = 0
+  while i < $todos_id.length
+    out += '{"id":' + $todos_id[i].to_s + ',"text":"' + $todos_text[i] + '"}'
+    out += ',' if i + 1 < $todos_id.length
+    i += 1
+  end
+  out + ']'
+end
+
+post '/todos' do
+  text = params[:text]
+  $todos_id.push($next_id)
+  $todos_text.push(text)
+  $next_id += 1
+  '{"id":' + ($next_id - 1).to_s + ',"text":"' + text + '"}'
+end
+
+delete '/todos/:id' do
+  target = params[:id].to_i
+  i = 0
+  found = false
+  while i < $todos_id.length
+    if $todos_id[i] == target
+      $todos_id.delete_at(i)
+      $todos_text.delete_at(i)
+      found = true
+      i = $todos_id.length
+    else
+      i += 1
+    end
+  end
+  if found
+    '{"deleted":' + target.to_s + '}'
+  else
+    status 404
+    '{"error":"not found"}'
+  end
+end

data/test/real_world/06_basic_auth.rb

@@ -0,0 +1,25 @@
+# Before-filter auth: every /admin/* request must carry a token. Tests
+# the halt-from-before-filter pattern.
+require 'sinatra'
+
+TOKEN = 'sekret-42'
+
+before do
+  if request.path.start_with?('/admin')
+    if request.headers['x-token'] != TOKEN
+      halt 401, 'forbidden'
+    end
+  end
+end
+
+get '/' do
+  'public homepage'
+end
+
+get '/admin/dashboard' do
+  'admin: ok'
+end
+
+get '/admin/users' do
+  'admin: users'
+end