simon/jolt
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Remove built-in jolt.http.server (ring-janet-adapter library replaces it)

Browse source 
The HTTP server moves out of the host into the jolt-lang/ring-janet-adapter
library, which binds sockets itself via jolt.ffi and shuts down cleanly. Drop
host/chez/http-server.ss and the obsolete ffi-server-test (the FFI collect-safe
path is covered by ffi-binding-test; the server by the adapter's own CI).
This commit is contained in:
Yogthos 2026-06-22 12:19:04 -04:00
parent 01748d2b17
commit b7bd144321
4 changed files with 2 additions and 303 deletions
Download patch file Download diff file Expand all files Collapse all files

70
test/chez/ffi-server-test.ss
View file

@ -1,70 +0,0 @@
;; FFI + threading regression. Run from repo root:
;; chez --script test/chez/ffi-server-test.ss
;;
;; Covers two fixes:
;; - the HTTP server's blocking accept/recv/send are __collect_safe, so a thread
;; idle in accept() no longer pins the stop-the-world collector. With the bug,
;; a (collect) on the main thread throws "cannot collect when multiple threads
;; are active"; with the fix it succeeds while the server sits in accept().
;; - jolt.http-client temp-file paths are unique per process+thread (no clobber).
;; Plus a live request end to end (server thread wakes from accept and responds).
(import (chezscheme))
;; mirror cli.ss's load sequence through http-server.ss
(load "host/chez/rt.ss")
(set-chez-ns! "clojure.core")
(load "host/chez/seed/prelude.ss")
(load "host/chez/post-prelude.ss")
(set-chez-ns! "user")
(load "host/chez/host-contract.ss")
(load "host/chez/seed/image.ss")
(load "host/chez/compile-eval.ss")
(load "host/chez/png.ss")
(load "host/chez/http-client.ss")
(load "host/chez/http-server.ss")
(load "host/chez/loader.ss") ; defines jolt-sh-out, used by http-client
(define total 0) (define fails 0)
(define (ok name pred) (set! total (+ total 1)) (unless pred (set! fails (+ fails 1)) (printf "FAIL: ~a\n" name)))
(define port 8391)
(define run-server (var-deref "jolt.http.server" "run-server"))
(define stop-server (var-deref "jolt.http.server" "stop-server"))
(define http-get (var-deref "jolt.http-client" "get"))
(define (kw s) (keyword #f s))
(define handler (lambda (req) (jolt-hash-map (kw "status") 200 (kw "body") "hi from test")))
(define server (jolt-invoke run-server handler (jolt-hash-map (kw "port") port)))
;; let the accept thread reach accept() (sleep is collect-safe in Chez)
(sleep (make-time 'time-duration 300000000 0))
;; GC must proceed even though a thread is blocked in accept(): a stalled
;; collector throws "cannot collect when multiple threads are active".
(ok "collect not stalled by idle accept()" (guard (e (#t #f)) (collect) #t))
;; client temp paths: unique under concurrency. Exercise the private path
;; generator via reflection-free duplication of its guarantee — many threads,
;; all distinct.
(let ((seen (make-hashtable string-hash string=?)) (m (make-mutex)) (dups 0))
(define threads
(map (lambda (_) (fork-thread (lambda ()
(let loop ((i 0)) (when (< i 1000)
(let ((p (hc-tmp-path))) (with-mutex m (if (hashtable-ref seen p #f) (set! dups (+ dups 1)) (hashtable-set! seen p #t))))
(loop (+ i 1)))))))
(iota 6)))
(sleep (make-time 'time-duration 400000000 0))
(ok "http-client temp paths unique across threads" (= dups 0)))
;; live request end to end
(let* ((resp (jolt-invoke http-get (string-append "http://127.0.0.1:" (number->string port) "/")))
(status (jolt-get resp (kw "status")))
(body (jolt-get resp (kw "body"))))
(ok "live GET status 200" (eqv? 200 status))
(ok "live GET body" (and (string? body) (string=? body "hi from test"))))
(jolt-invoke stop-server server)
(printf "~a/~a passed~n" (- total fails) total)
(exit (if (zero? fails) 0 1))