From 4b08eac262b58ba770ee43529ad97c44452ff408 Mon Sep 17 00:00:00 2001 From: interp Date: Sun, 13 Apr 2003 18:27:43 +0000 Subject: [PATCH] use with-lock instead of obtain-lock/release-lock --- scheme/httpd/surflets/surflet-handler.scm | 195 +++++++++------------- 1 file changed, 83 insertions(+), 112 deletions(-) diff --git a/scheme/httpd/surflets/surflet-handler.scm b/scheme/httpd/surflets/surflet-handler.scm index 99f2c8f..155a255 100644 --- a/scheme/httpd/surflets/surflet-handler.scm +++ b/scheme/httpd/surflets/surflet-handler.scm @@ -72,19 +72,19 @@ (surflet-request-request s-req) path-string)) ((string=? (file-name-extension path-string) ".scm") - (obtain-lock *session-table-lock*) - ;; no access to session table until new session-id is saved - (let ((session-id (generate-new-table-id *session-table*)) - (lifetime (options-session-lifetime))) - (table-set! *session-table* session-id - (make-session path-string ; used to make - ; redirections to origin - (make-integer-table) ; continuation table - (make-lock) ; continuation table lock - (make-thread-safe-counter) ; continuation counter - #f ; session-data - lifetime)) - (release-lock *session-table-lock*) + (receive (session-id lifetime) + (with-lock *session-table-lock* + (let ((session-id (generate-new-table-id *session-table*)) + (lifetime (options-session-lifetime))) + (table-set! *session-table* session-id + (make-session path-string ; used for redirections + (make-integer-table) ; continuation table + (make-lock) ; continuation table lock + (make-thread-safe-counter) ; continuation counter + #f ; session-data + lifetime)) + (values session-id lifetime))) + ;; no access to session table until new session-id is saved (register-instance! session-id) (with-fatal-error-handler @@ -93,7 +93,7 @@ (delete-session! session-id) (bad-gateway-error-response s-req path-string condition)) (let ((surflet (get-surflet-rt-structure path-string surflet-path))) - (timeout-queue-register-session! session-id (+ (time) lifetime)) + (timeout-queue-register-session! session-id (+ (time) lifetime)) (reset (with-fatal-error-handler @@ -163,10 +163,8 @@ (lookup-continuation-table (lambda (session continuation-table continuation-id) (let ((continuation-table-lock (session-continuation-table-lock session))) - (obtain-lock continuation-table-lock) - (let ((result (table-ref continuation-table continuation-id))) - (release-lock continuation-table-lock) - result))))) + (with-lock continuation-table-lock + (table-ref continuation-table continuation-id)))))) (lambda (path-string surflet-path s-req) (receive (session-id continuation-id) @@ -208,10 +206,11 @@ (let ((continuations-table (session-continuation-table session)) (continuation-table-lock (session-continuation-table-lock session)) (continuation-counter (session-next-continuation-counter session))) - (obtain-lock continuation-table-lock) - (let ((continuation-id (generate-new-table-id continuations-table))) - (table-set! continuations-table continuation-id return) - (release-lock continuation-table-lock) + (let ((continuation-id + (with-lock continuation-table-lock + (let ((c-id (generate-new-table-id continuations-table))) + (table-set! continuations-table c-id return) + c-id)))) (let ((new-url (make-resume-url (session-surflet-name session) session-id continuation-counter @@ -284,10 +283,8 @@ ;; Looks up SESSION-ID in the *SESSION-TABLE* (locking) and returns ;; the SESSION record, if anby (#f otherwise). (define (session-lookup session-id) - (obtain-lock *session-table-lock*) - (let ((result (table-ref *session-table* session-id))) - (release-lock *session-table-lock*) - result)) + (with-lock *session-table-lock* + (table-ref *session-table* session-id))) ;;; SESSION-NEXT-CONTINUATION-COUNTER ;; Increases the SESSION-CONTINUATION-COUNTER in the SESSION record by @@ -300,17 +297,19 @@ ;; Deletes the session indicated by its number SESSION-ID from the ;; *SESSION-TABLE* (locking). (define (delete-session! session-id) - (obtain-lock *session-table-lock*) - ;; notify surveillance of session being alread killed (prevents + (with-lock *session-table-lock* + ;; notify surveillance of session being alread killed (prevents ;; surveillance of killing new session that has the same number by ;; accident) (let ((session (table-ref *session-table* session-id))) (if session (begin (timeout-queue-remove-session! session-id) - (table-set! *session-table* session-id #f)))) + (table-set! *session-table* session-id #f)) ;; else: somebody was faster than we - (release-lock *session-table-lock*)) + )))) + + ;;; SESSION-ADJUST-TIMEOUT! ;; Resets time-to-die of session indicated by its SESSION-ID number. @@ -358,28 +357,26 @@ (lambda (condtion decline) (release-lock *session-table-lock*) (decline)) - (obtain-lock *session-table-lock*) - ;; notify session killing - (table-walk - (lambda (session-id session) - (timeout-queue-remove-session! session-id)) - *session-table*) - (set! *session-table* (make-integer-table)) - (release-lock *session-table*))) + (with-lock *session-table-lock* + ;; notify session killing + (table-walk + (lambda (session-id session) + (timeout-queue-remove-session! session-id)) + *session-table*) + (set! *session-table* (make-integer-table))))) ;;; GET-SESSIONS ;; Returns a list of all active sessions in *SESSION-TABLE* ;; (locking). The list elements are pairs of session-id and session ;; record. (define (get-sessions) - (obtain-lock *session-table-lock*) - (let ((sessions '())) - (table-walk - (lambda (session-id session-entry) - (set! sessions (cons (cons session-id session-entry) sessions))) - *session-table*) - (release-lock *session-table-lock*) - sessions)) + (with-lock *session-table-lock* + (let ((sessions '())) + (table-walk + (lambda (session-id session-entry) + (set! sessions (cons (cons session-id session-entry) sessions))) + *session-table*) + sessions))) (define get-session session-lookup) @@ -398,14 +395,13 @@ (let ((continuation-table-lock (session-continuation-table-lock session)) (continuation-table (session-continuation-table session)) (continuations '())) - (obtain-lock continuation-table-lock) - (table-walk - (lambda (continuation-id continuation-entry) - (set! continuations (cons (cons continuation-id continuation-entry) - continuations))) - continuation-table) - (release-lock continuation-table-lock) - continuations) + (with-lock continuation-table-lock + (table-walk + (lambda (continuation-id continuation-entry) + (set! continuations (cons (cons continuation-id continuation-entry) + continuations))) + continuation-table) + continuations)) '()))) ;;; DELETE-CONTINUATION @@ -414,12 +410,11 @@ (let ((session (session-lookup session-id))) (if session (let ((continuation-table-lock (session-continuation-table-lock session))) - (obtain-lock continuation-table-lock) - (let ((continuation-table (session-continuation-table session)) - (continuations '())) - (if (table-ref continuation-table continuation-id) - (table-set! continuation-table continuation-id #f))) - (release-lock continuation-table-lock))))) + (with-lock continuation-table-lock + (let ((continuation-table (session-continuation-table session)) + (continuations '())) + (if (table-ref continuation-table continuation-id) + (table-set! continuation-table continuation-id #f)))))))) ;;; SET-SESSION-DATA!, GET-SESSION-DATA ;; Access to arbitrary data stored along with current session (no @@ -462,46 +457,29 @@ (define get-surflet-rt-structure (let ((load-surflet (lambda (full-surflet-name cached?) - ;; Want to get warnings also. - (with-fatal-handler* - (lambda (condition decline) - (if cached? (release-lock *surflet-table-lock*)) - ;; Let the others do the job. - (error condition)) - (lambda () - ;; load-config-file does not care about cwd(?) - ;; --> absolute file name needed - (load-config-file full-surflet-name) - ;; surflet-structure to load must be named "surflet" - (let ((surflet-structure (reify-structure 'surflet))) - (load-structure surflet-structure) - (if cached? - (begin - (table-set! *surflet-table* full-surflet-name - (cons surflet-structure - (file-last-mod full-surflet-name))) - ;; only now the lock may be released - (release-lock *surflet-table-lock*))) - surflet-structure)))))) + ;; load-config-file does not care about cwd(?) + ;; --> absolute file name needed + (load-config-file full-surflet-name) + ;; surflet-structure to load must be named "surflet" + (let ((surflet-structure (reify-structure 'surflet))) + (load-structure surflet-structure) + (if cached? + (table-set! *surflet-table* full-surflet-name + (cons surflet-structure + (file-last-mod full-surflet-name)))) + surflet-structure)))) (lambda (surflet-name directory) (let ((full-surflet-name (absolute-file-name surflet-name directory))) (if (options-cache-surflets?) - (begin - ;; The lock is only obtained and released, if surflets - ;; are cached. LOAD-SURFLET gets the CACHED? parameter, - ;; so nothing will happen, if in the meanwhile caching - ;; is turned off. - (obtain-lock *surflet-table-lock*) + (with-lock *surflet-table-lock* (cond ((table-ref *surflet-table* full-surflet-name) => (lambda (surflet) - (if (equal? (file-last-mod full-surflet-name) - (cdr surflet)) - (begin - (release-lock *surflet-table-lock*) - (car surflet)) - (load-surflet full-surflet-name #t)))) + (if (equal? (file-last-mod full-surflet-name) + (cdr surflet)) + (car surflet) + (load-surflet full-surflet-name #t)))) (else (load-surflet full-surflet-name #t)))) (load-surflet full-surflet-name #f)))))) @@ -509,33 +487,26 @@ ;;; GET-LOADED-SURFLETS ;; Returns list of all loaded surflets (real path strings). (define (get-loaded-surflets) - (obtain-lock *surflet-table-lock*) - (let ((loaded-surflets '())) - (table-walk - (lambda (surflet-path rt-structure) - (set! loaded-surflets (cons surflet-path loaded-surflets))) - *surflet-table*) - (release-lock *surflet-table-lock*) - loaded-surflets)) + (with-lock *surflet-table-lock* + (let ((loaded-surflets '())) + (table-walk + (lambda (surflet-path rt-structure) + (set! loaded-surflets (cons surflet-path loaded-surflets))) + *surflet-table*) + loaded-surflets))) ;;; UNLOAD-SURFLET ;; Removes SURFLET-NAME from the *SURFLET-TABLE* cache (locking). (define (unload-surflet surflet-name) - (obtain-lock *surflet-table-lock*) - (if (table-ref *surflet-table* surflet-name) - (table-set! *surflet-table* surflet-name #f)) - (release-lock *surflet-table-lock*)) + (with-lock *surflet-table-lock* + (if (table-ref *surflet-table* surflet-name) + (table-set! *surflet-table* surflet-name #f)))) ;;; RESET-SURFLET-CACHE! ;; Clears *SURFLET-TABLE* (locking). (define (reset-surflet-cache!) -; (with-fatal-handler -; (lambda (condition decline) -; (release-lock *surflet-table-lock*) -; (decline)) - (obtain-lock *surflet-table-lock*) - (set! *surflet-table* (make-string-table)) - (release-lock *surflet-table-lock*)) + (with-lock *surflet-table-lock* + (set! *surflet-table* (make-string-table)))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; INSTANCE