The house Reference Manual

Next: , Previous: , Up: (dir)   [Contents][Index]

The house Reference Manual

This is the house Reference Manual, version 0.5.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Aug 15 04:46:39 2022 GMT+0.

Table of Contents


1 Introduction

:house

Minimal, asynchronous, native Common Lisp web server

Build Status

The goals of :house are to be

  1. Asynchronous
  2. Minimal, but complete for the purposes of web application development
  3. Fully native

Performance is not on this list. This is the server/client framework you run if you never want to see an ffi-binding error on any platform where you're able to run sbcl. If you need high-throughput, take a look at woo. If you need a thread-per-request model, look into hunchentoot. If you need a file server, go set up nginx.

News

House has undergone a major overhaul. This should simplify a bunch of things.

Installation

Usage

Quick start
(define-handler (hello-world :content-type "text/plain") ()
  "Hello world!")
(define-handler (hello-you/<name>=>>string) ()
  (format nil "Hello there, ~a!" name))
(house:start 4040)

You should then be able to hop over to a browser and visit http://localhost:4040/hello-world to see the plaintext "Hello world!" response, or http:localhost:4040/hello-you/James to see the plaintext "Hello there, James!" (this may or may not make sense to do, depending on whether your name is James).

Threaded quick start

Because :house is single-threaded, using house:start directly as above will monopolize your REPL. You might not care about that in certain circumstances, or perhaps your deployment environment can't afford the extra thread. If you do and it can, you should start :house in a separate thread to retain your ability to evaluate things against the running system. You can do that the usual way:

(defparameter *server* (bordeaux-threads:make-thread (lambda () (house:start 4040))))
Static Files

House is not a file server. Static file serving capability is provided for ease of testing, and maybe for very small-scale deployment. If you're going to be taking any significant traffic, get a reverse proxy going with something like nginx.

You can define a static file handler with

(define-file-handler [file-or-directory])

It'll handle individual files by serving them, and it'll handle directories by serving all contained files recursively.

Redirecting

You can re-direct to a different handler by using the redirect! function inside of a define-handler call

(define-handler (name) () (redirect! "/static/name.html" :permanent? t))

