sunet/scheme/httpd/surflets/packages.scm

630 lines
17 KiB
Scheme
Raw Normal View History

2003-01-19 11:57:27 -05:00
;; Structures and interfaces for surflets.
2002-09-13 03:21:19 -04:00
;;; Copyright 2002, 2003 Andreas Bernauer
;;; Copyright 2002 Martin Gasbichler
2002-09-13 03:21:19 -04:00
;;; NOTE: SSAX/lib/packages.scm must be loaded before you can use this
;;; downloadable from
;;; http://sourceforge.net/project/showfiles.php?group_id=30687 (take
;;; the r5rs compliant version (ssax-sr5rs-plt200-4.9.tar.gz); and
;;; patch string->goodhtml in packages.scm to string->goodHTML)
2002-09-13 03:21:19 -04:00
;;; Interfaces
;; Surflet Handler
2003-01-19 11:57:27 -05:00
(define-interface surflet-handler-interface
(export surflet-handler))
2002-09-13 03:21:19 -04:00
;; Responses from SUrflets
(define-interface surflet-handler/responses-interface
(export make-surflet-response
surflet-response?
surflet-response-status
surflet-response-content-type
surflet-response-headers
surflet-response-data))
;; SUrflet-requests as expected from the surflet handler
(define-interface surflet-handler/requests-interface
(export make-surflet-request ;FIMXE? unusable for user
surflet-request?
surflet-request-request
surflet-request-input-port
surflet-request-method
surflet-request-uri
surflet-request-url
surflet-request-version
surflet-request-headers
surflet-request-socket))
(define-interface surflets/error-interface
(export send-error ;send error response
(status-code :syntax))) ;from httpd-responses
;; Use for SUrflets
(define-interface surflet-handler/primitives-interface
(compound-interface
surflet-handler/responses-interface
surflet-handler/requests-interface
surflets/error-interface
(export send/suspend ;send and suspend
send/finish ;send and finish
send ;just send (no finish, no suspend)
)))
2002-09-13 03:21:19 -04:00
;; Send HTML-Strings (for advanced user)
(define-interface surflets/send-html-string-interface
(export send-html-string/suspend
send-html-string/finish
send-html-string))
;; Extensions/Exports to/from Olegs SSAX library
(define-interface surflets/sxml-interface
(export display-low-level-sxml
sxml->string
sxml->string/internal
sxml-attribute?
default-rule
text-rule
attribute-rule))
;; SUrflets' extensions to SXML
(define-interface surflets/surflet-sxml-interface
(export surflet-sxml->low-level-sxml
surflet-sxml-rules
surflet-form-rule
default-rules
plain-html-rule
url-rule))
;; Use for advanced users: make your own conversion rules.
(define-interface surflets/my-sxml-interface
(compound-interface
surflets/send-html-string-interface
surflets/sxml-interface
surflets/surflet-sxml-interface))
(define-interface surflets/continuations-interface
(export get-continuations
delete-continuation!))
;; Access to session-id and continuation-id
(define-interface surflets/ids-interface
(export my-session-id
my-continuation-id
my-ids
instance-session-id))
(define-interface surflets/session-data-interface
(export get-session-data
set-session-data!))
;; Use for advanced users: access to your sessions and continuations
;; and continuations (currently you get access to all sessions; this
;; should and will be restricted in the future)
(define-interface surflets/my-sessions-interface
(compound-interface
surflets/ids-interface
surflets/continuations-interface
surflets/session-data-interface
(export get-session
;; That would be too much:
;; get-sessions
delete-session!
instance-session-id
session-adjust-timeout!
adjust-timeout!
session-alive?
session-surflet-name
options-session-lifetime
options-cache-surflets?)))
(define-interface surflets/sessions-interface
(compound-interface
surflets/session-data-interface
(export get-session
get-sessions
delete-session!
instance-session-id
session-adjust-timeout!
adjust-timeout!
session-alive?
session-surflet-name
;; FIXME: This is too much and should be restricted:
session-memo
session-continuation-table
session-continuation-table-lock
session-continuation-counter)))
(define-interface surflet-handler/surflets-interface
(export get-loaded-surflets
unload-surflet))
(define-interface surflet-handler/options-interface
(export options-session-lifetime
options-cache-surflets?
set-options-session-lifetime!
set-options-cache-surflets?!))
(define-interface surflet-handler/resume-url-interface
(export resume-url?
resume-url-ids
resume-url-session-id
resume-url-continuation-id))
;; Use for adminstration of the Surflet Handler
(define-interface surflet-handler/admin-interface
(compound-interface
surflet-handler/surflets-interface
surflets/sessions-interface
surflets/continuations-interface
surflet-handler/resume-url-interface
surflet-handler/options-interface
))
;; THE interface that SUrflets use.
2003-01-19 11:57:27 -05:00
(define-interface surflet-interface
(export main)) ; MAIN gets one parameter, the REQUEST
;; Simple Surflet API as known from PLT
(define-interface simple-surflet-api-interface
(export single-query
queries
form-query
inform
final-page
make-password
make-number
make-boolean
make-radio
make-yes-no
extract/single
extract))
;; shift-reset
(define-interface shift-reset-interface
(export (reset :syntax)
(shift :syntax)))
;; For memory profiling
(define-interface profiling-interface
(export profile-space
profile-result
profile-results
write-gnuplot-data-file
space-info-pair space-info-symbol
space-info-vector space-info-closure
space-info-location space-info-cell
space-info-channel space-info-port
space-info-ratnum space-info-record
space-info-continuation space-info-extended-number
space-info-template space-info-weak-pointer
space-info-shared-binding space-info-unused-d-header1
space-info-unused-d-header2 space-info-string
space-info-byte-vector space-info-double
space-info-bignum space-info-total
set-space-info-pair! set-space-info-symbol!
set-space-info-vector! set-space-info-closure!
set-space-info-location! set-space-info-cell!
set-space-info-channel! set-space-info-port!
set-space-info-ratnum! set-space-info-record!
set-space-info-continuation! set-space-info-extended-number!
set-space-info-template! set-space-info-weak-pointer!
set-space-info-shared-binding! set-space-info-unused-d-header1!
set-space-info-unused-d-header2! set-space-info-string!
set-space-info-byte-vector! set-space-info-double!
set-space-info-bignum! set-space-info-total!
pure-count pure-bytes
impure-count impure-bytes
total-count total-bytes
))
;; Handling every condition
(define-interface handle-fatal-interface
(export with-fatal-handler*
(with-fatal-handler :syntax)))
;; Thread-safe counter
(define-interface thread-safe-counter-interface
(export make-thread-safe-counter
thread-safe-counter-value
thread-safe-counter-next!
thread-safe-counter?))
;; These two are from Martin Gasbichler:
(define-interface rt-module-language-interface
(export ((lambda-interface
with-names-from-rt-structure)
:syntax)
reify-structure
load-structure
load-config-file
rt-structure-binding))
(define-interface rt-modules-interface
(export interface-value-names
reify-structure
load-config-file
rt-structure-binding
load-structure))
;; With the help of TYPED-OPTIONALS you can define a function
;; like (make-submit-button [string] args)
(define-interface typed-optionals-interface
(export typed-optionals
(optionals :syntax)))
;; Input-fields as Scheme objects
(define-interface surflets/input-fields-interface
(export generate-input-field-name
make-input-field
make-higher-input-field
make-text-input-field
make-hidden-input-field
make-password-input-field
make-number-input-field
make-textarea-input-field
make-select-input-field
make-checkbox-input-field
make-radio-input-fields
make-submit-button
make-reset-button
make-image-button
input-field-value
raw-input-field-value
input-field-binding
input-field?))
;;; This is for surflets/surflet-sxml only:
(define-interface surflets/input-fields/internal-interface
(export *input-field-trigger*
input-field-html-tree))
;; Some utilities
(define-interface surflets/utilities-interface
(export form-query-list
rev-append
make-callback
generate-unique-name))
;; Intelligent Addresses
(define-interface surflets/addresses-interface
(export make-address
make-annotated-address
real-address-name
real-address-annotated?))
;; Returned-via (dispatcher for input-fields and intelligent
;; addresses)
(define-interface surflets/returned-via-interface
(export returned-via
returned-via?
(case-returned-via :syntax)))
;; Outdater denies access to outdated object
(define-interface surflets/outdaters-interface
(export make-outdater
(if-outdated :syntax)
show-outdated))
;; Access to form bindings in URL
(define-interface surflets/bindings-interface
(export get-bindings
get-content-length
extract-bindings
extract-single-binding))
;; HTML-Extensions to send/suspend et al. (for basic user)
(define-interface surflets/send-html-interface
(export send-html/suspend
send-html/finish
send-html))
;; Helping functions for surflets (for basic user)
(define-interface surflets-interface
(compound-interface
; surflet-handler/surflets-interface;
; surflets/sxml-interface
; surflets/surflet-sxml-interface
surflets/send-html-interface
surflets/input-fields-interface
surflets/addresses-interface
surflets/returned-via-interface
surflets/bindings-interface
surflets/session-data-interface))
;;; Structures
;; structures from SUrflet Handler
(define-structures
((surflet-handler surflet-handler-interface)
(surflet-handler/surflets surflet-handler/surflets-interface)
(surflet-handler/options surflet-handler/options-interface)
(surflet-handler/resume-url surflet-handler/resume-url-interface)
(surflet-handler/admin surflet-handler/admin-interface)
(surflet-handler/primitives surflet-handler/primitives-interface)
(surflet-handler/responses surflet-handler/responses-interface)
(surflets/sessions surflets/sessions-interface)
(surflets/continuations surflets/continuations-interface)
(surflets/error surflets/error-interface)
(surflets/session-data surflets/session-data-interface))
(open define-record-types ;DEFINE-RECORD-TYPE
handle-fatal ;WITH-FATAL-ERROR-HANDLER* et al.
handle-fatal-error
httpd-errors ;errors for httpd
httpd-logging ;HTTP-SYSLOG
httpd-requests ;requests from httpd
httpd-responses ;replies for httpd
let-opt ;:OPTIONAL
locks ;MAKE-LOCK et al.
profiling ;PROFILE-SPACE
rt-module-language ;get structures dynamically
scheme-with-scsh ;regexp et al.
shift-reset ;SHIFT and RESET
srfi-6 ;string-ports
srfi-14 ;CHAR-SET:DIGIT
srfi-27 ;random numbers
surflet-requests ;requests for surflets
sxml-to-html ;SXML->HTML
tables ;HASH-TABLES
thread-cells ;THREAD-CELL et al.
thread-fluids ;FORK-THREAD
thread-safe-counter
threads ;SLEEP
uri ;URI-PATH-LIST->PATH
)
(files surflet-handler))
;; SUrflets library of helping functions
(define-structure surflets surflets-interface
(open surflets/session-data
surflets/send-html ;send-html/suspend...
surflets/input-fields
surflets/addresses ;annotated-address...
surflets/returned-via
surflets/bindings))
;; SUrflets library for advanced users: make and use your own
;; conversion rules.
(define-structure surflets/my-sxml surflets/my-sxml-interface
(open surflets/send-html-string
surflets/sxml
surflets/surflet-sxml))
;; SUrflets librarary for advanced users: access to session and
;; continuations and stuff.
(define-structure surflets/my-sessions surflets/my-sessions-interface
(open surflets/ids
surflets/continuations
surflets/session-data
surflet-handler/surflets
surflets/sessions
surflet-handler/options))
;; Shift-Reset
(define-structure shift-reset shift-reset-interface
(open scheme
signals
escapes
thread-cells)
(files shift-reset))
;; Measuring memory usage.
(define-structure profiling profiling-interface
(open let-opt
define-record-types
spatial
srfi-13
srfi-1
2002-09-18 11:32:41 -04:00
locks
scheme-with-scsh)
(files profile))
;; Simple Surflet API as known from PLT.
2003-01-19 11:57:27 -05:00
(define-structure simple-surflet-api simple-surflet-api-interface
(open scheme-with-scsh
define-record-types
let-opt
2003-01-19 11:57:27 -05:00
surflets
(subset srfi-1 (zip filter find make-list))
handle-fatal-error
)
(files simple-surflet-api))
;; Handling every condition
(define-structure handle-fatal handle-fatal-interface
(open scheme conditions handle)
(files handle-fatal))
;; Thread-safe counter
(define-structure thread-safe-counter thread-safe-counter-interface
(open scheme
locks
define-record-types)
(files thread-safe-counter))
;; SUrflet-requests as expected from the SUrflet handler
;;; We have two names for the same thing to ease the use of structure
;;; names: requests seem to be part of the surflet-handler, but are
;;; actually seperate files. If you know everything about SUrflets,
;;; you use `surflet-requests'.
(define-structures
((surflet-handler/requests surflet-handler/requests-interface)
(surflet-requests surflet-handler/requests-interface))
(open scheme
define-record-types
httpd-requests)
(files surflet-request))
;; With the help of TYPED-OPTIONALS you can define a function
;; like (make-submit-button [string] args)
(define-structure typed-optionals typed-optionals-interface
(open scheme
receiving ;receive
srfi-23 ;error
surflets/utilities ;rev-append
(subset srfi-1 (make-list)))
(files typed-optionals))
;; Extensions to Olegs SSAX library
(define-structure surflets/sxml surflets/sxml-interface
(open scheme-with-scsh ;string-ports
(subset sxml-to-html (string->goodHTML entag))
(subset sxml-tree-trans (pre-post-order)))
(files sxml))
;; Input fields as Scheme objects
(define-structures
((surflets/input-fields surflets/input-fields-interface)
(surflets/input-fields/internal
surflets/input-fields/internal-interface))
(open scheme
srfi-23 ;error
(subset srfi-1 (filter))
(subset let-opt (:optional))
handle-fatal-error
define-record-types
(subset typed-optionals (optionals))
surflets/sxml
surflets/utilities ;rev-append,generate-unique-name
)
(files input-fields))
;; Extensions to SXML for surflets
(define-structure surflets/surflet-sxml surflets/surflet-sxml-interface
(open scheme-with-scsh ;error,receive
surflets/input-fields/internal
surflets/sxml
typed-optionals
(subset sxml-tree-trans (pre-post-order)))
(files surflet-sxml))
;; Access to session-id and continuation-id
(define-structure surflets/ids surflets/ids-interface
(open scheme
(subset surflet-requests (surflet-request-url))
(subset srfi-1 (last))
(subset surflet-handler/admin
(instance-session-id
resume-url-session-id
resume-url-continuation-id
resume-url-ids))
(subset url (http-url-path)))
(files ids))
;; Some utilities
(define-structure surflets/utilities surflets/utilities-interface
(open scheme
parse-html-forms
(subset surflet-handler/primitives (send/suspend)))
(files utilities))
;; Intelligent Addresses
(define-structure surflets/addresses surflets/addresses-interface
(open scheme
srfi-23 ;error
(subset uri (escape-uri))
define-record-types
(subset surflets/utilities (generate-unique-name)))
(files addresses))
(define-structure surflets/returned-via surflets/returned-via-interface
(open scheme
surflets/input-fields
surflets/addresses
(subset uri (unescape-uri)))
(files returned-via))
(define-structure surflets/outdaters surflets/outdaters-interface
(open scheme
define-record-types
surflets/send-html)
(files outdater))
(define-structure surflets/bindings surflets/bindings-interface
(open scheme-with-scsh ;read-string,error
locks
weak ;weak pointers
surflets/utilities ;form-query-list
surflet-requests
(subset url (http-url-search))
(subset srfi-14 (char-set:digit))
(subset srfi-13 (string-index))
(subset srfi-1 (filter))
(subset sunet-utilities (get-header)))
(files bindings))
(define-structures
((surflets/send-html surflets/send-html-interface)
(surflets/send-html-string surflets/send-html-string-interface))
(open scheme
surflet-handler/primitives
surflets/sxml
surflets/surflet-sxml)
(files send-html))
;; These two are from Martin Gasbichler:
(define-structure rt-module-language rt-module-language-interface
(open scheme
rt-modules)
(for-syntax (open scheme
rt-modules))
(begin
(define-syntax lambda-interface
(lambda (expr rename compare)
(let ((%lambda (rename 'lambda))
(interface-name (cadr expr))
(body (cddr expr)))
`(,%lambda ,(interface-value-names interface-name) ,@body))))
;(with-names-from-rt-structure surflet surflet-interface (main))
(define-syntax with-names-from-rt-structure
(lambda (expr rename compare)
(let ((%lambda (rename 'lambda))
(%let (rename 'let))
(%rt-structure-value (rename 'rt-structure-value))
(%rt-structure-binding (rename 'rt-structure-binding))
(rt-structure (cadr expr))
(interface-name (caddr expr))
(body (cdddr expr)))
(let ((ivn (interface-value-names interface-name)))
`(,%let ((,%rt-structure-value ,rt-structure))
((,%lambda ,ivn ,@body)
,@(map (lambda (name)
`(,%rt-structure-binding ,%rt-structure-value ',name))
ivn)))))))))
(define-structure rt-modules rt-modules-interface
(open scheme
meta-types ; syntax-type
interfaces ; for-each-declaration
define-record-types
records
signals
bindings
packages
packages-internal
locations
environments
ensures-loaded
package-commands-internal)
(files rt-module))