275 lines
12 KiB
Scheme
275 lines
12 KiB
Scheme
(module status mzscheme
|
|
(require (lib "file.ss")
|
|
(lib "list.ss")
|
|
(lib "string.ss")
|
|
(lib "date.ss")
|
|
(lib "servlet.ss" "web-server")
|
|
(lib "response-structs.ss" "web-server")
|
|
(lib "uri-codec.ss" "net")
|
|
(lib "md5.ss" "handin-server" "private")
|
|
(lib "logger.ss" "handin-server" "private")
|
|
(lib "config.ss" "handin-server" "private"))
|
|
|
|
(define active-dir (build-path server-dir "active"))
|
|
(define inactive-dir (build-path server-dir "inactive"))
|
|
(define active/inactive-dirs (list active-dir inactive-dir))
|
|
|
|
(define master-password (get-config 'master-password))
|
|
|
|
(define get-user-data
|
|
(let ([users-file (build-path server-dir "users.ss")])
|
|
(lambda (user)
|
|
(get-preference (string->symbol user) (lambda () #f) #f users-file))))
|
|
|
|
(define (clean-str s)
|
|
(regexp-replace #rx" *$" (regexp-replace #rx"^ *" s "") ""))
|
|
|
|
(define (aget alist key)
|
|
(cond [(assq key alist) => cdr] [else #f]))
|
|
|
|
(define (make-page title . body)
|
|
`(html (head (title ,title))
|
|
(body ([bgcolor "white"]) (h1 ((align "center")) ,title) ,@body)))
|
|
|
|
(define handin-prefix-re
|
|
;; a regexp that turns a full path to a server-dir relative path
|
|
(regexp
|
|
(string-append
|
|
"^" (regexp-quote
|
|
(regexp-replace
|
|
#rx"/?$"
|
|
(if (path? server-dir) (path->string server-dir) server-dir)
|
|
"/")))))
|
|
|
|
(define (make-k k tag)
|
|
(format "~a~atag=~a" k (if (regexp-match #rx"^[^#]*[?]" k) "&" "?")
|
|
(uri-encode (regexp-replace handin-prefix-re
|
|
(if (path? tag) (path->string tag) tag)
|
|
""))))
|
|
|
|
(define (select-k request)
|
|
(aget (request-bindings request) 'tag))
|
|
|
|
;; `look-for' can be a username as a string (will find "bar+foo" for "foo"),
|
|
;; or a regexp that should match the whole directory name (used with
|
|
;; "^solution" below)
|
|
(define (find-hi-entry hi look-for)
|
|
(define (find-submission top)
|
|
(let ([dir (build-path top hi)])
|
|
(and (directory-exists? dir)
|
|
(ormap
|
|
(lambda (d)
|
|
(let ([d (path->string d)])
|
|
(and (cond [(string? look-for)
|
|
(member look-for (regexp-split #rx" *[+] *" d))]
|
|
[(regexp? look-for) (regexp-match look-for d)]
|
|
[else (error 'find-hi-entry
|
|
"internal error: ~e" look-for)])
|
|
(build-path dir d))))
|
|
(directory-list dir)))))
|
|
(ormap find-submission active/inactive-dirs))
|
|
|
|
(define (handin-link k user hi)
|
|
(let* ([dir (find-hi-entry hi user)]
|
|
[l (and dir (with-handlers ([exn:fail? (lambda (x) null)])
|
|
(parameterize ([current-directory dir])
|
|
(sort (filter (lambda (f)
|
|
(and (not (equal? f "grade"))
|
|
(file-exists? f)))
|
|
(map path->string (directory-list)))
|
|
string<?))))])
|
|
(if (pair? l)
|
|
(cdr (apply append
|
|
(map (lambda (i) `((br) ,i))
|
|
(map (lambda (f)
|
|
(let ([hi (build-path dir f)])
|
|
`(font ()
|
|
(a ([href ,(make-k k hi)]) ,f)
|
|
" ("
|
|
,(date->string
|
|
(seconds->date
|
|
(file-or-directory-modify-seconds hi))
|
|
#t)
|
|
")")))
|
|
l))))
|
|
(list (format "No handins accepted so far for user ~s, assignment ~s"
|
|
user hi)))))
|
|
|
|
(define (solution-link k hi)
|
|
(let ([soln (find-hi-entry hi #rx"^solution")]
|
|
[none `((i "---"))])
|
|
(cond [(not soln) none]
|
|
[(file-exists? soln)
|
|
`((a ((href ,(make-k k soln))) "Solution"))]
|
|
[(directory-exists? soln)
|
|
(parameterize ([current-directory soln])
|
|
(let ([files (sort (map path->string
|
|
(filter file-exists? (directory-list)))
|
|
string<?)])
|
|
(if (null? files)
|
|
none
|
|
(apply append
|
|
(map (lambda (f)
|
|
`((a ([href ,(make-k k (build-path soln f))])
|
|
(tt ,f))
|
|
(br)))
|
|
files)))))]
|
|
[else none])))
|
|
|
|
(define (handin-grade user hi)
|
|
(let* ([dir (find-hi-entry hi user)]
|
|
[grade (and dir
|
|
(let ([filename (build-path dir "grade")])
|
|
(and (file-exists? filename)
|
|
(with-input-from-file filename
|
|
(lambda ()
|
|
(read-string (file-size filename)))))))])
|
|
(or grade "--")))
|
|
|
|
(define (one-status-page user for-handin)
|
|
(let* ([next (send/suspend
|
|
(lambda (k)
|
|
(make-page (format "User: ~a, Handin: ~a" user for-handin)
|
|
`(p ,@(handin-link k user for-handin))
|
|
`(p "Grade: " ,(handin-grade user for-handin))
|
|
`(p ,@(solution-link k for-handin))
|
|
`(p (a ([href ,(make-k k "allofthem")])
|
|
,(format "All handins for ~a" user))))))]
|
|
[tag (select-k next)])
|
|
(if (string=? tag "allofthem")
|
|
(all-status-page user)
|
|
(download user tag))))
|
|
|
|
(define re:base #rx"^([a-zA-Z]*)([0-9]+)")
|
|
(define (all-status-page user)
|
|
(let* ([l (sort
|
|
(map path->string
|
|
(append (directory-list active-dir)
|
|
(with-handlers ([exn:fail? (lambda (x) null)])
|
|
(directory-list inactive-dir))))
|
|
(lambda (a b)
|
|
(let ([am (regexp-match re:base a)]
|
|
[bm (regexp-match re:base b)])
|
|
(if (and am bm
|
|
(string=? (cadr am) (cadr bm)))
|
|
(or (< (string->number (caddr am))
|
|
(string->number (caddr bm)))
|
|
(string<? a b))
|
|
(string<? a b)))))]
|
|
[next
|
|
(send/suspend
|
|
(lambda (k)
|
|
(define (header text)
|
|
`(td ((bgcolor "#f0f0f0")) (big (strong ,text))))
|
|
(make-page
|
|
(format "All Handins for ~a" user)
|
|
`(table ([bgcolor "#ddddff"] [cellpadding "6"] [align "center"])
|
|
(tr () ,@(map header '(nbsp "Files" "Grade" "Solution")))
|
|
,@(map (lambda (hi)
|
|
`(tr ([valign "top"])
|
|
,(header hi)
|
|
(td ([bgcolor "white"]) ,@(handin-link k user hi))
|
|
(td ([bgcolor "white"] (align "right")) ,(handin-grade user hi))
|
|
(td ([bgcolor "white"]) ,@(solution-link k hi))))
|
|
l)))))]
|
|
[tag (select-k next)])
|
|
(download user tag)))
|
|
|
|
(define (download who tag)
|
|
(define (check path elts)
|
|
(let loop ([path path] [elts (reverse elts)])
|
|
(let*-values ([(base name dir?) (split-path path)]
|
|
[(name) (path->string name)]
|
|
[(check) (and (pair? elts) (car elts))])
|
|
(if (null? elts)
|
|
;; must be rooted in active/inactive (why build-path instead of
|
|
;; using `path'? -- because path will have a trailing slash)
|
|
(member (build-path base name) active/inactive-dirs)
|
|
(and (cond [(eq? '* check) #t]
|
|
[(regexp? check) (regexp-match check name)]
|
|
[(string? check)
|
|
(or (equal? name check)
|
|
(member check (regexp-split #rx" *[+] *" name)))]
|
|
[else #f])
|
|
(loop base (cdr elts)))))))
|
|
(define file (build-path server-dir tag))
|
|
(with-handlers ([exn:fail? (lambda (exn)
|
|
(make-page "Error" "Illegal file access"))])
|
|
;; Make sure the user is allowed to read the requested file:
|
|
(or (check file `(* ,who *))
|
|
(check file `(* #rx"^solution"))
|
|
(check file `(* #rx"^solution" *))
|
|
(error "Boom!"))
|
|
(log-line "Status file-get: ~s ~a" who file)
|
|
;; Return the downloaded file
|
|
(let* ([data (with-input-from-file file
|
|
(lambda () (read-bytes (file-size file))))]
|
|
[html? (regexp-match #rx"[.]html?$" (string-foldcase tag))]
|
|
[wxme? (regexp-match #rx#"^WXME" data)])
|
|
(make-response/full 200 "Okay" (current-seconds)
|
|
(cond [html? #"text/html"]
|
|
[wxme? #"application/data"]
|
|
[else #"text/plain"])
|
|
`([Content-Length . ,(number->string (bytes-length data))]
|
|
[Content-Disposition
|
|
. ,(format "~a; filename=~s"
|
|
(if wxme? "attachment" "inline")
|
|
(let-values ([(base name dir?) (split-path file)])
|
|
(path->string name)))])
|
|
(list data)))))
|
|
|
|
(define (status-page user for-handin)
|
|
(log-line "Status access: ~s" user)
|
|
(if for-handin
|
|
(one-status-page user for-handin)
|
|
(all-status-page user)))
|
|
|
|
(define (login-page status for-handin errmsg)
|
|
(let* ([request
|
|
(send/suspend
|
|
(lambda (k)
|
|
(make-page
|
|
"Handin Status Login"
|
|
`(form ([action ,k] [method "post"])
|
|
(table ([align "center"])
|
|
(tr (td ([colspan "2"] [align "center"])
|
|
(font ([color "red"]) ,(or errmsg 'nbsp))))
|
|
(tr (td "Username")
|
|
(td (input ([type "text"] [name "user"] [size "20"]
|
|
[value ""]))))
|
|
(tr (td nbsp))
|
|
(tr (td "Password")
|
|
(td (input ([type "password"] [name "passwd"]
|
|
[size "20"] [value ""]))))
|
|
(tr (td ([colspan "2"] [align "center"])
|
|
(input ([type "submit"] [name "post"]
|
|
[value "Login"])))))))))]
|
|
[user (clean-str (aget (request-bindings request) 'user))]
|
|
[passwd (aget (request-bindings request) 'passwd)]
|
|
[user-data (get-user-data user)])
|
|
(cond [(and user-data
|
|
(string? passwd)
|
|
(let ([pw (md5 passwd)])
|
|
(or (equal? pw (car user-data))
|
|
(equal? pw master-password))))
|
|
(status-page user for-handin)]
|
|
[else (login-page status for-handin "Bad username or password")])))
|
|
|
|
(define web-counter
|
|
(let ([sema (make-semaphore 1)]
|
|
[count 0])
|
|
(lambda ()
|
|
(dynamic-wind
|
|
(lambda () (semaphore-wait sema))
|
|
(lambda () (set! count (add1 count)) (format "w~a" count))
|
|
(lambda () (semaphore-post sema))))))
|
|
|
|
(define (start initial-request)
|
|
(parameterize ([current-session (web-counter)])
|
|
(login-page null (aget (request-bindings initial-request) 'handin) #f)))
|
|
|
|
(provide interface-version timeout start)
|
|
(define interface-version 'v1)
|
|
(define timeout 180)
|
|
)
|