Requests for "/name" will now instead serve a 301 Moved Permanently response with a target of "/static/name.html" (if you leave out :permanent? t, it'll be a 307 Temporary Redirect instead). House isn't optimized for redirecting, either from the performance or the notation perspective. If you're going to be re-directing any significant number of pages, consider having your reverse proxy handling that too.

Using the type annotations

You can specify desired argument types for your handlers. For example:

(define-handler (handler) ((foo >>json) (bar >>integer) (baz (>>list #'>>keyword)))
   ...)

You can then use bar as an integer, foo as a parsed JSON s-expression and baz as a parsed list of keywords in the body of that handler. The built-in types are >>string, >>integer, >>json, >>keyword, and >>list. The last one is a higher-order function; it expects to output a sequence of the given type.

Type annotations are just named functions. You can define your own by defining a function of String -> a that parses a string into your desired type and possibly throws an error of some sort on failure. If you need a more specific type, you can use defun. For example:

(defun >>game (param)
  (let ((g (gethash param *game-table*)))
    (assert (typep g 'game))
    g))

Once that's done, you can annotate parameters with the >>game type.

(define-handler (handler) ((foo >>game) ...) ...)

foo will then be looked up in *game-table*, and asserted to be of type 'game before the handler body is evaluated.

All this is entirely optional. If you don't care about it, just pass un-annotated arguments to your handlers, and they'll do exactly what you'd expect. You'll then be able to handle the type-conversion/assertions entirely manually.

Setting up "&rest" parameters

If you define a handler with a variable name starting with *, it will bind to the remainder of the path elements of the request. For example

(define-handler (example/<*foo>) () (format nil "~s" *foo))

If you (start 5000) now, then hop over to a shell, you can do

you@that:~/$ curl http://127.0.0.1:5000/example/a/b/c/d/e
("a" "b" "c" "d" "e")

Be careful with this feature; &rest parameters shadow anything further down in the handler tree.

External API

Basics

start

Takes a port-number and starts the server listening on that port.

Handlers

define-handler

Defines a handler. The handler body has access to the bound symbol request in addition to its' parameters:

define-json-handler

Defines a handler that responds with "application/json", and automatically JSON-encodes its response.

define-channel

Defines a handler that opens an EventSource instead of closing after sending the response.

define-file-handler

Defines a handler that very inefficiently responds with static files.

Event Streams

subscribe!

Subscribes the specified socket to the specified channel. Should only be used with stream handlers, since the socket will need to be kept open for a subscription to be relevant.

publish!

Publishes a message to all subscribers of the specified channel. At the moment, it's assumed that the message recipients are all EventSource consumers (I'm working on a more general WebSocket-capable interface)


2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 house

Custom asynchronous HTTP server for the Deal project.

Author

Inaimathi <leo.zovic@gmail.com>

License

AGPL3

Version

0.5.0

Dependencies
  • alexandria (system).
  • anaphora (system).
  • bordeaux-threads (system).
  • usocket (system).
  • flexi-streams (system).
  • cl-fad (system).
  • cl-ppcre (system).
  • optima (system).
  • cl-json (system).
  • split-sequence (system).
  • quri (system).
  • session-token (system).
  • trivial-features (system).
  • lisp-unit (system).
Source

house.asd.

Child Component

src (module).


Next: , Previous: , Up: The house Reference Manual   [Contents][Index]

3 Modules

Modules are listed depth-first from the system components tree.


Previous: , Up: Modules   [Contents][Index]

3.1 house/src

Source

house.asd.

Parent Component

house (system).

Child Components

4 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

4.1 Lisp


Next: , Previous: , Up: Lisp   [Contents][Index]

4.1.1 house/house.asd

Source

house.asd.

Parent Component

house (system).

ASDF Systems

house.


4.1.2 house/src/package.lisp

Source

house.asd.

Parent Component

src (module).

Packages

house.

Internals

4.1.3 house/src/session.lisp

Source

house.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.4 house/src/util.lisp

Source

house.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.5 house/src/request.lisp

Source

house.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.6 house/src/response.lisp

Source

house.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.7 house/src/buffer.lisp

Source

house.asd.

Parent Component

src (module).

Internals

4.1.8 house/src/handler-table.lisp

Source

house.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.9 house/src/define-handler.lisp

Source

house.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.10 house/src/channel.lisp

Source

house.asd.

Parent Component

src (module).

Public Interface
Internals

Previous: , Up: Lisp   [Contents][Index]

4.1.11 house/src/house.lisp

Source

house.asd.

Parent Component

src (module).

Public Interface

start (function).

Internals

5 Packages

Packages are listed by definition order.


Previous: , Up: Packages   [Contents][Index]

5.1 house

Source

package.lisp.

Use List
  • cl-ppcre.
  • common-lisp.
  • lisp-unit.
  • optima.
  • usocket.
Public Interface
Internals

6 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

6.1 Public Interface


6.1.1 Macros

Macro: assert-http (assertion)
Package

house.

Source

util.lisp.

Macro: closing-handler ((&key content-type headers) (&rest args) &body body)
Package

house.

Source

define-handler.lisp.

Macro: define-channel ((name &key method) (&rest args) &body body)
Package

house.

Source

define-handler.lisp.

Macro: define-handler ((name &key content-type method) (&rest args) &body body)
Package

house.

Source

define-handler.lisp.

Macro: define-json-handler ((name &key method) (&rest args) &body body)
Package

house.

Source

define-handler.lisp.

Macro: stream-handler ((channel-name &key headers) (&rest args) &body body)
Package

house.

Source

define-handler.lisp.

Macro: with-handler-table (tbl &body body)
Package

house.

Source

handler-table.lisp.


6.1.2 Ordinary functions

Function: >>integer (arg)
Package

house.

Source

define-handler.lisp.

Function: >>json (arg)
Package

house.

Source

define-handler.lisp.

Function: >>keyword (arg)
Package

house.

Source

define-handler.lisp.

Function: >>list (elem-type)
Package

house.

Source

define-handler.lisp.

Function: >>string (arg)
Package

house.

Source

define-handler.lisp.

Function: clear-session-hooks! ()
Package

house.

Source

session.lisp.

Function: define-file-handler (path &key stem-from method)
Package

house.

Source

define-handler.lisp.

Function: empty-handler-table ()
Package

house.

Source

handler-table.lisp.

Function: find-handler (method uri-string &key handler-table)
Package

house.

Source

handler-table.lisp.

Function: get-session! (token)
Package

house.

Source

session.lisp.

Function: insert-handler! (method uri-string handler &key handler-table)
Package

house.

Source

handler-table.lisp.

Function: make-sse (data &key id event retry)
Package

house.

Source

channel.lisp.

Function: new-session! ()
Package

house.

Source

session.lisp.

Function: new-session-hook! (callback)
Package

house.

Source

session.lisp.

Function: publish! (channel msg)
Package

house.

Source

channel.lisp.

Function: redirect! (target &key permanent?)
Package

house.

Source

response.lisp.

Function: start (port &optional host)
Package

house.

Source

house.lisp.

Function: subscribe! (channel sock)
Package

house.

Source

channel.lisp.

Function: subscribers-of (channel)
Package

house.

Source

channel.lisp.


6.1.3 Generic functions

Generic Reader: headers (object)
Package

house.

Methods
Reader Method: headers ((response response))

automatically generated reader method

Source

response.lisp.

Target Slot

headers.

Reader Method: headers ((request request))

automatically generated reader method

Source

request.lisp.

Target Slot

headers.

Generic Writer: (setf headers) (object)
Package

house.

Methods
Writer Method: (setf headers) ((response response))

automatically generated writer method

Source

response.lisp.

Target Slot

headers.

Writer Method: (setf headers) ((request request))

automatically generated writer method

Source

request.lisp.

Target Slot

headers.

Generic Function: lookup (key hash)
Package

house.

Methods
Method: lookup (key (session session))
Source

util.lisp.

Method: lookup (key (hash hash-table))
Source

util.lisp.

Generic Function: (setf lookup) (key session)

Setter for lookup methods

Package

house.

Source

util.lisp.

Methods
Method: (setf lookup) (key (hash hash-table))
Method: (setf lookup) (key (session session))
Generic Reader: parameters (object)
Package

house.

Methods
Reader Method: parameters ((request request))

automatically generated reader method

Source

request.lisp.

Target Slot

parameters.

Generic Writer: (setf parameters) (object)
Package

house.

Methods
Writer Method: (setf parameters) ((request request))

automatically generated writer method

Source

request.lisp.

Target Slot

parameters.

Generic Reader: resource (object)
Package

house.

Methods
Reader Method: resource ((request request))

automatically generated reader method

Source

request.lisp.

Target Slot

resource.

Generic Writer: (setf resource) (object)
Package

house.

Methods
Writer Method: (setf resource) ((request request))

automatically generated writer method

Source

request.lisp.

Target Slot

resource.

Generic Reader: session (object)
Package

house.

Methods
Reader Method: session ((request request))

automatically generated reader method

Source

request.lisp.

Target Slot

session.

Generic Writer: (setf session) (object)
Package

house.

Methods
Writer Method: (setf session) ((request request))

automatically generated writer method

Source

request.lisp.

Target Slot

session.

Generic Reader: socket-of (object)
Package

house.

Methods
Reader Method: socket-of ((request request))

automatically generated reader method

Source

request.lisp.

Target Slot

socket-of.

Generic Writer: (setf socket-of) (object)
Package

house.

Methods
Writer Method: (setf socket-of) ((request request))

automatically generated writer method

Source

request.lisp.

Target Slot

socket-of.


6.1.4 Classes

Class: request
Package

house.

Source

request.lisp.

Direct methods
Direct slots
Slot: http-method
Initargs

:http-method

Readers

http-method.

Writers

(setf http-method).

Slot: resource
Initargs

:resource

Readers

resource.

Writers

(setf resource).

Slot: headers
Initargs

:headers

Readers

headers.

Writers

(setf headers).

Slot: session-tokens
Initargs

:session-tokens

Readers

session-tokens.

Writers

(setf session-tokens).

Slot: parameters
Initargs

:parameters

Readers

parameters.

Writers

(setf parameters).

Slot: session
Initargs

:session

Readers

session.

Writers

(setf session).

Slot: socket-of
Initargs

:socket-of

Readers

socket-of.

Writers

(setf socket-of).

Class: session
Package

house.

Source

session.lisp.

Direct methods
Direct slots
Slot: started
Initform

(get-universal-time)

Readers

started.

Writers

This slot is read-only.

Slot: last-poked
Initform

(get-universal-time)

Slot: token
Initargs

:token

Readers

token.

Writers

This slot is read-only.

Slot: session-values
Initform

(make-hash-table :test (quote equal))

Readers

session-values.

Writers

This slot is read-only.


6.2 Internals


Next: , Previous: , Up: Internals   [Contents][Index]

6.2.1 Special variables

Special Variable: *channels*
Package

house.

Source

channel.lisp.

Special Variable: *cookie-domains*
Package

house.

Source

package.lisp.

Special Variable: *handler-table*
Package

house.

Source

handler-table.lisp.

Special Variable: *mimetype-table*
Package

house.

Source

util.lisp.

Special Variable: *new-session-hook*
Package

house.

Source

session.lisp.

Special Variable: *sessions*
Package

house.

Source

session.lisp.

Special Variable: +400+
Package

house.

Source

response.lisp.

Special Variable: +404+
Package

house.

Source

response.lisp.

Special Variable: +413+
Package

house.

Source

response.lisp.

Special Variable: +500+
Package

house.

Source

response.lisp.

Special Variable: +clean-sessions-every+
Package

house.

Source

package.lisp.

Special Variable: +max-buffer-tries+
Package

house.

Source

package.lisp.

Special Variable: +max-request-age+
Package

house.

Source

package.lisp.

Special Variable: +max-request-size+
Package

house.

Source

package.lisp.

Special Variable: +max-session-idle+
Package

house.

Source

package.lisp.


6.2.2 Ordinary functions

Function: ->keyword (thing)
Package

house.

Source

util.lisp.

Function: -error! (err sock)
Package

house.

Source

house.lisp.

Function: -full-params (name args)
Package

house.

Source

define-handler.lisp.

Function: -param-bindings (params)
Package

house.

Source

define-handler.lisp.

Function: any-vars? (trie)
Package

house.

Source

handler-table.lisp.

Function: buffer! (buffer)
Package

house.

Source

buffer.lisp.

Reader: buffer-bi-stream (instance)
Writer: (setf buffer-bi-stream) (instance)
Package

house.

Source

buffer.lisp.

Target Slot

bi-stream.

Reader: buffer-contents (instance)
Writer: (setf buffer-contents) (instance)
Package

house.

Source

buffer.lisp.

Target Slot

contents.

Reader: buffer-expecting (instance)
Writer: (setf buffer-expecting) (instance)
Package

house.

Source

buffer.lisp.

Target Slot

expecting.

Function: buffer-p (object)
Package

house.

Source

buffer.lisp.

Reader: buffer-request (instance)
Writer: (setf buffer-request) (instance)
Package

house.

Source

buffer.lisp.

Target Slot

request.

Reader: buffer-started (instance)
Writer: (setf buffer-started) (instance)
Package

house.

Source

buffer.lisp.

Target Slot

started.

Reader: buffer-total-buffered (instance)
Writer: (setf buffer-total-buffered) (instance)
Package

house.

Source

buffer.lisp.

Target Slot

total-buffered.

Reader: buffer-tries (instance)
Writer: (setf buffer-tries) (instance)
Package

house.

Source

buffer.lisp.

Target Slot

tries.

Function: clean-sessions! ()
Package

house.

Source

session.lisp.

Function: copy-buffer (instance)
Package

house.

Source

buffer.lisp.

Function: copy-handler-entry (instance)
Package

house.

Source

define-handler.lisp.

Function: copy-sse (instance)
Package

house.

Source

channel.lisp.

Function: copy-trie (instance)
Package

house.

Source

handler-table.lisp.

Function: crlf (&optional stream)
Package

house.

Source

util.lisp.

Function: dedupe-params (full-params)
Package

house.

Source

define-handler.lisp.

Function: flex-stream (sock)
Package

house.

Source

util.lisp.

Function: get-param (request arg annotation)
Package

house.

Source

define-handler.lisp.

Function: handle-request! (sock req)
Package

house.

Source

house.lisp.

Reader: handler-entry-closing? (instance)
Writer: (setf handler-entry-closing?) (instance)
Package

house.

Source

define-handler.lisp.

Target Slot

closing?.

Reader: handler-entry-fn (instance)
Writer: (setf handler-entry-fn) (instance)
Package

house.

Source

define-handler.lisp.

Target Slot

fn.

Function: handler-entry-p (object)
Package

house.

Source

define-handler.lisp.

Function: idling? (sess)
Package

house.

Source

session.lisp.

Function: line-terminated? (lst)
Package

house.

Source

util.lisp.

Function: make-buffer (bi-stream)
Package

house.

Source

buffer.lisp.

Function: make-handler-entry (&key fn closing?)
Package

house.

Source

define-handler.lisp.

Function: make-trie (&key value rest map vars)
Package

house.

Source

handler-table.lisp.

Function: new-session-token! ()
Package

house.

Source

session.lisp.

Function: parse-buffer (buf)
Package

house.

Source

buffer.lisp.

Function: parse-cookies (cookie)
Package

house.

Source

request.lisp.

Function: parse-param-string (params)
Package

house.

Source

request.lisp.

Function: parse-request-string (str)
Package

house.

Source

request.lisp.

Function: path->mimetype (path)
Package

house.

Source

util.lisp.

Function: path->uri (path &key stem-from)
Package

house.

Source

util.lisp.

Function: path-var? (str)
Package

house.

Source

handler-table.lisp.

Function: poke! (sess)
Package

house.

Source

session.lisp.

Function: process-ready (ready conns)
Package

house.

Source

house.lisp.

Function: process-uri (uri)
Package

house.

Source

handler-table.lisp.

Function: rest-var? (str)
Package

house.

Source

handler-table.lisp.

Function: split-at (elem seq)
Package

house.

Source

util.lisp.

Reader: sse-data (instance)
Writer: (setf sse-data) (instance)
Package

house.

Source

channel.lisp.

Target Slot

data.

Reader: sse-event (instance)
Writer: (setf sse-event) (instance)
Package

house.

Source

channel.lisp.

Target Slot

event.

Reader: sse-id (instance)
Writer: (setf sse-id) (instance)
Package

house.

Source

channel.lisp.

Target Slot

id.

Function: sse-p (object)
Package

house.

Source

channel.lisp.

Reader: sse-retry (instance)
Writer: (setf sse-retry) (instance)
Package

house.

Source

channel.lisp.

Target Slot

retry.

Function: trie-insert! (key value trie)
Package

house.

Source

handler-table.lisp.

Function: trie-lookup (key trie)
Package

house.

Source

handler-table.lisp.

Reader: trie-map (instance)
Writer: (setf trie-map) (instance)
Package

house.

Source

handler-table.lisp.

Target Slot

map.

Function: trie-p (object)
Package

house.

Source

handler-table.lisp.

Reader: trie-rest (instance)
Writer: (setf trie-rest) (instance)
Package

house.

Source

handler-table.lisp.

Target Slot

rest.

Reader: trie-value (instance)
Writer: (setf trie-value) (instance)
Package

house.

Source

handler-table.lisp.

Target Slot

value.

Reader: trie-vars (instance)
Writer: (setf trie-vars) (instance)
Package

house.

Source

handler-table.lisp.

Target Slot

vars.

Function: var-annotation (str)
Package

house.

Source

handler-table.lisp.

Function: var-key (str)
Package

house.

Source

handler-table.lisp.

Function: write-ln (stream &rest sequences)
Package

house.

Source

util.lisp.

Function: write-response! (res stream)
Package

house.

Source

response.lisp.

Function: write-sse! (res stream)
Package

house.

Source

channel.lisp.


Next: , Previous: , Up: Internals   [Contents][Index]

6.2.3 Generic functions

Generic Reader: assertion (condition)
Package

house.

Methods
Reader Method: assertion ((condition http-assertion-error))
Source

util.lisp.

Target Slot

assertion.

Generic Reader: body (object)
Package

house.

Methods
Reader Method: body ((response response))

automatically generated reader method

Source

response.lisp.

Target Slot

body.

Generic Writer: (setf body) (object)
Package

house.

Methods
Writer Method: (setf body) ((response response))

automatically generated writer method

Source

response.lisp.

Target Slot

body.

Generic Reader: cache-control (object)
Package

house.

Methods
Reader Method: cache-control ((response response))

automatically generated reader method

Source

response.lisp.

Target Slot

cache-control.

Generic Writer: (setf cache-control) (object)
Package

house.

Methods
Writer Method: (setf cache-control) ((response response))

automatically generated writer method

Source

response.lisp.

Target Slot

cache-control.

Generic Reader: charset (object)
Package

house.

Methods
Reader Method: charset ((response response))

automatically generated reader method

Source

response.lisp.

Target Slot

charset.

Generic Writer: (setf charset) (object)
Package

house.

Methods
Writer Method: (setf charset) ((response response))

automatically generated writer method

Source

response.lisp.

Target Slot

charset.

Generic Reader: content-type (object)
Package

house.

Methods
Reader Method: content-type ((response response))

automatically generated reader method

Source

response.lisp.

Target Slot

content-type.

Generic Writer: (setf content-type) (object)
Package

house.

Methods
Writer Method: (setf content-type) ((response response))

automatically generated writer method

Source

response.lisp.

Target Slot

content-type.

Package

house.

Methods

automatically generated reader method

Source

response.lisp.

Target Slot

cookie.

Package

house.

Methods

automatically generated writer method

Source

response.lisp.

Target Slot

cookie.

Generic Reader: expires (object)
Package

house.

Methods
Reader Method: expires ((response response))

automatically generated reader method

Source

response.lisp.

Target Slot

expires.

Generic Writer: (setf expires) (object)
Package

house.

Methods
Writer Method: (setf expires) ((response response))

automatically generated writer method

Source

response.lisp.

Target Slot

expires.

Generic Reader: http-method (object)
Package

house.

Methods
Reader Method: http-method ((request request))

automatically generated reader method

Source

request.lisp.

Target Slot

http-method.

Generic Writer: (setf http-method) (object)
Package

house.

Methods
Writer Method: (setf http-method) ((request request))

automatically generated writer method

Source

request.lisp.

Target Slot

http-method.

Generic Reader: keep-alive? (object)
Package

house.

Methods
Reader Method: keep-alive? ((response response))

automatically generated reader method

Source

response.lisp.

Target Slot

keep-alive?.

Generic Writer: (setf keep-alive?) (object)
Package

house.

Methods
Writer Method: (setf keep-alive?) ((response response))

automatically generated writer method

Source

response.lisp.

Target Slot

keep-alive?.

Generic Reader: location (object)
Package

house.

Methods
Reader Method: location ((response response))

automatically generated reader method

Source

response.lisp.

Target Slot

location.

Generic Writer: (setf location) (object)
Package

house.

Methods
Writer Method: (setf location) ((response response))

automatically generated writer method

Source

response.lisp.

Target Slot

location.

Generic Reader: response-code (object)
Package

house.

Methods
Reader Method: response-code ((response response))

automatically generated reader method

Source

response.lisp.

Target Slot

response-code.

Generic Writer: (setf response-code) (object)
Package

house.

Methods
Writer Method: (setf response-code) ((response response))

automatically generated writer method

Source

response.lisp.

Target Slot

response-code.

Generic Reader: session-tokens (object)
Package

house.

Methods
Reader Method: session-tokens ((request request))

automatically generated reader method

Source

request.lisp.

Target Slot

session-tokens.

Generic Writer: (setf session-tokens) (object)
Package

house.

Methods
Writer Method: (setf session-tokens) ((request request))

automatically generated writer method

Source

request.lisp.

Target Slot

session-tokens.

Generic Reader: session-values (object)
Package

house.

Methods
Reader Method: session-values ((session session))

automatically generated reader method

Source

session.lisp.

Target Slot

session-values.

Generic Reader: started (object)
Package

house.

Methods
Reader Method: started ((session session))

automatically generated reader method

Source

session.lisp.

Target Slot

started.

Generic Reader: token (object)
Package

house.

Methods
Reader Method: token ((session session))

automatically generated reader method

Source

session.lisp.

Target Slot

token.


Next: , Previous: , Up: Internals   [Contents][Index]

6.2.4 Conditions

Condition: http-assertion-error
Package

house.

Source

util.lisp.

Direct superclasses

error.

Direct methods

assertion.

Direct slots
Slot: assertion
Initform

(quote nil)

Initargs

:assertion

Readers

assertion.

Writers

This slot is read-only.


Next: , Previous: , Up: Internals   [Contents][Index]

6.2.5 Structures

Structure: buffer
Package

house.

Source

buffer.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: tries
Type

integer

Initform

0

Readers

buffer-tries.

Writers

(setf buffer-tries).

Slot: contents
Readers

buffer-contents.

Writers

(setf buffer-contents).

Slot: bi-stream
Readers

buffer-bi-stream.

Writers

(setf buffer-bi-stream).

Slot: total-buffered
Type

integer

Initform

0

Readers

buffer-total-buffered.

Writers

(setf buffer-total-buffered).

Slot: started
Initform

(get-universal-time)

Readers

buffer-started.

Writers

(setf buffer-started).

Slot: request
Readers

buffer-request.

Writers

(setf buffer-request).

Slot: expecting
Type

integer

Initform

0

Readers

buffer-expecting.

Writers

(setf buffer-expecting).

Structure: handler-entry
Package

house.

Source

define-handler.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: fn
Readers

handler-entry-fn.

Writers

(setf handler-entry-fn).

Slot: closing?
Initform

t

Readers

handler-entry-closing?.

Writers

(setf handler-entry-closing?).

Structure: sse
Package

house.

Source

channel.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: id
Readers

sse-id.

Writers

(setf sse-id).

Slot: event
Readers

sse-event.

Writers

(setf sse-event).

Slot: retry
Readers

sse-retry.

Writers

(setf sse-retry).

Slot: data
Type

string

Initform

(error "an sse must have :data")

Readers

sse-data.

Writers

(setf sse-data).

Structure: trie
Package

house.

Source

handler-table.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: value
Readers

trie-value.

Writers

(setf trie-value).

Slot: rest
Package

common-lisp.

Readers

trie-rest.

Writers

(setf trie-rest).

Slot: map
Package

common-lisp.

Initform

(make-hash-table :test (quote equal))

Readers

trie-map.

Writers

(setf trie-map).

Slot: vars
Initform

(make-hash-table)

Readers

trie-vars.

Writers

(setf trie-vars).


Previous: , Up: Internals   [Contents][Index]

6.2.6 Classes

Class: response
Package

house.

Source

response.lisp.

Direct methods
Direct slots
Slot: content-type
Initform

"text/html"

Initargs

:content-type

Readers

content-type.

Writers

(setf content-type).

Slot: headers
Initargs

:headers

Readers

headers.

Writers

(setf headers).

Slot: charset
Initform

"utf-8"

Readers

charset.

Writers

(setf charset).

Slot: response-code
Initform

"200 ok"

Initargs

:response-code

Readers

response-code.

Writers

(setf response-code).

Initargs

:cookie

Readers

cookie.

Writers

(setf cookie).

Slot: location
Initargs

:location

Readers

location.

Writers

(setf location).

Slot: cache-control
Readers

cache-control.

Writers

(setf cache-control).

Slot: keep-alive?
Initargs

:keep-alive?

Readers

keep-alive?.

Writers

(setf keep-alive?).

Slot: expires
Readers

expires.

Writers

(setf expires).

Slot: body
Initargs

:body

Readers

body.

Writers

(setf body).


Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts


Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   (   -   >  
A   B   C   D   E   F   G   H   I   K   L   M   N   P   R   S   T   V   W  
Index Entry  Section

(
(setf body): Private generic functions
(setf body): Private generic functions
(setf buffer-bi-stream): Private ordinary functions
(setf buffer-contents): Private ordinary functions
(setf buffer-expecting): Private ordinary functions
(setf buffer-request): Private ordinary functions
(setf buffer-started): Private ordinary functions
(setf buffer-total-buffered): Private ordinary functions
(setf buffer-tries): Private ordinary functions
(setf cache-control): Private generic functions
(setf cache-control): Private generic functions
(setf charset): Private generic functions
(setf charset): Private generic functions
(setf content-type): Private generic functions
(setf content-type): Private generic functions
(setf cookie): Private generic functions
(setf cookie): Private generic functions
(setf expires): Private generic functions
(setf expires): Private generic functions
(setf handler-entry-closing?): Private ordinary functions
(setf handler-entry-fn): Private ordinary functions
(setf headers): Public generic functions
(setf headers): Public generic functions
(setf headers): Public generic functions
(setf http-method): Private generic functions
(setf http-method): Private generic functions
(setf keep-alive?): Private generic functions
(setf keep-alive?): Private generic functions
(setf location): Private generic functions
(setf location): Private generic functions
(setf lookup): Public generic functions
(setf lookup): Public generic functions
(setf lookup): Public generic functions
(setf parameters): Public generic functions
(setf parameters): Public generic functions
(setf resource): Public generic functions
(setf resource): Public generic functions
(setf response-code): Private generic functions
(setf response-code): Private generic functions
(setf session): Public generic functions
(setf session): Public generic functions
(setf session-tokens): Private generic functions
(setf session-tokens): Private generic functions
(setf socket-of): Public generic functions
(setf socket-of): Public generic functions
(setf sse-data): Private ordinary functions
(setf sse-event): Private ordinary functions
(setf sse-id): Private ordinary functions
(setf sse-retry): Private ordinary functions
(setf trie-map): Private ordinary functions
(setf trie-rest): Private ordinary functions
(setf trie-value): Private ordinary functions
(setf trie-vars): Private ordinary functions

-
->keyword: Private ordinary functions
-error!: Private ordinary functions
-full-params: Private ordinary functions
-param-bindings: Private ordinary functions

>
>>integer: Public ordinary functions
>>json: Public ordinary functions
>>keyword: Public ordinary functions
>>list: Public ordinary functions
>>string: Public ordinary functions

A
any-vars?: Private ordinary functions
assert-http: Public macros
assertion: Private generic functions
assertion: Private generic functions

B
body: Private generic functions
body: Private generic functions
buffer!: Private ordinary functions
buffer-bi-stream: Private ordinary functions
buffer-contents: Private ordinary functions
buffer-expecting: Private ordinary functions
buffer-p: Private ordinary functions
buffer-request: Private ordinary functions
buffer-started: Private ordinary functions
buffer-total-buffered: Private ordinary functions
buffer-tries: Private ordinary functions

C
cache-control: Private generic functions
cache-control: Private generic functions
charset: Private generic functions
charset: Private generic functions
clean-sessions!: Private ordinary functions
clear-session-hooks!: Public ordinary functions
closing-handler: Public macros
content-type: Private generic functions
content-type: Private generic functions
cookie: Private generic functions
cookie: Private generic functions
copy-buffer: Private ordinary functions
copy-handler-entry: Private ordinary functions
copy-sse: Private ordinary functions
copy-trie: Private ordinary functions
crlf: Private ordinary functions

D
dedupe-params: Private ordinary functions
define-channel: Public macros
define-file-handler: Public ordinary functions
define-handler: Public macros
define-json-handler: Public macros

E
empty-handler-table: Public ordinary functions
expires: Private generic functions
expires: Private generic functions

F
find-handler: Public ordinary functions
flex-stream: Private ordinary functions
Function, (setf buffer-bi-stream): Private ordinary functions
Function, (setf buffer-contents): Private ordinary functions
Function, (setf buffer-expecting): Private ordinary functions
Function, (setf buffer-request): Private ordinary functions
Function, (setf buffer-started): Private ordinary functions
Function, (setf buffer-total-buffered): Private ordinary functions
Function, (setf buffer-tries): Private ordinary functions
Function, (setf handler-entry-closing?): Private ordinary functions
Function, (setf handler-entry-fn): Private ordinary functions
Function, (setf sse-data): Private ordinary functions
Function, (setf sse-event): Private ordinary functions
Function, (setf sse-id): Private ordinary functions
Function, (setf sse-retry): Private ordinary functions
Function, (setf trie-map): Private ordinary functions
Function, (setf trie-rest): Private ordinary functions
Function, (setf trie-value): Private ordinary functions
Function, (setf trie-vars): Private ordinary functions
Function, ->keyword: Private ordinary functions
Function, -error!: Private ordinary functions
Function, -full-params: Private ordinary functions
Function, -param-bindings: Private ordinary functions
Function, >>integer: Public ordinary functions
Function, >>json: Public ordinary functions
Function, >>keyword: Public ordinary functions
Function, >>list: Public ordinary functions
Function, >>string: Public ordinary functions
Function, any-vars?: Private ordinary functions
Function, buffer!: Private ordinary functions
Function, buffer-bi-stream: Private ordinary functions
Function, buffer-contents: Private ordinary functions
Function, buffer-expecting: Private ordinary functions
Function, buffer-p: Private ordinary functions
Function, buffer-request: Private ordinary functions
Function, buffer-started: Private ordinary functions
Function, buffer-total-buffered: Private ordinary functions
Function, buffer-tries: Private ordinary functions
Function, clean-sessions!: Private ordinary functions
Function, clear-session-hooks!: Public ordinary functions
Function, copy-buffer: Private ordinary functions
Function, copy-handler-entry: Private ordinary functions
Function, copy-sse: Private ordinary functions
Function, copy-trie: Private ordinary functions
Function, crlf: Private ordinary functions
Function, dedupe-params: Private ordinary functions
Function, define-file-handler: Public ordinary functions
Function, empty-handler-table: Public ordinary functions
Function, find-handler: Public ordinary functions
Function, flex-stream: Private ordinary functions
Function, get-param: Private ordinary functions
Function, get-session!: Public ordinary functions
Function, handle-request!: Private ordinary functions
Function, handler-entry-closing?: Private ordinary functions
Function, handler-entry-fn: Private ordinary functions
Function, handler-entry-p: Private ordinary functions
Function, idling?: Private ordinary functions
Function, insert-handler!: Public ordinary functions
Function, line-terminated?: Private ordinary functions
Function, make-buffer: Private ordinary functions
Function, make-handler-entry: Private ordinary functions
Function, make-sse: Public ordinary functions
Function, make-trie: Private ordinary functions
Function, new-session!: Public ordinary functions
Function, new-session-hook!: Public ordinary functions
Function, new-session-token!: Private ordinary functions
Function, parse-buffer: Private ordinary functions
Function, parse-cookies: Private ordinary functions
Function, parse-param-string: Private ordinary functions
Function, parse-request-string: Private ordinary functions
Function, path->mimetype: Private ordinary functions
Function, path->uri: Private ordinary functions
Function, path-var?: Private ordinary functions
Function, poke!: Private ordinary functions
Function, process-ready: Private ordinary functions
Function, process-uri: Private ordinary functions
Function, publish!: Public ordinary functions
Function, redirect!: Public ordinary functions
Function, rest-var?: Private ordinary functions
Function, split-at: Private ordinary functions
Function, sse-data: Private ordinary functions
Function, sse-event: Private ordinary functions
Function, sse-id: Private ordinary functions
Function, sse-p: Private ordinary functions
Function, sse-retry: Private ordinary functions
Function, start: Public ordinary functions
Function, subscribe!: Public ordinary functions
Function, subscribers-of: Public ordinary functions
Function, trie-insert!: Private ordinary functions
Function, trie-lookup: Private ordinary functions
Function, trie-map: Private ordinary functions
Function, trie-p: Private ordinary functions
Function, trie-rest: Private ordinary functions
Function, trie-value: Private ordinary functions
Function, trie-vars: Private ordinary functions
Function, var-annotation: Private ordinary functions
Function, var-key: Private ordinary functions
Function, write-ln: Private ordinary functions
Function, write-response!: Private ordinary functions
Function, write-sse!: Private ordinary functions

G
Generic Function, (setf body): Private generic functions
Generic Function, (setf cache-control): Private generic functions
Generic Function, (setf charset): Private generic functions
Generic Function, (setf content-type): Private generic functions
Generic Function, (setf cookie): Private generic functions
Generic Function, (setf expires): Private generic functions
Generic Function, (setf headers): Public generic functions
Generic Function, (setf http-method): Private generic functions
Generic Function, (setf keep-alive?): Private generic functions
Generic Function, (setf location): Private generic functions
Generic Function, (setf lookup): Public generic functions
Generic Function, (setf parameters): Public generic functions
Generic Function, (setf resource): Public generic functions
Generic Function, (setf response-code): Private generic functions
Generic Function, (setf session): Public generic functions
Generic Function, (setf session-tokens): Private generic functions
Generic Function, (setf socket-of): Public generic functions
Generic Function, assertion: Private generic functions
Generic Function, body: Private generic functions
Generic Function, cache-control: Private generic functions
Generic Function, charset: Private generic functions
Generic Function, content-type: Private generic functions
Generic Function, cookie: Private generic functions
Generic Function, expires: Private generic functions
Generic Function, headers: Public generic functions
Generic Function, http-method: Private generic functions
Generic Function, keep-alive?: Private generic functions
Generic Function, location: Private generic functions
Generic Function, lookup: Public generic functions
Generic Function, parameters: Public generic functions
Generic Function, resource: Public generic functions
Generic Function, response-code: Private generic functions
Generic Function, session: Public generic functions
Generic Function, session-tokens: Private generic functions
Generic Function, session-values: Private generic functions
Generic Function, socket-of: Public generic functions
Generic Function, started: Private generic functions
Generic Function, token: Private generic functions
get-param: Private ordinary functions
get-session!: Public ordinary functions

H
handle-request!: Private ordinary functions
handler-entry-closing?: Private ordinary functions
handler-entry-fn: Private ordinary functions
handler-entry-p: Private ordinary functions
headers: Public generic functions
headers: Public generic functions
headers: Public generic functions
http-method: Private generic functions
http-method: Private generic functions

I
idling?: Private ordinary functions
insert-handler!: Public ordinary functions

K
keep-alive?: Private generic functions
keep-alive?: Private generic functions

L
line-terminated?: Private ordinary functions
location: Private generic functions
location: Private generic functions
lookup: Public generic functions
lookup: Public generic functions
lookup: Public generic functions

M
Macro, assert-http: Public macros
Macro, closing-handler: Public macros
Macro, define-channel: Public macros
Macro, define-handler: Public macros
Macro, define-json-handler: Public macros
Macro, stream-handler: Public macros
Macro, with-handler-table: Public macros
make-buffer: Private ordinary functions
make-handler-entry: Private ordinary functions
make-sse: Public ordinary functions
make-trie: Private ordinary functions
Method, (setf body): Private generic functions
Method, (setf cache-control): Private generic functions
Method, (setf charset): Private generic functions
Method, (setf content-type): Private generic functions
Method, (setf cookie): Private generic functions
Method, (setf expires): Private generic functions
Method, (setf headers): Public generic functions
Method, (setf headers): Public generic functions
Method, (setf http-method): Private generic functions
Method, (setf keep-alive?): Private generic functions
Method, (setf location): Private generic functions
Method, (setf lookup): Public generic functions
Method, (setf lookup): Public generic functions
Method, (setf parameters): Public generic functions
Method, (setf resource): Public generic functions
Method, (setf response-code): Private generic functions
Method, (setf session): Public generic functions
Method, (setf session-tokens): Private generic functions
Method, (setf socket-of): Public generic functions
Method, assertion: Private generic functions
Method, body: Private generic functions
Method, cache-control: Private generic functions
Method, charset: Private generic functions
Method, content-type: Private generic functions
Method, cookie: Private generic functions
Method, expires: Private generic functions
Method, headers: Public generic functions
Method, headers: Public generic functions
Method, http-method: Private generic functions
Method, keep-alive?: Private generic functions
Method, location: Private generic functions
Method, lookup: Public generic functions
Method, lookup: Public generic functions
Method, parameters: Public generic functions
Method, resource: Public generic functions
Method, response-code: Private generic functions
Method, session: Public generic functions
Method, session-tokens: Private generic functions
Method, session-values: Private generic functions
Method, socket-of: Public generic functions
Method, started: Private generic functions
Method, token: Private generic functions

N
new-session!: Public ordinary functions
new-session-hook!: Public ordinary functions
new-session-token!: Private ordinary functions

P
parameters: Public generic functions
parameters: Public generic functions
parse-buffer: Private ordinary functions
parse-cookies: Private ordinary functions
parse-param-string: Private ordinary functions
parse-request-string: Private ordinary functions
path->mimetype: Private ordinary functions
path->uri: Private ordinary functions
path-var?: Private ordinary functions
poke!: Private ordinary functions
process-ready: Private ordinary functions
process-uri: Private ordinary functions
publish!: Public ordinary functions

R
redirect!: Public ordinary functions
resource: Public generic functions
resource: Public generic functions
response-code: Private generic functions
response-code: Private generic functions
rest-var?: Private ordinary functions

S
session: Public generic functions
session: Public generic functions
session-tokens: Private generic functions
session-tokens: Private generic functions
session-values: Private generic functions
session-values: Private generic functions
socket-of: Public generic functions
socket-of: Public generic functions
split-at: Private ordinary functions
sse-data: Private ordinary functions
sse-event: Private ordinary functions
sse-id: Private ordinary functions
sse-p: Private ordinary functions
sse-retry: Private ordinary functions
start: Public ordinary functions
started: Private generic functions
started: Private generic functions
stream-handler: Public macros
subscribe!: Public ordinary functions
subscribers-of: Public ordinary functions

T
token: Private generic functions
token: Private generic functions
trie-insert!: Private ordinary functions
trie-lookup: Private ordinary functions
trie-map: Private ordinary functions
trie-p: Private ordinary functions
trie-rest: Private ordinary functions
trie-value: Private ordinary functions
trie-vars: Private ordinary functions

V
var-annotation: Private ordinary functions
var-key: Private ordinary functions

W
with-handler-table: Public macros
write-ln: Private ordinary functions
write-response!: Private ordinary functions
write-sse!: Private ordinary functions

Jump to:   (   -   >  
A   B   C   D   E   F   G   H   I   K   L   M   N   P   R   S   T   V   W  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *   +  
A   B   C   D   E   F   H   I   K   L   M   P   R   S   T   V  
Index Entry  Section

*
*channels*: Private special variables
*cookie-domains*: Private special variables
*handler-table*: Private special variables
*mimetype-table*: Private special variables
*new-session-hook*: Private special variables
*sessions*: Private special variables

+
+400+: Private special variables
+404+: Private special variables
+413+: Private special variables
+500+: Private special variables
+clean-sessions-every+: Private special variables
+max-buffer-tries+: Private special variables
+max-request-age+: Private special variables
+max-request-size+: Private special variables
+max-session-idle+: Private special variables

A
assertion: Private conditions

B
bi-stream: Private structures
body: Private classes

C
cache-control: Private classes
charset: Private classes
closing?: Private structures
content-type: Private classes
contents: Private structures
cookie: Private classes

D
data: Private structures

E
event: Private structures
expecting: Private structures
expires: Private classes

F
fn: Private structures

H
headers: Public classes
headers: Private classes
http-method: Public classes

I
id: Private structures

K
keep-alive?: Private classes

L
last-poked: Public classes
location: Private classes

M
map: Private structures

P
parameters: Public classes

R
request: Private structures
resource: Public classes
response-code: Private classes
rest: Private structures
retry: Private structures

S
session: Public classes
session-tokens: Public classes
session-values: Public classes
Slot, assertion: Private conditions
Slot, bi-stream: Private structures
Slot, body: Private classes
Slot, cache-control: Private classes
Slot, charset: Private classes
Slot, closing?: Private structures
Slot, content-type: Private classes
Slot, contents: Private structures
Slot, cookie: Private classes
Slot, data: Private structures
Slot, event: Private structures
Slot, expecting: Private structures
Slot, expires: Private classes
Slot, fn: Private structures
Slot, headers: Public classes
Slot, headers: Private classes
Slot, http-method: Public classes
Slot, id: Private structures
Slot, keep-alive?: Private classes
Slot, last-poked: Public classes
Slot, location: Private classes
Slot, map: Private structures
Slot, parameters: Public classes
Slot, request: Private structures
Slot, resource: Public classes
Slot, response-code: Private classes
Slot, rest: Private structures
Slot, retry: Private structures
Slot, session: Public classes
Slot, session-tokens: Public classes
Slot, session-values: Public classes
Slot, socket-of: Public classes
Slot, started: Public classes
Slot, started: Private structures
Slot, token: Public classes
Slot, total-buffered: Private structures
Slot, tries: Private structures
Slot, value: Private structures
Slot, vars: Private structures
socket-of: Public classes
Special Variable, *channels*: Private special variables
Special Variable, *cookie-domains*: Private special variables
Special Variable, *handler-table*: Private special variables
Special Variable, *mimetype-table*: Private special variables
Special Variable, *new-session-hook*: Private special variables
Special Variable, *sessions*: Private special variables
Special Variable, +400+: Private special variables
Special Variable, +404+: Private special variables
Special Variable, +413+: Private special variables
Special Variable, +500+: Private special variables
Special Variable, +clean-sessions-every+: Private special variables
Special Variable, +max-buffer-tries+: Private special variables
Special Variable, +max-request-age+: Private special variables
Special Variable, +max-request-size+: Private special variables
Special Variable, +max-session-idle+: Private special variables
started: Public classes
started: Private structures

T
token: Public classes
total-buffered: Private structures
tries: Private structures

V
value: Private structures
vars: Private structures

Jump to:   *   +  
A   B   C   D   E   F   H   I   K   L   M   P   R   S   T   V  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   B   C   D   F   H   M   P   R   S   T   U  
Index Entry  Section

B
buffer: Private structures
buffer.lisp: The house/src/buffer․lisp file

C
channel.lisp: The house/src/channel․lisp file
Class, request: Public classes
Class, response: Private classes
Class, session: Public classes
Condition, http-assertion-error: Private conditions

D
define-handler.lisp: The house/src/define-handler․lisp file

F
File, buffer.lisp: The house/src/buffer․lisp file
File, channel.lisp: The house/src/channel․lisp file
File, define-handler.lisp: The house/src/define-handler․lisp file
File, handler-table.lisp: The house/src/handler-table․lisp file
File, house.asd: The house/house․asd file
File, house.lisp: The house/src/house․lisp file
File, package.lisp: The house/src/package․lisp file
File, request.lisp: The house/src/request․lisp file
File, response.lisp: The house/src/response․lisp file
File, session.lisp: The house/src/session․lisp file
File, util.lisp: The house/src/util․lisp file

H
handler-entry: Private structures
handler-table.lisp: The house/src/handler-table․lisp file
house: The house system
house: The house package
house.asd: The house/house․asd file
house.lisp: The house/src/house․lisp file
http-assertion-error: Private conditions

M
Module, src: The house/src module

P
Package, house: The house package
package.lisp: The house/src/package․lisp file

R
request: Public classes
request.lisp: The house/src/request․lisp file
response: Private classes
response.lisp: The house/src/response․lisp file

S
session: Public classes
session.lisp: The house/src/session․lisp file
src: The house/src module
sse: Private structures
Structure, buffer: Private structures
Structure, handler-entry: Private structures
Structure, sse: Private structures
Structure, trie: Private structures
System, house: The house system

T
trie: Private structures

U
util.lisp: The house/src/util․lisp file

Jump to:   B   C   D   F   H   M   P   R   S   T   U