The cl-async Reference Manual

Exported Definitions

*buffer-size* (special variable)
*buffer-writes* (special variable)
*data-registry* (special variable)
*enable-threading* (special variable)
*event-base* (special variable)
*event-base-next-id* (special variable)
*function-registry* (special variable)
*input-buffer* (special variable)
*output-buffer* (special variable)
*safe-sldb-quit-restart* (special variable)
event-base (class)
event-base-c (method)
(setf event-base-c) (method)
event-base-catch-app-errors (method)
(setf event-base-catch-app-errors) (method)
event-base-data-registry (method)
(setf event-base-data-registry) (method)
event-base-dns-base (method)
(setf event-base-dns-base) (method)
event-base-dns-ref-count (method)
(setf event-base-dns-ref-count) (method)
event-base-exit-functions (method)
(setf event-base-exit-functions) (method)
event-base-function-registry (method)
(setf event-base-function-registry) (method)
event-base-id (method)
(setf event-base-id) (method)
event-base-lock (method)
(setf event-base-lock) (method)
event-base-num-connections-in (method)
(setf event-base-num-connections-in) (method)
event-base-num-connections-out (method)
(setf event-base-num-connections-out) (method)
event-base-send-errors-to-eventcb (method)
(setf event-base-send-errors-to-eventcb) (method)
event-base-signal-handlers (method)
(setf event-base-signal-handlers) (method)
event-errcode (method)
event-errmsg (method)
event-error (condition)
event-info (condition)

5 Packages

Packages are listed by definition order.

5.1 `cl-async`

Source

package.lisp (file)

Nickname

as

Use List

trivial-gray-streams
cl-async-util
cl-async-base
common-lisp

Exported Definitions

+sigabrt+ (constant)
+sigalrm+ (constant)
+sigbus+ (constant)
+sigchld+ (constant)
+sigcont+ (constant)
+sigemt+ (constant)
+sigfpe+ (constant)
+sighup+ (constant)
+sigill+ (constant)
+siginfo+ (constant)
+sigint+ (constant)
+sigio+ (constant)
+sigkill+ (constant)
+sigpipe+ (constant)
+sigprof+ (constant)
+sigquit+ (constant)
+sigsegv+ (constant)
+sigstop+ (constant)
+sigsys+ (constant)
+sigterm+ (constant)
+sigtrap+ (constant)
+sigtstp+ (constant)
+sigttin+ (constant)
+sigttou+ (constant)
+sigurg+ (constant)
+sigusr1+ (constant)
+sigusr2+ (constant)
+sigvtalrm+ (constant)
+sigwinch+ (constant)
+sigxcpu+ (constant)
+sigxfsz+ (constant)
add-event (function)
add-event-loop-exit-callback (function)
async-input-stream (class)
async-io-stream (class)
async-output-stream (class)
async-stream (class)
check-streamish-open (function)
clear-signal-handlers (function)
close-socket (function)
close-socket-server (generic function)
close-socket-server (method)
close-streamish (generic function)
close-streamish (method)
close-streamish (method)
close-streamish (method)
close-tcp-server (function)
connect-tcp-socket (function)
delay (function)
disable-socket (function)
dns-error (condition)
dns-lookup (function)
dump-event-loop-status (function)
enable-socket (function)
event (class)
event-c (generic function)
event-c (method)
(setf event-c) (method)
(setf event-c) (generic function)
event-freed (generic function)
event-freed (method)
(setf event-freed) (method)
(setf event-freed) (generic function)
event-freed (condition)
event-freed-p (generic function)
event-freed-p (method)
exit-event-loop (function)
filesystem-eacces (condition)
filesystem-enoent (condition)
filesystem-eperm (condition)
filesystem-error (condition)
free-event (function)
free-idler (function)
free-notifier (function)
free-poller (function)
free-signal-handler (function)
fs-monitor-close (function)
fs-unwatch (function)
fs-watch (function)
idle (function)
idler (class)
idler-freed-p (generic function)
idler-freed-p (method)
interval (function)
make-event (function)
make-notifier (function)
mkdtemp (function)
notifier (class)
notifier-freed-p (generic function)
notifier-freed-p (method)
pipe-connect (function)
pipe-server (function)
pipe-server (class)
poll (function)
poller (class)
poller-freed-p (generic function)
poller-freed-p (method)
process-error-output (generic function)
process-error-output (method)
(setf process-error-output) (method)
(setf process-error-output) (generic function)
process-input (generic function)
process-input (method)
(setf process-input) (method)
(setf process-input) (generic function)
process-kill (function)
process-output (generic function)
process-output (method)
(setf process-output) (method)
(setf process-output) (generic function)
ref (generic function)
ref (method)
ref (method)
remove-event (function)
remove-interval (function)
reverse-dns-lookup (function)
set-socket-timeouts (function)
signal-handler (function)
socket (generic function)
socket (method)
socket (method)
(setf socket) (method)
(setf socket) (generic function)
socket (class)
socket-aborted (condition)
socket-accept-error (condition)
socket-accept-error-listener (generic function)
socket-accept-error-listener (method)
(setf socket-accept-error-listener) (method)
(setf socket-accept-error-listener) (generic function)
socket-address-in-use (condition)
socket-c (generic function)
socket-c (method)
(setf socket-c) (method)
(setf socket-c) (generic function)
socket-closed (generic function)
socket-closed (method)
(setf socket-closed) (method)
(setf socket-closed) (generic function)
socket-closed (condition)
socket-closed-p (function)
socket-data (generic function)
socket-data (method)
(setf socket-data) (method)
(setf socket-data) (generic function)
socket-eof (condition)
socket-error (condition)
socket-info (condition)
socket-refused (condition)
socket-reset (condition)
socket-timeout (condition)
spawn (function)
start-event-loop (function)
stats (function)
stream-socket (function)
streamish (generic function)
streamish (method)
streamish (method)
streamish (method)
(setf streamish) (generic function)
(setf streamish) (method)
(setf streamish) (method)
streamish (class)
streamish-broken-pipe (condition)
streamish-canceled (condition)
streamish-closed (generic function)
streamish-closed (method)
(setf streamish-closed) (method)
(setf streamish-closed) (generic function)
streamish-closed (condition)
streamish-closed-p (function)
streamish-eof (condition)
streamish-error (condition)
streamish-info (condition)
streamish-write (generic function)
streamish-write (method)
streamish-write (method)
streamish-write (method)
tcp-accept-error (condition)
tcp-connect (function)
tcp-eof (condition)
tcp-error (condition)
tcp-info (condition)
tcp-refused (condition)
tcp-reset (condition)
tcp-server (function)
tcp-server (class)
tcp-server-bind-error (condition)
tcp-socket (generic function)
tcp-socket (method)
(setf tcp-socket) (method)
(setf tcp-socket) (generic function)
tcp-socket (class)
tcp-timeout (condition)
trigger-notifier (function)
unref (generic function)
unref (method)
unref (method)
with-delay (macro)
with-event-loop (macro)
with-interval (macro)
write-socket-data (function)

Internal Definitions

%fs-monitor-close (function)
%pipe-connect (function)
*event-base-registry* (special variable)
*event-base-registry-lock* (special variable)
*loop-close-iters* (special variable)
async-cb (function)
async-close-cb (function)
check-event-loop-running (function)
check-event-unfreed (function)
check-notifier-unfreed (function)
check-socket-open (function)
dns-cb (function)
do-close-loop (function)
do-close-streamish (function)
errno-event (generic function)
errno-event (method)
errno-event (method)
errno-event (method)
errno-event (method)
errno-event (method)
errno-event (method)
errno-event (method)
errno-event (method)
errno-event (method)
errno-event (method)
errno-event (method)
errno-event (method)
errno-event (method)
errno-event (method)
errno-event (method)
event-freed-event (generic function)
event-freed-event (method)
(setf event-freed-event) (method)
(setf event-freed-event) (generic function)
event-handler (function)
fs-cb (function)
fs-event-callback (function)
fs-monitor (class)
fs-monitor-c (generic function)
fs-monitor-c (method)
(setf fs-monitor-c) (method)
(setf fs-monitor-c) (generic function)
fs-monitor-close-cb (function)
handle-cleanup (generic function)
handle-cleanup (method)
handle-cleanup (method)
handle-cleanup (method)
handle-cleanup (method)
handle-cleanup (method)
handle-cleanup (method)
handle-cleanup (method)
handle-cleanup (method)
idle-cb (function)
idle-close-cb (function)
idler-c (generic function)
idler-c (method)
(setf idler-c) (method)
(setf idler-c) (generic function)
idler-freed (generic function)
idler-freed (method)
(setf idler-freed) (method)
(setf idler-freed) (generic function)
init-client-socket (function)
init-incoming-socket (function)
init-stdio-container (function)
lisp-signal-cb (function)
loop-exit-walk-cb (function)
make-socket-handle (generic function)
make-socket-handle (method)
make-socket-handle (method)
notifier-c (generic function)
notifier-c (method)
(setf notifier-c) (method)
(setf notifier-c) (generic function)
notifier-freed (generic function)
notifier-freed (method)
(setf notifier-freed) (method)
(setf notifier-freed) (generic function)
notifier-freed (condition)
notifier-freed-notifier (generic function)
notifier-freed-notifier (method)
(setf notifier-freed-notifier) (method)
(setf notifier-freed-notifier) (generic function)
notifier-single-shot (generic function)
notifier-single-shot (method)
(setf notifier-single-shot) (method)
(setf notifier-single-shot) (generic function)
notifier-single-shot-p (generic function)
notifier-single-shot-p (method)
pipe (class)
pipe-mixin (class)
poll-cb (function)
poll-close-cb (function)
poller-c (generic function)
poller-c (method)
(setf poller-c) (method)
(setf poller-c) (generic function)
poller-freed (generic function)
poller-freed (method)
(setf poller-freed) (method)
(setf poller-freed) (generic function)
process (class)
process-c (generic function)
process-c (method)
(setf process-c) (method)
(setf process-c) (generic function)
process-close (function)
process-close-cb (function)
process-event-loop-exit-callbacks (function)
process-exit-cb (function)
reverse-dns-cb (function)
send-buffered-data (generic function)
send-buffered-data (method)
server-socket-class (generic function)
server-socket-class (method)
server-socket-class (method)
set-lisp-signal-handler (function)
signal-cb (function)
signal-close-cb (function)
signal-pointer (function)
socket-accept-cb (function)
socket-accept-error-server (generic function)
socket-accept-error-server (method)
(setf socket-accept-error-server) (method)
(setf socket-accept-error-server) (generic function)
socket-buffer (generic function)
socket-buffer (method)
(setf socket-buffer) (method)
(setf socket-buffer) (generic function)
socket-buffering-p (generic function)
socket-buffering-p (method)
(setf socket-buffering-p) (method)
(setf socket-buffering-p) (generic function)
socket-connect-cb (function)
socket-connected (generic function)
socket-connected (method)
(setf socket-connected) (method)
(setf socket-connected) (generic function)
socket-direction (generic function)
socket-direction (method)
(setf socket-direction) (method)
(setf socket-direction) (generic function)
socket-drain-read-buffer (generic function)
socket-drain-read-buffer (method)
(setf socket-drain-read-buffer) (method)
(setf socket-drain-read-buffer) (generic function)
socket-server (function)
socket-server (class)
socket-server-bind (generic function)
socket-server-bind (method)
socket-server-bind (method)
socket-server-c (generic function)
socket-server-c (method)
(setf socket-server-c) (method)
(setf socket-server-c) (generic function)
socket-server-closed (generic function)
socket-server-closed (method)
(setf socket-server-closed) (method)
(setf socket-server-closed) (generic function)
socket-server-stream (generic function)
socket-server-stream (method)
(setf socket-server-stream) (method)
(setf socket-server-stream) (generic function)
stream-append-bytes (generic function)
stream-append-bytes (method)
stream-buffer (generic function)
stream-buffer (method)
(setf stream-buffer) (method)
(setf stream-buffer) (generic function)
stream-output-type (generic function)
stream-output-type (method)
streamish-alloc-cb (function)
streamish-c (generic function)
streamish-c (method)
(setf streamish-c) (method)
(setf streamish-c) (generic function)
streamish-close-cb (function)
streamish-convert-data (function)
streamish-data (generic function)
streamish-data (method)
(setf streamish-data) (method)
(setf streamish-data) (generic function)
streamish-drain-read-buffer (generic function)
streamish-drain-read-buffer (method)
(setf streamish-drain-read-buffer) (method)
(setf streamish-drain-read-buffer) (generic function)
streamish-read-cb (function)
streamish-read-start (function)
streamish-shutdown-cb (function)
streamish-write-cb (function)
tcp-connect-new (function)
tcp-mixin (class)
tcp-server-bind-error-addr (generic function)
tcp-server-bind-error-addr (method)
(setf tcp-server-bind-error-addr) (method)
(setf tcp-server-bind-error-addr) (generic function)
tcp-server-bind-error-port (generic function)
tcp-server-bind-error-port (method)
(setf tcp-server-bind-error-port) (method)
(setf tcp-server-bind-error-port) (generic function)
tcp-server-closed (function)
tcp-server-new (function)
timer-cb (function)
timer-close-cb (function)
walk-cb (function)
write-pending-socket-data (generic function)
write-pending-socket-data (method)
write-to-uvstream (function)

5.2 `cl-async-util`

Source

src/util/package.lisp (file)

Use List

cl-async-base
common-lisp

Used By List

Exported Definitions

*ipv4-scanner* (special variable)
*ipv6-scanner* (special variable)
*passthrough-errors* (special variable)
+af-inet+ (constant)
+af-inet6+ (constant)
+af-unix+ (constant)
+af-unspec+ (constant)
addrinfo-to-string (function)
append-array (function)
attach-data-to-pointer (function)
buffer-output (function)
bytes (function)
bytes-or-string (type)
call-with-callback-restarts (function)
callback (type)
catch-app-errors (macro)
clear-callbacks (function)
clear-pointer-data (function)
create-data-pointer (function)
define-c-callback (macro)
define-condition-alias (macro)
deref-data-from-pointer (function)
do-chunk-data (function)
error-str (function)
fd-connected-p (function)
free-pointer-data (function)
get-callbacks (function)
handle-error (generic function)
handle-error (method)
ip-address-p (function)
ip-str-to-sockaddr (function)
ipv4-address-p (function)
ipv6-address-p (function)
make-buffer (function)
make-pointer-eql-able (function)
octet (type)
octet-vector (type)
passthrough-error-p (function)
run-event-cb (function)
save-callbacks (function)
set-socket-nonblocking (function)
with-foreign-object* (macro)
with-ip-to-sockaddr (macro)
with-lock (macro)
write-to-buffer (function)

Internal Definitions

*evcb-err* (special variable)

5.3 `cl-async-base`

Source

src/base.lisp (file)

Use List

common-lisp

Used By List

cl-async
cl-async-util

Exported Definitions

*buffer-size* (special variable)
*buffer-writes* (special variable)
*data-registry* (special variable)
*enable-threading* (special variable)
*event-base* (special variable)
*event-base-next-id* (special variable)
*function-registry* (special variable)
*input-buffer* (special variable)
*output-buffer* (special variable)
*safe-sldb-quit-restart* (special variable)
event-base (class)
event-base-c (generic function)
event-base-c (method)
(setf event-base-c) (method)
(setf event-base-c) (generic function)
event-base-catch-app-errors (generic function)
event-base-catch-app-errors (method)
(setf event-base-catch-app-errors) (method)
(setf event-base-catch-app-errors) (generic function)
event-base-data-registry (generic function)
event-base-data-registry (method)
(setf event-base-data-registry) (method)
(setf event-base-data-registry) (generic function)
event-base-dns-base (generic function)
event-base-dns-base (method)
(setf event-base-dns-base) (method)
(setf event-base-dns-base) (generic function)
event-base-dns-ref-count (generic function)
event-base-dns-ref-count (method)
(setf event-base-dns-ref-count) (method)
(setf event-base-dns-ref-count) (generic function)
event-base-exit-functions (generic function)
event-base-exit-functions (method)
(setf event-base-exit-functions) (method)
(setf event-base-exit-functions) (generic function)
event-base-function-registry (generic function)
event-base-function-registry (method)
(setf event-base-function-registry) (method)
(setf event-base-function-registry) (generic function)
event-base-id (generic function)
event-base-id (method)
(setf event-base-id) (method)
(setf event-base-id) (generic function)
event-base-lock (generic function)
event-base-lock (method)
(setf event-base-lock) (method)
(setf event-base-lock) (generic function)
event-base-num-connections-in (generic function)
event-base-num-connections-in (method)
(setf event-base-num-connections-in) (method)
(setf event-base-num-connections-in) (generic function)
event-base-num-connections-out (generic function)
event-base-num-connections-out (method)
(setf event-base-num-connections-out) (method)
(setf event-base-num-connections-out) (generic function)
event-base-send-errors-to-eventcb (generic function)
event-base-send-errors-to-eventcb (method)
(setf event-base-send-errors-to-eventcb) (method)
(setf event-base-send-errors-to-eventcb) (generic function)
event-base-signal-handlers (generic function)
event-base-signal-handlers (method)
(setf event-base-signal-handlers) (method)
(setf event-base-signal-handlers) (generic function)
event-errcode (generic function)
event-errcode (method)
event-errmsg (generic function)
event-errmsg (method)
event-error (condition)
event-info (condition)

6 Definitions

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

6.1 Exported definitions

6.1.1 Constants

Constant: +af-inet+

Package: cl-async-util
Source: src/util/foreign.lisp (file)

Constant: +af-inet6+

Package: cl-async-util
Source: src/util/foreign.lisp (file)

Constant: +af-unix+

Package: cl-async-util
Source: src/util/foreign.lisp (file)

Constant: +af-unspec+

Package: cl-async-util
Source: src/util/foreign.lisp (file)

Constant: +sigabrt+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigalrm+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigbus+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigchld+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigcont+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigemt+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigfpe+

Package: cl-async
Source: signal.lisp (file)

Constant: +sighup+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigill+

Package: cl-async
Source: signal.lisp (file)

Constant: +siginfo+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigint+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigio+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigkill+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigpipe+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigprof+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigquit+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigsegv+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigstop+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigsys+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigterm+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigtrap+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigtstp+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigttin+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigttou+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigurg+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigusr1+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigusr2+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigvtalrm+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigwinch+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigxcpu+

Package: cl-async
Source: signal.lisp (file)

Constant: +sigxfsz+

Package: cl-async
Source: signal.lisp (file)

6.1.2 Special variables

Special Variable: *buffer-size*

The amount of data we’ll pull from the evbuffers when doing reading/writing.

Package: cl-async-base
Source: src/base.lisp (file)

Special Variable: *buffer-writes*

If T, will buffer writes on the socket until the next loop. This is mainly to cut down on calls to uv_write, which is fairly slow.

Package: cl-async-base
Source: src/base.lisp (file)

Special Variable: *data-registry*

A hash table holding C pointer -> lisp data mappings.

Package: cl-async-base
Source: src/base.lisp (file)

Special Variable: *enable-threading*

If true, various pieces of the cl-async internals will lock their restecpive structures before operating to ensure thread safety.

Package: cl-async-base
Source: src/base.lisp (file)

Special Variable: *event-base*

THE event base object used to process all async operations.

Package: cl-async-base
Source: src/base.lisp (file)

Special Variable: *event-base-next-id*

The numeric identifier assigned to each new event base.

Package: cl-async-base
Source: src/base.lisp (file)

Special Variable: *function-registry*

A hash table holding C pointer -> lisp function(s) mappings.

Package: cl-async-base
Source: src/base.lisp (file)

Special Variable: *input-buffer*

A buffer that lives in both C and lisp worlds (static-vector) that lets us read from sockets.

Package: cl-async-base
Source: src/base.lisp (file)

Special Variable: *ipv4-scanner*

Scanner that detects if a string is an IPV4 address.

Package: cl-async-util
Source: src/util/helpers.lisp (file)

Special Variable: *ipv6-scanner*

Scanner that detects if a string is an IPV6 address.

Package: cl-async-util
Source: src/util/helpers.lisp (file)

Special Variable: *output-buffer*

A buffer that lives in both C and lisp worlds (static-vector) that lets us write to sockets.

Package: cl-async-base
Source: src/base.lisp (file)

Special Variable: *passthrough-errors*

Package: cl-async-util
Source: src/util/error.lisp (file)

Special Variable: *safe-sldb-quit-restart*

If true, provides a safe default for SLIME debugger quit restart (ABORT-CALLBACK). This restart causes the callback to be aborted without quitting the event loop. If false, the default restart is set to EXIT-EVENT-LOOP.

Package: cl-async-base
Source: src/base.lisp (file)

6.1.3 Macros

Macro: catch-app-errors EVENT-CB &body BODY

Handle error conditions by directing them to the specified event callback or default event handler of the current event loop, if catching app errors is enabled for the current event loop via EVENT-BASE-CATCH-APP-ERRORS, otherwise just evaluate the BODY.

If event-cbs are called via run-event-cb, make sure the event-cb is NOT double-called with the same condition twice.

Package: cl-async-util
Source: src/util/error.lisp (file)

Macro: define-c-callback NAME RETURN-VAL (&rest ARGS) &body BODY

Define a top-level function with the given and also define a C callback that calls the function directly. The idea is that CFFI callbacks aren’t directly callable/debuggable, but it’s obnoxious to have to define and callback *and* a function right next to each other.

Package: cl-async-util
Source: src/util/foreign.lisp (file)

Macro: define-condition-alias ALIAS NAME

Define an alias for the specified condition.

Package: cl-async-util
Source: src/util/helpers.lisp (file)

Macro: with-delay (&optional SECONDS) &body BODY

Nicer syntax for delay function.

Package: cl-async
Source: event.lisp (file)

Macro: with-event-loop (&key CATCH-APP-ERRORS SEND-ERRORS-TO-EVENTCB) &body BODY

Makes starting an event loop a tad less annoying. I really couldn’t take typing out ‘(start-event-loop (lambda () ...) ...) every time. Example:

(with-event-loop (:catch-app-errors t) (do-something-one-does-when-an-event-loop-is-running))

See how nice that is?

Package: cl-async
Source: event-loop.lisp (file)

Macro: with-foreign-object* (VAR TYPE &key ZERO INITIAL) BINDINGS &body BODY

Convenience macro, makes creation and initialization of CFFI types easier. Emphasis on initialization.

Package: cl-async-util
Source: src/util/foreign.lisp (file)

Macro: with-interval (SECONDS) &body BODY

Nicer syntax for interval function.

Package: cl-async
Source: event.lisp (file)

Macro: with-ip-to-sockaddr ((BIND) ADDRESS PORT) &body BODY

Wraps around ipv4-str-to-sockaddr. Converts a string address and port and creates a sockaddr-in object, runs the body with it bound, and frees it.

Package: cl-async-util
Source: src/util/foreign.lisp (file)

Macro: with-lock &body BODY

If threading is enabled, locks the current event loop before processing body and releases the lock after body is finished.

Package: cl-async-util
Source: src/util/helpers.lisp (file)

6.1.4 Functions

Function: add-event EVENT &key TIMEOUT ACTIVATE

Add an event to its specified event loop (make it pending). If given a :timeout (in seconds) the event will fire after that amount of time, unless it’s removed or freed.

Package: cl-async
Source: event.lisp (file)

Function: add-event-loop-exit-callback FN

Add a function to be run when the event loop exits.

Package: cl-async
Source: event-loop.lisp (file)

Function: addrinfo-to-string ADDRINFO

Given a (horrible) addrinfo C object pointer, grab either an IP4 or IP6 address and return is as a string.

Package: cl-async-util
Source: src/util/foreign.lisp (file)

Function: append-array ARR1 ARR2

Create an array, made up of arr1 followed by arr2.

Package: cl-async-util
Source: src/util/helpers.lisp (file)

Function: attach-data-to-pointer POINTER DATA

Attach a lisp object to a foreign pointer.

Package: cl-async-util
Source: src/util/helpers.lisp (file)

Function: buffer-output BUFFER

Grab the output from a buffer created with (make-buffer).

Package: cl-async-util
Source: src/util/helpers.lisp (file)

Function: bytes VECTOR

Convert any vector/string into a byte array. Useful for sending direct byte data into write-socket-data.

Package: cl-async-util
Source: src/util/helpers.lisp (file)

Function: call-with-callback-restarts THUNK &key CONTINUE-FN ABORT-RESTART-DESCRIPTION

Call thunk with restarts that make it possible to ignore the callback in case of an error or safely terminate the event loop.

If SWANK is active, set SLDB’s quit restart to ABORT-CALLBACK restart if *safe-sldb-quit-restart* is true or EXIT-EVENT-LOOP otherwise.

Package: cl-async-util
Source: src/util/error.lisp (file)

Function: check-streamish-open STREAMISH

Throw a streamish-closed condition if given a streamish that’s closed.

Package: cl-async
Source: streamish.lisp (file)

Function: clear-callbacks POINTER

Clear out all callbacks for the given pointer.

Package: cl-async-util
Source: src/util/helpers.lisp (file)

Function: clear-pointer-data POINTER

Clear the data attached to a CFFI pointer.

Package: cl-async-util
Source: src/util/helpers.lisp (file)

Function: clear-signal-handlers ()

Clear all bound signal handlers. Great for cleaning up when exiting an app.

Package: cl-async
Source: signal.lisp (file)

Function: close-socket SOCKET &key FORCE

Free a socket (uvstream) and clear out all associated data. Same as close-streamish.

Package: cl-async
Source: socket.lisp (file)

Function: close-tcp-server SERVER

Package: cl-async
Source: tcp.lisp (file)

Function: connect-tcp-socket SOCKET/STREAM HOST PORT &key EVENT-CB

Connect a tcp socket initialized with init-client-socket.

Package: cl-async
Source: tcp.lisp (file)

Function: create-data-pointer ()

Creates a pointer in C land that can be used to attach data/callbacks to. Note that this must be freed via clear-pointer-data.

Package: cl-async-util
Source: src/util/helpers.lisp (file)

Function: delay CALLBACK &key TIME EVENT-CB

Run a function, asynchronously, after the specified amount of seconds. An event loop must be running for this to work.

If time is nil, callback is still called asynchronously, but is queued in the event loop with no delay.

Package: cl-async
Source: event.lisp (file)

Function: deref-data-from-pointer POINTER

Grab data attached to a CFFI pointer.

Package: cl-async-util
Source: src/util/helpers.lisp (file)

Function: disable-socket SOCKET &key READ WRITE

Disable read/write monitoring on a socket. If :read or :write are nil, they are not enabled, but rather just not disabled.

Package: cl-async
Source: socket.lisp (file)

Function: dns-lookup HOST RESOLVE-CB &key EVENT-CB FAMILY

Asynchronously lookup a DNS address. Note that if an IP address is passed, the lookup happens synchronously. If a lookup is synchronous (and instant) this returns T, otherwise nil (lookup happening in background). Either way the resolve-cb is called with the lookup info (so always assume this is async).

Package: cl-async
Source: dns.lisp (file)

Function: do-chunk-data DATA BUFFER WRITE-CB &key START END NEW-BUFFER

Util function that splits data into the (length buffer) chunks and calls write-cb for each chunk.

Package: cl-async-util
Source: src/util/helpers.lisp (file)

Function: dump-event-loop-status ()

Return the status of the event loop. Really a debug function more than anything else.

Package: cl-async
Source: event-loop.lisp (file)

Function: enable-socket SOCKET &key READ WRITE

Enable read/write monitoring on a socket. If :read or :write are nil, they are not disabled, but rather just not enabled.

Package: cl-async
Source: socket.lisp (file)

Function: error-str UV-ERRNO

Given a libuv error number, return the error string.

Package: cl-async-util
Source: src/util/foreign.lisp (file)

Function: exit-event-loop ()

Exit the event loop if running.

Package: cl-async
Source: event-loop.lisp (file)

Function: fd-connected-p FD

Check if an FD is connected.

Package: cl-async-util
Source: src/util/foreign.lisp (file)

Function: free-event EVENT

Free a cl-async event object and any resources it uses.

Package: cl-async
Source: event.lisp (file)

Function: free-idler IDLER

Stop and free an idler.

Package: cl-async
Source: idle.lisp (file)

Function: free-notifier NOTIFIER

Free a cl-async notifier object and any resources it uses.

Package: cl-async
Source: notify.lisp (file)

Function: free-pointer-data POINTER &key PRESERVE-POINTER

Clears out all data attached to a foreign pointer, and frees the pointer (unless :preserve-pointer is t).

Package: cl-async-util
Source: src/util/helpers.lisp (file)

Function: free-poller POLLER

Stop and free a poller.

Package: cl-async
Source: poll.lisp (file)

Function: free-signal-handler SIGNO

Clear a signal handler and unbind it.

Package: cl-async
Source: signal.lisp (file)

Function: fs-monitor-close FS-MONITOR

Package: cl-async
Source: fsevent.lisp (file)

Function: fs-unwatch FS-MONITOR

Package: cl-async
Source: fsevent.lisp (file)

Function: fs-watch PATH CALLBACK &key EVENT-CB

Package: cl-async
Source: fsevent.lisp (file)

Function: get-callbacks POINTER

Get all callbacks for the given pointer.

Package: cl-async-util
Source: src/util/helpers.lisp (file)

Function: idle CALLBACK &key EVENT-CB

Calls ‘callback‘ once per event loop.

Package: cl-async
Source: idle.lisp (file)

Function: interval CALLBACK &key TIME EVENT-CB

Run a function, asynchronously, every ‘time‘ seconds. This function returns a function which, when called, cancels the interval.

Package: cl-async
Source: event.lisp (file)

Function: ip-address-p ADDR

Determine if the given host is an IP or a hostname.

Package: cl-async-util
Source: src/util/helpers.lisp (file)

Function: ip-str-to-sockaddr ADDRESS PORT

Convert a string IP address and port into a sockaddr-in struct. Must be freed by the app!

Package: cl-async-util
Source: src/util/foreign.lisp (file)

Function: ipv4-address-p ADDR

Determine if the given host is an IPV4 addr or a hostname.

Package: cl-async-util
Source: src/util/helpers.lisp (file)

Function: ipv6-address-p ADDR

Determine if the given host is an IPV6 addr or a hostname.

Package: cl-async-util
Source: src/util/helpers.lisp (file)

Function: make-buffer &optional DATA

Create an octet buffer, optoinally filled with the given data.

Package: cl-async-util
Source: src/util/helpers.lisp (file)

Function: make-event CALLBACK &key EVENT-CB

Make an arbitrary event, and add it to the event loop. It *must* be triggered by (add-event <the event> :activate t) or it will sit, idle, for 100 years. Or you can remove/free it instead.

This is useful for triggering arbitrary events, and can even be triggered from a thread outside the libuv loop.

Package: cl-async
Source: event.lisp (file)

Function: make-notifier CALLBACK &key EVENT-CB SINGLE-SHOT

Makes a notifier, an object that can trigger a callback from a thread other than the event loop thread. If single-shot is true (the default), free the notifier after it’s triggered.

Package: cl-async
Source: notify.lisp (file)

Function: make-pointer-eql-able POINTER

Abstraction to make a CFFI pointer #’eql to itself. Does its best to be the most performant for the current implementation.

Package: cl-async-util
Source: src/util/helpers.lisp (file)

Function: mkdtemp TEMPLATE CB &key EVENT-CB

Package: cl-async
Source: filesystem.lisp (file)

Function: passthrough-error-p E

Return true if the specified error condition should not be intercepted by cl-async error handling mechanism.

Package: cl-async-util
Source: src/util/error.lisp (file)

Function: pipe-connect NAME READ-CB &key DATA STREAM EVENT-CB CONNECT-CB WRITE-CB READ-TIMEOUT WRITE-TIMEOUT DONT-DRAIN-READ-BUFFER

Open a pipe connection asynchronously. Optionally send data out once connected via the :data keyword (can be a string or byte array).

Package: cl-async
Source: pipe.lisp (file)

Function: pipe-server NAME READ-CB &key EVENT-CB CONNECT-CB BACKLOG STREAM FD

Start a pipe listener on the current event loop. Returns a tcp-server class which can be closed with close-tcp-server

Package: cl-async
Source: pipe.lisp (file)

Function: poll FD POLL-CB &key EVENT-CB POLL-FOR SOCKET

Poll an OS FD. If the FD is a socket, :socket t must be passed.

Package: cl-async
Source: poll.lisp (file)

Function: process-kill PROCESS SIGNAL &key EVENT-CB

If PROCESS is active, send the specified signal (an integer) to it and return true. If PROCESS is not active or an error occurs (and EVENT-CB doesn’t
signal an error), return false. If EVENT-CB is specified, use it
to handle errors, otherwise signal them via ERROR.

Package: cl-async
Source: process.lisp (file)

Function: remove-event EVENT

Remove a pending event from the event loop.

Package: cl-async
Source: event.lisp (file)

Function: remove-interval INTERVAL-FN

Stops an interval from looping.

Package: cl-async
Source: event.lisp (file)

Function: reverse-dns-lookup IP RESOLVE-CB &key EVENT-CB

Perform reverse DNS lookup on IP specifier as string. Call RESOLVE-CB with resolved HOST and SERVICE as strings. The callback is called once with one host, even if multiple hosts match the query.

Package: cl-async
Source: dns.lisp (file)

Function: run-event-cb EVENT-CB &rest ARGS

When used in the dynamic context of catch-app-errors, wraps the calling of an event-cb with args such that errors are caught and saved, ensuring that an event-cb isn’t called twice with the same condition. When used outside the dynamic context of catch-app-errors, just invokes event-cb with args.

Package: cl-async-util
Source: src/util/error.lisp (file)

Function: save-callbacks POINTER CALLBACKS

Save a set of callbacks, keyed by the given pointer.

Package: cl-async-util
Source: src/util/helpers.lisp (file)

Function: set-socket-nonblocking FD

Sets an FD into non-blocking mode.

Package: cl-async-util
Source: src/util/foreign.lisp (file)

Function: set-socket-timeouts SOCKET READ-SEC WRITE-SEC &key SOCKET-IS-UVSTREAM

Set the read/write timeouts on a socket.

Package: cl-async
Source: socket.lisp (file)

Function: signal-handler SIGNO SIGNAL-CB &key EVENT-CB

Setup a one-time signal handler for the given signo. This also sets up a lisp signal handler, so if a signal comes through while lisp is running instead of the event loop, it will run the same callback. All signal handlers are restored on event loop exit.

Package: cl-async
Source: signal.lisp (file)

Function: socket-closed-p SOCKET

Return whether a socket is closed or not. Same as streamish-closed-p.

Package: cl-async
Source: socket.lisp (file)

Function: spawn PATH ARGS &key EXIT-CB EVENT-CB INPUT OUTPUT ERROR-OUTPUT

Run the program specified by PATH with specified ARGS.
ARGS don’t include the executable path (argv[0]). Return process object and pipes or streams for input, output and error output file descriptors of the child process (NIL for file descriptors that aren’t redirected via :PIPE or :STREAM, see below).

EXIT-CB specifies the callback that should be called when the program terminates. It should be a function taking three arguments: process object, exit status and signal number that caused program termination (0 if the program wasn’t terminated by signal).

EVENT-CB specifies error handler to be used.

INPUT, OUTPUT and ERROR-OUTPUT specify process input/output/error output redirection. For each of these, the following values are supported:

:IGNORE the corresponding file descriptor isn’t used
:INHERIT inherit file descriptor from this process
(:PIPE [:READ-CB ...] ...) use pipe-based redirection of the corresponding file descriptor (see PIPE-CONNECT for the set of supported keyword arguments).
(:STREAM [:READ-CB ...] ...) same as PIPE, but uses async stream instead of a pipe.

Package: cl-async
Source: process.lisp (file)

Function: start-event-loop START-FN &key CATCH-APP-ERRORS SEND-ERRORS-TO-EVENTCB

Simple wrapper function that starts an event loop which runs the given callback, most likely to init your server/client.

Package: cl-async
Source: event-loop.lisp (file)

Function: stats ()

Return statistics about the current event loop.

Package: cl-async
Source: event-loop.lisp (file)

Function: stream-socket STREAM

Package: cl-async
Source: async-stream.lisp (file)

Function: streamish-closed-p STREAMISH

Return whether a streamish is closed or not.

Package: cl-async
Source: streamish.lisp (file)

Function: tcp-connect HOST PORT READ-CB &rest ARGS

Open a TCP connection asynchronously. Optionally send data out once connected via the :data keyword (can be a string or byte array).

Package: cl-async
Source: tcp.lisp (file)

Function: tcp-server BIND-ADDRESS PORT READ-CB &rest ARGS

Open a TCP connection asynchronously. Optionally send data out once connected via the :data keyword (can be a string or byte array).

Package: cl-async
Source: tcp.lisp (file)

Function: trigger-notifier NOTIFIER

Fires the callback attached to a notifier. Can be called from any thread.

Package: cl-async
Source: notify.lisp (file)

Function: write-socket-data SOCKET DATA &rest ARGS &key &allow-other-keys

An compatibility alias for STREAMISH-WRITE.

Package: cl-async
Source: socket.lisp (file)

Function: write-to-buffer SEQ BUFFER &optional START END

Write data to a buffer created with (make-buffer).

Package: cl-async-util
Source: src/util/helpers.lisp (file)

6.1.5 Generic functions

Generic Function: close-socket-server SOCKET

Closes a socket server. If already closed, does nothing.

Package

Source

socket.lisp (file)

Methods

Method: close-socket-server (SOCKET-SERVER socket-server)

Generic Function: close-streamish STREAMISH &key FORCE &allow-other-keys

Free a streamish (uvstream) and clear out all associated data.

Package

Source

streamish.lisp (file)

Methods

Method: close-streamish (SOCKET tcp-socket) &key &allow-other-keys after

Source: tcp.lisp (file)

Method: close-streamish (SOCKET socket) &key FORCE &allow-other-keys

Source: socket.lisp (file)

Method: close-streamish (STREAMISH streamish) &key FORCE: Close and free a streamish and all of it’s underlying structures.

Generic Function: event-base-c OBJECT

Generic Function: (setf event-base-c) NEW-VALUE OBJECT

Package

Methods

Method: event-base-c (EVENT-BASE event-base)

Method: (setf event-base-c) NEW-VALUE (EVENT-BASE event-base)

Holds the C object pointing to the underlying event loop object.

Source: src/base.lisp (file)

Generic Function: event-base-catch-app-errors OBJECT

Generic Function: (setf event-base-catch-app-errors) NEW-VALUE OBJECT

Package

Methods

Method: event-base-catch-app-errors (EVENT-BASE event-base)

Method: (setf event-base-catch-app-errors) NEW-VALUE (EVENT-BASE event-base)

If t (or a function) will trap all errors produced in the event loop and process them internally

Source: src/base.lisp (file)

Generic Function: event-base-data-registry OBJECT

Generic Function: (setf event-base-data-registry) NEW-VALUE OBJECT

Package

Methods

Method: event-base-data-registry (EVENT-BASE event-base)

Method: (setf event-base-data-registry) NEW-VALUE (EVENT-BASE event-base)

Holds all callback data attached to this event loop.

Source: src/base.lisp (file)

Generic Function: event-base-dns-base OBJECT

Generic Function: (setf event-base-dns-base) NEW-VALUE OBJECT

Package

Methods

Method: event-base-dns-base (EVENT-BASE event-base)

Method: (setf event-base-dns-base) NEW-VALUE (EVENT-BASE event-base)

Holds the DNS base object used for DNS lookups.

Source: src/base.lisp (file)

Generic Function: event-base-dns-ref-count OBJECT

Generic Function: (setf event-base-dns-ref-count) NEW-VALUE OBJECT

Package

Methods

Method: event-base-dns-ref-count (EVENT-BASE event-base)

Method: (setf event-base-dns-ref-count) NEW-VALUE (EVENT-BASE event-base)

Tracks how many open requests are pending on the dns base.

Source: src/base.lisp (file)

Generic Function: event-base-exit-functions OBJECT

Generic Function: (setf event-base-exit-functions) NEW-VALUE OBJECT

Package

Methods

Method: event-base-exit-functions (EVENT-BASE event-base)

Method: (setf event-base-exit-functions) NEW-VALUE (EVENT-BASE event-base)

Holds functions to be run when the event loop exist (cleanly or otherwise).

Source: src/base.lisp (file)

Generic Function: event-base-function-registry OBJECT

Generic Function: (setf event-base-function-registry) NEW-VALUE OBJECT

Package

Methods

Method: event-base-function-registry (EVENT-BASE event-base)

Method: (setf event-base-function-registry) NEW-VALUE (EVENT-BASE event-base)

Holds all callbacks attached to this event loop.

Source: src/base.lisp (file)

Generic Function: event-base-id OBJECT

Generic Function: (setf event-base-id) NEW-VALUE OBJECT

Package

Methods

Method: event-base-id (EVENT-BASE event-base)

Method: (setf event-base-id) NEW-VALUE (EVENT-BASE event-base)

Holds this event loop’s numeric id.

Source: src/base.lisp (file)

Generic Function: event-base-lock OBJECT

Generic Function: (setf event-base-lock) NEW-VALUE OBJECT

Package

Methods

Method: event-base-lock (EVENT-BASE event-base)

Method: (setf event-base-lock) NEW-VALUE (EVENT-BASE event-base)

Holds *the* lock for this event base.

Source: src/base.lisp (file)

Generic Function: event-base-num-connections-in OBJECT

Generic Function: (setf event-base-num-connections-in) NEW-VALUE OBJECT

Package

Methods

Method: event-base-num-connections-in (EVENT-BASE event-base)

automatically generated reader method

Source: src/base.lisp (file)

Method: (setf event-base-num-connections-in) NEW-VALUE (EVENT-BASE event-base)

automatically generated writer method

Source: src/base.lisp (file)

Generic Function: event-base-num-connections-out OBJECT

Generic Function: (setf event-base-num-connections-out) NEW-VALUE OBJECT

Package

Methods

Method: event-base-num-connections-out (EVENT-BASE event-base)

automatically generated reader method

Source: src/base.lisp (file)

Method: (setf event-base-num-connections-out) NEW-VALUE (EVENT-BASE event-base)

automatically generated writer method

Source: src/base.lisp (file)

Generic Function: event-base-send-errors-to-eventcb OBJECT

Generic Function: (setf event-base-send-errors-to-eventcb) NEW-VALUE OBJECT

Package

Methods

Method: event-base-send-errors-to-eventcb (EVENT-BASE event-base)

Method: (setf event-base-send-errors-to-eventcb) NEW-VALUE (EVENT-BASE event-base)

If t, will send caught errors to the event-cb instead of handle-error

Source: src/base.lisp (file)

Generic Function: event-base-signal-handlers OBJECT

Generic Function: (setf event-base-signal-handlers) NEW-VALUE OBJECT

Package

Methods

Method: event-base-signal-handlers (EVENT-BASE event-base)

Method: (setf event-base-signal-handlers) NEW-VALUE (EVENT-BASE event-base)

Holds all signal handlers.

Source: src/base.lisp (file)

Generic Function: event-c OBJECT

Generic Function: (setf event-c) NEW-VALUE OBJECT

Package

Methods

Method: event-c (EVENT event)

automatically generated reader method

Source: event.lisp (file)

Method: (setf event-c) NEW-VALUE (EVENT event)

automatically generated writer method

Source: event.lisp (file)

Generic Function: event-errcode CONDITION

Package

Methods

Method: event-errcode (CONDITION event-error)

Source: src/base.lisp (file)

Generic Function: event-errmsg CONDITION

Package

Methods

Method: event-errmsg (CONDITION event-error)

Source: src/base.lisp (file)

Generic Function: event-freed OBJECT

Generic Function: (setf event-freed) NEW-VALUE OBJECT

Package

Methods

Method: event-freed (EVENT event)

automatically generated reader method

Source: event.lisp (file)

Method: (setf event-freed) NEW-VALUE (EVENT event)

automatically generated writer method

Source: event.lisp (file)

Generic Function: event-freed-p OBJECT

Package

Methods

Method: event-freed-p (EVENT event)

automatically generated reader method

Source: event.lisp (file)

Generic Function: handle-error ERROR

Default error handler responsible for handling uncaught errors.

Package

cl-async-util

Source

src/util/error.lisp (file)

Methods

Method: handle-error ERROR

Generic Function: idler-freed-p OBJECT

Package

Methods

Method: idler-freed-p (IDLER idler)

automatically generated reader method

Source: idle.lisp (file)

Generic Function: notifier-freed-p OBJECT

Package

Methods

Method: notifier-freed-p (NOTIFIER notifier)

automatically generated reader method

Source: notify.lisp (file)

Generic Function: poller-freed-p OBJECT

Package

Methods

Method: poller-freed-p (POLLER poller)

automatically generated reader method

Source: poll.lisp (file)

Generic Function: process-error-output OBJECT

Generic Function: (setf process-error-output) NEW-VALUE OBJECT

Package

Methods

Method: process-error-output (PROCESS process)

automatically generated reader method

Source: process.lisp (file)

Method: (setf process-error-output) NEW-VALUE (PROCESS process)

automatically generated writer method

Source: process.lisp (file)

Generic Function: process-input OBJECT

Generic Function: (setf process-input) NEW-VALUE OBJECT

Package

Methods

Method: process-input (PROCESS process)

automatically generated reader method

Source: process.lisp (file)

Method: (setf process-input) NEW-VALUE (PROCESS process)

automatically generated writer method

Source: process.lisp (file)

Generic Function: process-output OBJECT

Generic Function: (setf process-output) NEW-VALUE OBJECT

Package

Methods

Method: process-output (PROCESS process)

automatically generated reader method

Source: process.lisp (file)

Method: (setf process-output) NEW-VALUE (PROCESS process)

automatically generated writer method

Source: process.lisp (file)

Generic Function: ref HANDLE

Reference a libuv handle object (uv_ref)

Package

Source

event-loop.lisp (file)

Methods

Method: ref (HANDLE notifier)

Source: notify.lisp (file)

Method: ref (HANDLE event)

Source: event.lisp (file)

Generic Function: socket CONDITION

Generic Function: (setf socket) NEW-VALUE CONDITION

Package

Methods

Method: socket THING

Source: socket.lisp (file)

Method: socket (CONDITION socket-info)

Method: (setf socket) NEW-VALUE (CONDITION socket-info)

Source: socket.lisp (file)

Generic Function: socket-accept-error-listener CONDITION

Generic Function: (setf socket-accept-error-listener) NEW-VALUE CONDITION

Package

Methods

Method: socket-accept-error-listener (CONDITION socket-accept-error)

Method: (setf socket-accept-error-listener) NEW-VALUE (CONDITION socket-accept-error)

Source: socket.lisp (file)

Generic Function: socket-c OBJECT

Generic Function: (setf socket-c) NEW-VALUE OBJECT

Package

Methods

Method: socket-c (SOCKET socket)

automatically generated reader method

Source: socket.lisp (file)

Method: (setf socket-c) NEW-VALUE (SOCKET socket)

automatically generated writer method

Source: socket.lisp (file)

Generic Function: socket-closed OBJECT

Generic Function: (setf socket-closed) NEW-VALUE OBJECT

Package

Methods

Method: socket-closed (SOCKET socket)

automatically generated reader method

Source: socket.lisp (file)

Method: (setf socket-closed) NEW-VALUE (SOCKET socket)

automatically generated writer method

Source: socket.lisp (file)

Generic Function: socket-data OBJECT

Generic Function: (setf socket-data) NEW-VALUE OBJECT

Package

Methods

Method: socket-data (SOCKET socket)

automatically generated reader method

Source: socket.lisp (file)

Method: (setf socket-data) NEW-VALUE (SOCKET socket)

automatically generated writer method

Source: socket.lisp (file)

Generic Function: streamish THING

Returned associated streamish for THING or THING itself if THING is a streamish.

Package

Source

streamish.lisp (file)

Writer

(setf streamish) (generic function)

Methods

Method: streamish (ASYNC-STREAM async-stream)

automatically generated reader method

Source: async-stream.lisp (file)

Method: streamish (STREAMISH streamish)

Method: streamish (CONDITION streamish-info)

Generic Function: (setf streamish) NEW-VALUE CONDITION

Package

Reader

streamish (generic function)

Methods

Method: (setf streamish) NEW-VALUE (ASYNC-STREAM async-stream)

automatically generated writer method

Source: async-stream.lisp (file)

Method: (setf streamish) NEW-VALUE (CONDITION streamish-info)

Source: streamish.lisp (file)

Generic Function: streamish-closed OBJECT

Generic Function: (setf streamish-closed) NEW-VALUE OBJECT

Package

Methods

Method: streamish-closed (STREAMISH streamish)

automatically generated reader method

Source: streamish.lisp (file)

Method: (setf streamish-closed) NEW-VALUE (STREAMISH streamish)

automatically generated writer method

Source: streamish.lisp (file)

Generic Function: streamish-write STREAMISH DATA &key START END FORCE READ-CB WRITE-CB EVENT-CB &allow-other-keys

Write data into a streamish. Allows specifying read/write/event
callbacks. Any callback left nil will use that current callback from the streamish (so they only override when specified, otherwise keep the current callback).

Note that libuv doesn’t buffer output for non-connected sockets, so we have to do it ourselves by checking if the socket is connected and buffering accordingly.

Package

Source

streamish.lisp (file)

Methods

Method: streamish-write (SOCKET socket) DATA &key START END FORCE &allow-other-keys

Source: socket.lisp (file)

Method: streamish-write (STREAMISH streamish) DATA &key READ-CB WRITE-CB EVENT-CB &allow-other-keys around

Method: streamish-write (STREAMISH streamish) DATA &key START END &allow-other-keys

Generic Function: tcp-socket CONDITION

Generic Function: (setf tcp-socket) NEW-VALUE CONDITION

Package

Methods

Method: tcp-socket (CONDITION streamish-info)

Method: (setf tcp-socket) NEW-VALUE (CONDITION streamish-info)

Source: streamish.lisp (file)

Generic Function: unref HANDLE

Unreference a libuv handle object (uv_unref)

Package

Source

event-loop.lisp (file)

Methods

Method: unref (HANDLE notifier)

Source: notify.lisp (file)

Method: unref (HANDLE event)

Source: event.lisp (file)

6.1.6 Conditions

Condition: dns-error ()

Passed to a failure callback when a DNS error occurs on a connection.

Package: cl-async
Source: dns.lisp (file)
Direct superclasses: event-error (condition)

Condition: event-error ()

Describes a general error event.

Package

Source

src/base.lisp (file)

Direct superclasses

error (condition)
event-info (condition)

Direct subclasses

event-freed (condition)
dns-error (condition)
streamish-error (condition)
filesystem-error (condition)
notifier-freed (condition)

Direct methods

event-errmsg (method)
event-errcode (method)

Direct slots

Slot: code

Initargs: :code
Initform: (quote 0)
Readers: event-errcode (generic function)

Slot: msg

Initargs: :msg
Initform: (quote nil)
Readers: event-errmsg (generic function)

Condition: event-freed ()

Thrown when a freed event is operated on.

Package

Source

event.lisp (file)

Direct superclasses

event-error (condition)

Direct methods

event-freed-event (method)
event-freed-event (method)

Direct slots

Slot: event

Initargs: :event
Initform: (quote nil)
Readers: event-freed-event (generic function)
Writers: (setf event-freed-event) (generic function)

Condition: event-info ()

Describes the base event for any action in cl-async.

Package

Source

src/base.lisp (file)

Direct superclasses

condition (condition)

Direct subclasses

event-error (condition)
streamish-info (condition)

Condition: filesystem-eacces ()

Error: access denied

Package: cl-async
Source: filesystem.lisp (file)
Direct superclasses: filesystem-error (condition)

Condition: filesystem-enoent ()

Error: no such file or directory

Package: cl-async
Source: filesystem.lisp (file)
Direct superclasses: filesystem-error (condition)

Condition: filesystem-eperm ()

Error: permission denied

Package: cl-async
Source: filesystem.lisp (file)
Direct superclasses: filesystem-error (condition)

Condition: filesystem-error ()

Base class for filesystem conditions

Package

Source

filesystem.lisp (file)

Direct superclasses

event-error (condition)

Direct subclasses

filesystem-enoent (condition)
filesystem-eacces (condition)
filesystem-eperm (condition)

Condition: socket-aborted ()

Connection aborted.

Package: cl-async
Source: socket.lisp (file)
Direct superclasses: socket-error (condition)

Condition: socket-accept-error ()

Passed to a server’s event-cb when there’s an error accepting a connection.

Package

Source

socket.lisp (file)

Direct superclasses

socket-error (condition)

Direct methods

socket-accept-error-server (method)
socket-accept-error-server (method)
socket-accept-error-listener (method)
socket-accept-error-listener (method)

Direct slots

Slot: listener

Initargs: :listener
Initform: (quote (cffi-sys:null-pointer))
Readers: socket-accept-error-listener (generic function)
Writers: (setf socket-accept-error-listener) (generic function)

Slot: server

Initargs: :server
Initform: (quote nil)
Readers: socket-accept-error-server (generic function)
Writers: (setf socket-accept-error-server) (generic function)

Condition: socket-address-in-use ()

Address is already in use.

Package: cl-async
Source: socket.lisp (file)
Direct superclasses: socket-error (condition)

Condition: socket-closed ()

Thrown when a closed streamish is being operated on.

Package: cl-async
Source: streamish.lisp (file)
Direct superclasses: streamish-error (condition)

Condition: socket-eof ()

Peer closes a socket connection.

Package

Source

socket.lisp (file)

Direct superclasses

socket-error (condition)
streamish-eof (condition)

Condition: socket-error ()

Describes a general socket connection error.

Package

Source

socket.lisp (file)

Direct superclasses

socket-info (condition)
streamish-error (condition)

Direct subclasses

socket-eof (condition)
socket-reset (condition)
socket-timeout (condition)
socket-refused (condition)
socket-aborted (condition)
socket-address-in-use (condition)
socket-accept-error (condition)
tcp-server-bind-error (condition)

Condition: socket-info ()

Base socket condition. Holds the socket object.

Package

Source

socket.lisp (file)

Direct superclasses

streamish-info (condition)

Direct subclasses

socket-error (condition)

Direct methods

socket (method)
socket (method)

Direct slots

Slot: streamish

Initargs: :streamish, :socket
Initform: (quote nil)
Readers: socket (generic function)
Writers: (setf socket) (generic function)

Condition: socket-refused ()

Connection refused.

Package: cl-async
Source: socket.lisp (file)
Direct superclasses: socket-error (condition)

Condition: socket-reset ()

Connection reset.

Package: cl-async
Source: socket.lisp (file)
Direct superclasses: socket-error (condition)

Condition: socket-timeout ()

Socket connection timed out.

Package: cl-async
Source: socket.lisp (file)
Direct superclasses: socket-error (condition)

Condition: streamish-broken-pipe ()

Broken pipe.

Package: cl-async
Source: streamish.lisp (file)
Direct superclasses: streamish-error (condition)

Condition: streamish-canceled ()

Operation canceled.

Package: cl-async
Source: streamish.lisp (file)
Direct superclasses: streamish-error (condition)

Condition: streamish-closed ()

Thrown when a closed streamish is being operated on.

Package: cl-async
Source: streamish.lisp (file)
Direct superclasses: streamish-error (condition)

Condition: streamish-eof ()

Passed to an event callback when stream EOF is reached.

Package: cl-async
Source: streamish.lisp (file)
Direct superclasses: streamish-info (condition)
Direct subclasses: socket-eof (condition)

Condition: streamish-error ()

Describes a general streamish error.

Package

Source

streamish.lisp (file)

Direct superclasses

streamish-info (condition)
event-error (condition)

Direct subclasses

streamish-closed (condition)
streamish-broken-pipe (condition)
streamish-canceled (condition)
socket-error (condition)

Condition: streamish-info ()

Base streamish condition. Holds the streamish object.

Package

Source

streamish.lisp (file)

Direct superclasses

event-info (condition)

Direct subclasses

streamish-error (condition)
streamish-eof (condition)
socket-info (condition)

Direct methods

tcp-socket (method)
(setf streamish) (method)
tcp-socket (method)
streamish (method)

Direct slots

Slot: streamish

Initargs

:streamish, :socket

Initform

(quote nil)

Readers

streamish (generic function)
tcp-socket (generic function)

Writers

(setf streamish) (generic function)
(setf tcp-socket) (generic function)

Condition: tcp-accept-error ()

Passed to a server’s event-cb when there’s an error accepting a connection.

Package

Source

socket.lisp (file)

Direct superclasses

socket-error (condition)

Direct methods

socket-accept-error-server (method)
socket-accept-error-server (method)
socket-accept-error-listener (method)
socket-accept-error-listener (method)

Direct slots

Slot: listener

Initargs: :listener
Initform: (quote (cffi-sys:null-pointer))
Readers: socket-accept-error-listener (generic function)
Writers: (setf socket-accept-error-listener) (generic function)

Slot: server

Initargs: :server
Initform: (quote nil)
Readers: socket-accept-error-server (generic function)
Writers: (setf socket-accept-error-server) (generic function)

Condition: tcp-eof ()

Peer closes a socket connection.

Package

Source

socket.lisp (file)

Direct superclasses

socket-error (condition)
streamish-eof (condition)

Condition: tcp-error ()

Describes a general socket connection error.

Package

Source

socket.lisp (file)

Direct superclasses

socket-info (condition)
streamish-error (condition)

Direct subclasses

socket-eof (condition)
socket-reset (condition)
socket-timeout (condition)
socket-refused (condition)
socket-aborted (condition)
socket-address-in-use (condition)
socket-accept-error (condition)
tcp-server-bind-error (condition)

Condition: tcp-info ()

Base socket condition. Holds the socket object.

Package

Source

socket.lisp (file)

Direct superclasses

streamish-info (condition)

Direct subclasses

socket-error (condition)

Direct methods

socket (method)
socket (method)

Direct slots

Slot: streamish

Initargs: :streamish, :socket
Initform: (quote nil)
Readers: socket (generic function)
Writers: (setf socket) (generic function)

Condition: tcp-refused ()

Connection refused.

Package: cl-async
Source: socket.lisp (file)
Direct superclasses: socket-error (condition)

Condition: tcp-reset ()

Connection reset.

Package: cl-async
Source: socket.lisp (file)
Direct superclasses: socket-error (condition)

Condition: tcp-server-bind-error ()

Thrown when a server fails to bind (generally, the port is already in use).

Package

Source

tcp.lisp (file)

Direct superclasses

socket-error (condition)

Direct methods

tcp-server-bind-error-port (method)
tcp-server-bind-error-port (method)
tcp-server-bind-error-addr (method)
tcp-server-bind-error-addr (method)

Direct slots

Slot: addr

Initargs: :addr
Initform: (quote nil)
Readers: tcp-server-bind-error-addr (generic function)
Writers: (setf tcp-server-bind-error-addr) (generic function)

Slot: port

Initargs: :port
Initform: (quote nil)
Readers: tcp-server-bind-error-port (generic function)
Writers: (setf tcp-server-bind-error-port) (generic function)

Condition: tcp-timeout ()

Socket connection timed out.

Package: cl-async
Source: socket.lisp (file)
Direct superclasses: socket-error (condition)

6.1.7 Classes

Class: async-input-stream ()

Async input stream.

Package

Source

Direct superclasses

fundamental-binary-input-stream (class)
async-stream (class)

Direct subclasses

async-io-stream (class)

Direct methods

stream-read-sequence (method)
stream-read-byte (method)
stream-clear-input (method)

Class: async-io-stream ()

Async stream for both input and output.

Package

Source

Direct superclasses

async-output-stream (class)
async-input-stream (class)

Class: async-output-stream ()

Async output stream.

Package

Source

Direct superclasses

fundamental-binary-output-stream (class)
async-stream (class)

Direct subclasses

async-io-stream (class)

Direct methods

send-buffered-data (method)
stream-write-byte (method)
stream-write-sequence (method)
stream-finish-output (method)
stream-force-output (method)
stream-clear-output (method)

Class: async-stream ()

The underlying class for async streams. Wraps a streamish.

Package

Source

Direct superclasses

trivial-gray-stream-mixin (class)

Direct subclasses

async-output-stream (class)
async-input-stream (class)

Direct methods

close (method)
open-stream-p (method)
stream-element-type (method)
stream-output-type (method)
stream-append-bytes (method)
stream-buffer (method)
stream-buffer (method)
(setf streamish) (method)
streamish (method)

Direct slots

Slot: streamish

Initargs: :socket, :streamish
Readers: streamish (generic function)
Writers: (setf streamish) (generic function)

Slot: buffer

Initform: (cl-async-util:make-buffer)
Readers: stream-buffer (generic function)
Writers: (setf stream-buffer) (generic function)

Class: event ()

Wraps a C libuv event object.

Package

Source

event.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

unref (method)
ref (method)
event-freed (method)
event-freed (method)
event-freed-p (method)
event-c (method)
event-c (method)

Direct slots

Slot: c

Initargs: :c
Initform: (cffi-sys:null-pointer)
Readers: event-c (generic function)
Writers: (setf event-c) (generic function)

Slot: freed

Readers

event-freed-p (generic function)
event-freed (generic function)

Writers

(setf event-freed) (generic function)

Class: event-base ()

A class that holds an event loop and all of the state that it manages.

One object to rule them all, one object to find them.
One object to bring them in and in the darkness bind them.

Package

Source

src/base.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

event-base-num-connections-out (method)
event-base-num-connections-out (method)
event-base-num-connections-in (method)
event-base-num-connections-in (method)
event-base-lock (method)
event-base-lock (method)
event-base-send-errors-to-eventcb (method)
event-base-send-errors-to-eventcb (method)
event-base-catch-app-errors (method)
event-base-catch-app-errors (method)
event-base-dns-ref-count (method)
event-base-dns-ref-count (method)
event-base-dns-base (method)
event-base-dns-base (method)
event-base-signal-handlers (method)
event-base-signal-handlers (method)
event-base-exit-functions (method)
event-base-exit-functions (method)
event-base-data-registry (method)
event-base-data-registry (method)
event-base-function-registry (method)
event-base-function-registry (method)
event-base-id (method)
event-base-id (method)
event-base-c (method)
event-base-c (method)

Direct slots

Slot: c

Holds the C object pointing to the underlying event loop object.

Initargs: :c
Readers: event-base-c (generic function)
Writers: (setf event-base-c) (generic function)

Slot: id

Holds this event loop’s numeric id.

Initargs: :id
Readers: event-base-id (generic function)
Writers: (setf event-base-id) (generic function)

Slot: function-registry

Holds all callbacks attached to this event loop.

Initargs: :function-registry
Initform: (make-hash-table :test (function eql))
Readers: event-base-function-registry (generic function)
Writers: (setf event-base-function-registry) (generic function)

Slot: data-registry

Holds all callback data attached to this event loop.

Initargs: :data-registry
Initform: (make-hash-table :test (function eql))
Readers: event-base-data-registry (generic function)
Writers: (setf event-base-data-registry) (generic function)

Slot: exit-functions

Holds functions to be run when the event loop exist (cleanly or otherwise).

Initargs: :exit-functions
Readers: event-base-exit-functions (generic function)
Writers: (setf event-base-exit-functions) (generic function)

Slot: signal-handlers

Holds all signal handlers.

Initargs: :signal-handlers
Readers: event-base-signal-handlers (generic function)
Writers: (setf event-base-signal-handlers) (generic function)

Slot: dns-base

Holds the DNS base object used for DNS lookups.

Initargs: :dns-base
Readers: event-base-dns-base (generic function)
Writers: (setf event-base-dns-base) (generic function)

Slot: dns-ref-count

Tracks how many open requests are pending on the dns base.

Initargs: :dns-ref-count
Initform: 0
Readers: event-base-dns-ref-count (generic function)
Writers: (setf event-base-dns-ref-count) (generic function)

Slot: catch-app-errors

If t (or a function) will trap all errors produced in the event loop and process them internally

Initargs: :catch-app-errors
Readers: event-base-catch-app-errors (generic function)
Writers: (setf event-base-catch-app-errors) (generic function)

Slot: send-errors-to-eventcb

If t, will send caught errors to the event-cb instead of handle-error

Initargs: :send-errors-to-eventcb
Readers: event-base-send-errors-to-eventcb (generic function)
Writers: (setf event-base-send-errors-to-eventcb) (generic function)

Slot: lock

Holds *the* lock for this event base.

Initargs: :lock
Initform: (bordeaux-threads:make-lock)
Readers: event-base-lock (generic function)
Writers: (setf event-base-lock) (generic function)

Slot: num-connections-in

Initform: 0
Readers: event-base-num-connections-in (generic function)
Writers: (setf event-base-num-connections-in) (generic function)

Slot: num-connections-out

Initform: 0
Readers: event-base-num-connections-out (generic function)
Writers: (setf event-base-num-connections-out) (generic function)

Class: idler ()

Wraps a libuv idle handle.

Package

Source

idle.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

idler-freed (method)
idler-freed (method)
idler-freed-p (method)
idler-c (method)
idler-c (method)

Direct slots

Slot: c

Initargs: :c
Initform: (cffi-sys:null-pointer)
Readers: idler-c (generic function)
Writers: (setf idler-c) (generic function)

Slot: freed

Readers

idler-freed-p (generic function)
idler-freed (generic function)

Writers

(setf idler-freed) (generic function)

Class: notifier ()

Wraps a threading-enabled notifier.

Package

Source

notify.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

unref (method)
ref (method)
notifier-single-shot (method)
notifier-single-shot (method)
notifier-single-shot-p (method)
notifier-freed (method)
notifier-freed (method)
notifier-freed-p (method)
notifier-c (method)
notifier-c (method)

Direct slots

Slot: c

Initargs: :c
Initform: (cffi-sys:null-pointer)
Readers: notifier-c (generic function)
Writers: (setf notifier-c) (generic function)

Slot: freed

Readers

notifier-freed-p (generic function)
notifier-freed (generic function)

Writers

(setf notifier-freed) (generic function)

Slot: single-shot

Initargs

:single-shot

Initform

t

Readers

notifier-single-shot-p (generic function)
notifier-single-shot (generic function)

Writers

(setf notifier-single-shot) (generic function)

Class: pipe-server ()

Package

Source

pipe.lisp (file)

Direct superclasses

socket-server (class)
pipe-mixin (class)

Direct methods

socket-server-bind (method)
server-socket-class (method)

Class: poller ()

Wraps a polling handle.

Package

Source

poll.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

poller-freed (method)
poller-freed (method)
poller-freed-p (method)
poller-c (method)
poller-c (method)

Direct slots

Slot: c

Initargs: :c
Initform: (cffi-sys:null-pointer)
Readers: poller-c (generic function)
Writers: (setf poller-c) (generic function)

Slot: freed

Readers

poller-freed-p (generic function)
poller-freed (generic function)

Writers

(setf poller-freed) (generic function)

Class: socket ()

Wraps around a socket.

Package

Source

socket.lisp (file)

Direct superclasses

streamish (class)

Direct subclasses

tcp-socket (class)
pipe (class)

Direct methods

initialize-instance (method)
close-streamish (method)
write-pending-socket-data (method)
streamish-write (method)
errno-event (method)
errno-event (method)
errno-event (method)
errno-event (method)
errno-event (method)
socket-drain-read-buffer (method)
socket-drain-read-buffer (method)
socket-connected (method)
socket-connected (method)
socket-buffering-p (method)
socket-buffering-p (method)
socket-buffer (method)
socket-buffer (method)
socket-closed (method)
socket-closed (method)
socket-data (method)
socket-data (method)
socket-c (method)
socket-c (method)

Direct slots

Slot: c

Readers: socket-c (generic function)
Writers: (setf socket-c) (generic function)

Slot: data

Readers: socket-data (generic function)
Writers: (setf socket-data) (generic function)

Slot: closed

Readers: socket-closed (generic function)
Writers: (setf socket-closed) (generic function)

Slot: buffer

Holds data sent on the socket that hasn’t been sent yet.

Initargs: :buffer
Initform: (cl-async-util:make-buffer)
Readers: socket-buffer (generic function)
Writers: (setf socket-buffer) (generic function)

Slot: bufferingp

Lets us know if the socket is currently buffering output.

Readers: socket-buffering-p (generic function)
Writers: (setf socket-buffering-p) (generic function)

Slot: connected

Initargs: :connected
Readers: socket-connected (generic function)
Writers: (setf socket-connected) (generic function)

Slot: drain-read-buffer

Readers: socket-drain-read-buffer (generic function)
Writers: (setf socket-drain-read-buffer) (generic function)

Class: streamish ()

Wraps around a streamish.

Package

Source

streamish.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

socket (class)

Direct methods

streamish-write (method)
streamish-write (method)
close-streamish (method)
errno-event (method)
errno-event (method)
errno-event (method)
streamish (method)
streamish-drain-read-buffer (method)
streamish-drain-read-buffer (method)
streamish-closed (method)
streamish-closed (method)
streamish-data (method)
streamish-data (method)
streamish-c (method)
streamish-c (method)

Direct slots

Slot: c

Initargs: :c
Initform: (cffi-sys:null-pointer)
Readers: streamish-c (generic function)
Writers: (setf streamish-c) (generic function)

Slot: data

Used to store arbitrary (app-defined) data with a streamish.

Initargs: cl-async::data
Readers: streamish-data (generic function)
Writers: (setf streamish-data) (generic function)

Slot: closed

Initargs: :closed
Readers: streamish-closed (generic function)
Writers: (setf streamish-closed) (generic function)

Slot: drain-read-buffer

Initargs: :drain-read-buffer
Initform: t
Readers: streamish-drain-read-buffer (generic function)
Writers: (setf streamish-drain-read-buffer) (generic function)

Class: tcp-server ()

Package

Source

tcp.lisp (file)

Direct superclasses

socket-server (class)
tcp-mixin (class)

Direct methods

socket-server-bind (method)
server-socket-class (method)

Class: tcp-socket ()

Package

Source

tcp.lisp (file)

Direct superclasses

socket (class)
tcp-mixin (class)

Direct methods

close-streamish (method)
initialize-instance (method)
socket-direction (method)
socket-direction (method)

Direct slots

Slot: direction

Initargs: :direction
Initform: :out
Readers: socket-direction (generic function)
Writers: (setf socket-direction) (generic function)

6.1.8 Types

Type: bytes-or-string ()

Package: cl-async-util
Source: src/util/helpers.lisp (file)

Type: callback ()

Package: cl-async-util
Source: src/util/helpers.lisp (file)

Type: octet ()

Package: cl-async-util
Source: src/util/helpers.lisp (file)

Type: octet-vector ()

Package: cl-async-util
Source: src/util/helpers.lisp (file)

6.2 Internal definitions

6.2.1 Special variables

Special Variable: *evcb-err*

Package: cl-async-util
Source: src/util/error.lisp (file)

Special Variable: *event-base-registry*

Holds ID -> event-base lookups for every active event loop. Mainly used when grabbing the threading context for a particular event loop.

Package: cl-async
Source: event-loop.lisp (file)

Special Variable: *event-base-registry-lock*

Locks the event-base registry.

Package: cl-async
Source: event-loop.lisp (file)

Special Variable: *loop-close-iters*

Maximum number of event loop cleanup iterations

Package: cl-async
Source: event-loop.lisp (file)

6.2.2 Functions

Function: %fs-monitor-close HANDLE

Package: cl-async
Source: fsevent.lisp (file)

Function: %pipe-connect SOCKET/STREAM NAME

Connect a pipe initialized with init-client-socket.

Package: cl-async
Source: pipe.lisp (file)

Function: async-cb ASYNC-C

Called when an async notifier is triggered.

Package: cl-async
Source: notify.lisp (file)

Function: async-close-cb ASYNC-C

Called when an async handle is closed.

Package: cl-async
Source: notify.lisp (file)

Function: check-event-loop-running ()

Package: cl-async
Source: event-loop.lisp (file)

Function: check-event-unfreed EVENT

Checks that an event being operated on is not freed.

Package: cl-async
Source: event.lisp (file)

Function: check-notifier-unfreed NOTIFIER

Checks that an notifier being operated on is not freed.

Package: cl-async
Source: notify.lisp (file)

Function: check-socket-open SOCKET

Compatibility alias for CHECK-STREAMISH-OPEN.

Package: cl-async
Source: socket.lisp (file)

Function: dns-cb REQ STATUS ADDRINFO

Callback for DNS lookups.

Package: cl-async
Source: dns.lisp (file)

Function: do-close-loop EVLOOP

Close an event loop by looping over its open handles, closing them, rinsing and repeating until uv-loop-close returns 0, but at most *LOOP-CLOSE-ITERS* times.

Package: cl-async
Source: event-loop.lisp (file)

Function: do-close-streamish UVSTREAM &key FORCE

Close an UV stream.

Package: cl-async
Source: streamish.lisp (file)

Function: event-handler ERROR EVENT-CB &key STREAMISH THROW

Called when an event (error, mainly) occurs.

Package: cl-async
Source: streamish.lisp (file)

Function: fs-cb REQ

Package: cl-async
Source: filesystem.lisp (file)

Function: fs-event-callback HANDLE PATH EVENTS STATUS

Package: cl-async
Source: fsevent.lisp (file)

Function: fs-monitor-close-cb HANDLE

Called when a fs-monitor closes.

Package: cl-async
Source: fsevent.lisp (file)

Function: idle-cb HANDLE

Called when an idle handler fires.

Package: cl-async
Source: idle.lisp (file)

Function: idle-close-cb IDLE-C

Called when an idler closes.

Package: cl-async
Source: idle.lisp (file)

Function: init-client-socket SOCKET-CLASS &key READ-CB EVENT-CB DATA STREAM CONNECT-CB WRITE-CB DIRECTION READ-TIMEOUT WRITE-TIMEOUT DONT-DRAIN-READ-BUFFER

Initialize an async socket, but do not connect it.

Package: cl-async
Source: socket.lisp (file)

Function: init-incoming-socket SERVER STATUS

Called by the socket-accept-cb when an incoming connection is detected. Sets up a socket between the client and the server along with any callbacks the server has attached to it. Returns the cl-async socket object created.

Package: cl-async
Source: socket.lisp (file)

Function: init-stdio-container CONTAINER OUT-P TYPE FD PIPE-ARGS

Package: cl-async
Source: process.lisp (file)

Function: lisp-signal-cb SIGNO

Generic callback for lisp signal handling.

Package: cl-async
Source: signal.lisp (file)

Function: loop-exit-walk-cb HANDLE ARG

Called when we want to close the loop AND IT WONT CLOSE. So we walk each handle and close them.

Package: cl-async
Source: event-loop.lisp (file)

Function: poll-cb POLL-C STATUS EVENTS

Called when something happens on a polled FD.

Package: cl-async
Source: poll.lisp (file)

Function: poll-close-cb POLL-C

Called when a poller closes.

Package: cl-async
Source: poll.lisp (file)

Function: process-close PROCESS-HANDLE

Package: cl-async
Source: process.lisp (file)

Function: process-close-cb PROCESS-HANDLE

Called when a process closes.

Package: cl-async
Source: process.lisp (file)

Function: process-event-loop-exit-callbacks ()

run and clear out all event loop exit functions.

Package: cl-async
Source: event-loop.lisp (file)

Function: process-exit-cb PROCESS-HANDLE EXIT-STATUS TERM-SIGNAL

Package: cl-async
Source: process.lisp (file)

Function: reverse-dns-cb REQ STATUS HOSTNAME SERVICE

Callback for reverse DNS lookups.

Package: cl-async
Source: dns.lisp (file)

Function: set-lisp-signal-handler SIGNO FN

Replace the current handler for the signal number under signo, and return a pointer to the handler that is being replaced.

Package: cl-async
Source: signal.lisp (file)

Function: signal-cb WATCHER SIGNO

All signals come through here.

Package: cl-async
Source: signal.lisp (file)

Function: signal-close-cb WATCHER

Called when a signal handler closes.

Package: cl-async
Source: signal.lisp (file)

Function: signal-pointer SIGNO

Creates a pointer from a signal number. Not that this doesn’t need to be freed since we’re not allocating anything...just creating a pointer object with a specific address (which can be GCed).

Package: cl-async
Source: signal.lisp (file)

Function: socket-accept-cb SERVER STATUS

Called by a listener when an incoming connection is detected. Thin wrapper around init-incoming-socket, which does all the setting up of callbacks and pointers and so forth.

Package: cl-async
Source: socket.lisp (file)

Function: socket-connect-cb REQ STATUS

Called when an outgoing socket connects.

Package: cl-async
Source: socket.lisp (file)

Function: socket-server SERVER-CLASS ADDRESS READ-CB &key EVENT-CB CONNECT-CB BACKLOG STREAM FD

Start a socket listener on the current event loop. Returns a socket-server instance which can be closed with close-socket-server

Package: cl-async
Source: socket.lisp (file)

Function: streamish-alloc-cb HANDLE SIZE BUF

Called when we want to allocate data to be filled for stream reading.

Package: cl-async
Source: streamish.lisp (file)

Function: streamish-close-cb UVSTREAM

Called when a streamish closes.

Package: cl-async
Source: streamish.lisp (file)

Function: streamish-convert-data DATA

Package: cl-async
Source: streamish.lisp (file)

Function: streamish-read-cb UVSTREAM NREAD BUF

Called when a stream has been read into a buffer returned by alloc-cb.

Package: cl-async
Source: streamish.lisp (file)

Function: streamish-read-start STREAMISH

Start reading on the socket, return true on success. Invoke streamish’ event handler callback on error, returning NIL.

Package: cl-async
Source: streamish.lisp (file)

Function: streamish-shutdown-cb REQ STATUS

Called when a streamish shuts down.

Package: cl-async
Source: streamish.lisp (file)

Function: streamish-write-cb REQ STATUS

Called when data is finished being written to a streamish.

Package: cl-async
Source: streamish.lisp (file)

Function: tcp-connect-new HOST PORT READ-CB &key DATA STREAM EVENT-CB CONNECT-CB WRITE-CB READ-TIMEOUT WRITE-TIMEOUT DONT-DRAIN-READ-BUFFER

Open a TCP connection asynchronously. Optionally send data out once connected via the :data keyword (can be a string or byte array).

Package: cl-async
Source: tcp.lisp (file)

Function: tcp-server-closed SERVER

Package: cl-async
Source: tcp.lisp (file)

Function: tcp-server-new BIND-ADDRESS PORT READ-CB &key EVENT-CB CONNECT-CB BACKLOG STREAM FD

Start a TCP listener on the current event loop. Returns a tcp-server class which can be closed with close-tcp-server

Package: cl-async
Source: tcp.lisp (file)

Function: timer-cb TIMER-C

Callback used by the async timer system to find and run user-specified callbacks on timer events.

Package: cl-async
Source: event.lisp (file)

Function: timer-close-cb TIMER-C

Called when a timer closes.

Package: cl-async
Source: event.lisp (file)

Function: walk-cb HANDLE ARG

Called when we’re walking the loop.

Package: cl-async
Source: event-loop.lisp (file)

Function: write-to-uvstream UVSTREAM DATA &key START END

Util function to write data directly to a uv stream object.

Package: cl-async
Source: streamish.lisp (file)

6.2.3 Generic functions

Generic Function: errno-event STREAMISH ERRNO

Make an event based on errno and streamish.

Package

Source

streamish.lisp (file)

Methods

Method: errno-event STREAMISH (ERRNO (eql -1))

Source: filesystem.lisp (file)

Method: errno-event STREAMISH (ERRNO (eql -13))

Source: filesystem.lisp (file)

Method: errno-event STREAMISH (ERRNO (eql -2))

Source: filesystem.lisp (file)

Method: errno-event SOCKET (ERRNO (eql -98))

Source: socket.lisp (file)

Method: errno-event (SOCKET socket) (ERRNO (eql -103))

Source: socket.lisp (file)

Method: errno-event (SOCKET socket) (ERRNO (eql -111))

Source: socket.lisp (file)

Method: errno-event (SOCKET socket) (ERRNO (eql -4095))

Source: socket.lisp (file)

Method: errno-event (SOCKET socket) (ERRNO (eql -104))

Source: socket.lisp (file)

Method: errno-event (SOCKET socket) (ERRNO (eql -110))

Source: socket.lisp (file)

Method: errno-event (STREAMISH streamish) (ERRNO (eql -125))

Method: errno-event (STREAMISH streamish) (ERRNO (eql -32))

Method: errno-event (STREAMISH streamish) (ERRNO (eql -4095))

Method: errno-event STREAMISH (ERRNO (eql -14))

Method: errno-event STREAMISH (ERRNO (eql -3008))

Method: errno-event STREAMISH ERRNO

Generic Function: event-freed-event CONDITION

Generic Function: (setf event-freed-event) NEW-VALUE CONDITION

Package

Methods

Method: event-freed-event (CONDITION event-freed)

Method: (setf event-freed-event) NEW-VALUE (CONDITION event-freed)

Source: event.lisp (file)

Generic Function: fs-monitor-c OBJECT

Generic Function: (setf fs-monitor-c) NEW-VALUE OBJECT

Package

Methods

Method: fs-monitor-c (FS-MONITOR fs-monitor)

automatically generated reader method

Source: fsevent.lisp (file)

Method: (setf fs-monitor-c) NEW-VALUE (FS-MONITOR fs-monitor)

automatically generated writer method

Source: fsevent.lisp (file)

Generic Function: handle-cleanup HANDLE-TYPE HANDLE

Perform cleanup for a libuv handle

Package

Source

event-loop.lisp (file)

Methods

Method: handle-cleanup (HANDLE-TYPE (eql fs-event)) HANDLE

Source: fsevent.lisp (file)

Method: handle-cleanup (HANDLE-TYPE (eql process)) HANDLE

Source: process.lisp (file)

Method: handle-cleanup (HANDLE-TYPE (eql async)) HANDLE

Source: notify.lisp (file)

Method: handle-cleanup (HANDLE-TYPE (eql named-pipe)) HANDLE

Source: pipe.lisp (file)

Method: handle-cleanup (HANDLE-TYPE (eql tcp)) HANDLE

Source: tcp.lisp (file)

Method: handle-cleanup (HANDLE-TYPE (eql async-socket)) HANDLE

Source: socket.lisp (file)

Method: handle-cleanup (HANDLE-TYPE (eql timer)) HANDLE

Source: event.lisp (file)

Method: handle-cleanup HANDLE-TYPE HANDLE

Generic Function: idler-c OBJECT

Generic Function: (setf idler-c) NEW-VALUE OBJECT

Package

Methods

Method: idler-c (IDLER idler)

automatically generated reader method

Source: idle.lisp (file)

Method: (setf idler-c) NEW-VALUE (IDLER idler)

automatically generated writer method

Source: idle.lisp (file)

Generic Function: idler-freed OBJECT

Generic Function: (setf idler-freed) NEW-VALUE OBJECT

Package

Methods

Method: idler-freed (IDLER idler)

automatically generated reader method

Source: idle.lisp (file)

Method: (setf idler-freed) NEW-VALUE (IDLER idler)

automatically generated writer method

Source: idle.lisp (file)

Generic Function: make-socket-handle SOCKET-OR-SERVER

Create an underlying stream handle for socket connection

Package

Source

socket.lisp (file)

Methods

Method: make-socket-handle (SOCKET-OR-SERVER pipe-mixin)

Source: pipe.lisp (file)

Method: make-socket-handle (SOCKET-OR-SERVER tcp-mixin)

Source: tcp.lisp (file)

Generic Function: notifier-c OBJECT

Generic Function: (setf notifier-c) NEW-VALUE OBJECT

Package

Methods

Method: notifier-c (NOTIFIER notifier)

automatically generated reader method

Source: notify.lisp (file)

Method: (setf notifier-c) NEW-VALUE (NOTIFIER notifier)

automatically generated writer method

Source: notify.lisp (file)

Generic Function: notifier-freed OBJECT

Generic Function: (setf notifier-freed) NEW-VALUE OBJECT

Package

Methods

Method: notifier-freed (NOTIFIER notifier)

automatically generated reader method

Source: notify.lisp (file)

Method: (setf notifier-freed) NEW-VALUE (NOTIFIER notifier)

automatically generated writer method

Source: notify.lisp (file)

Generic Function: notifier-freed-notifier CONDITION

Generic Function: (setf notifier-freed-notifier) NEW-VALUE CONDITION

Package

Methods

Method: notifier-freed-notifier (CONDITION notifier-freed)

Method: (setf notifier-freed-notifier) NEW-VALUE (CONDITION notifier-freed)

Source: notify.lisp (file)

Generic Function: notifier-single-shot OBJECT

Generic Function: (setf notifier-single-shot) NEW-VALUE OBJECT

Package

Methods

Method: notifier-single-shot (NOTIFIER notifier)

automatically generated reader method

Source: notify.lisp (file)

Method: (setf notifier-single-shot) NEW-VALUE (NOTIFIER notifier)

automatically generated writer method

Source: notify.lisp (file)

Generic Function: notifier-single-shot-p OBJECT

Package

Methods

Method: notifier-single-shot-p (NOTIFIER notifier)

automatically generated reader method

Source: notify.lisp (file)

Generic Function: poller-c OBJECT

Generic Function: (setf poller-c) NEW-VALUE OBJECT

Package

Methods

Method: poller-c (POLLER poller)

automatically generated reader method

Source: poll.lisp (file)

Method: (setf poller-c) NEW-VALUE (POLLER poller)

automatically generated writer method

Source: poll.lisp (file)

Generic Function: poller-freed OBJECT

Generic Function: (setf poller-freed) NEW-VALUE OBJECT

Package

Methods

Method: poller-freed (POLLER poller)

automatically generated reader method

Source: poll.lisp (file)

Method: (setf poller-freed) NEW-VALUE (POLLER poller)

automatically generated writer method

Source: poll.lisp (file)

Generic Function: process-c OBJECT

Generic Function: (setf process-c) NEW-VALUE OBJECT

Package

Methods

Method: process-c (PROCESS process)

automatically generated reader method

Source: process.lisp (file)

Method: (setf process-c) NEW-VALUE (PROCESS process)

automatically generated writer method

Source: process.lisp (file)

Generic Function: send-buffered-data STREAM

Package

Methods

Method: send-buffered-data (STREAM async-output-stream)

Take data we’ve buffered between initial sending and actual streamish and send it out.

Source: async-stream.lisp (file)

Generic Function: server-socket-class SERVER

Return socket class for connections accepted by SERVER

Package

Source

socket.lisp (file)

Methods

Method: server-socket-class (SERVER pipe-server)

Source: pipe.lisp (file)

Method: server-socket-class (SERVER tcp-server)

Source: tcp.lisp (file)

Generic Function: socket-accept-error-server CONDITION

Generic Function: (setf socket-accept-error-server) NEW-VALUE CONDITION

Package

Methods

Method: socket-accept-error-server (CONDITION socket-accept-error)

Method: (setf socket-accept-error-server) NEW-VALUE (CONDITION socket-accept-error)

Source: socket.lisp (file)

Generic Function: socket-buffer OBJECT

Generic Function: (setf socket-buffer) NEW-VALUE OBJECT

Package

Methods

Method: socket-buffer (SOCKET socket)

Method: (setf socket-buffer) NEW-VALUE (SOCKET socket)

Holds data sent on the socket that hasn’t been sent yet.

Source: socket.lisp (file)

Generic Function: socket-buffering-p OBJECT

Generic Function: (setf socket-buffering-p) NEW-VALUE OBJECT

Package

Methods

Method: socket-buffering-p (SOCKET socket)

Method: (setf socket-buffering-p) NEW-VALUE (SOCKET socket)

Lets us know if the socket is currently buffering output.

Source: socket.lisp (file)

Generic Function: socket-connected OBJECT

Generic Function: (setf socket-connected) NEW-VALUE OBJECT

Package

Methods

Method: socket-connected (SOCKET socket)

automatically generated reader method

Source: socket.lisp (file)

Method: (setf socket-connected) NEW-VALUE (SOCKET socket)

automatically generated writer method

Source: socket.lisp (file)

Generic Function: socket-direction OBJECT

Generic Function: (setf socket-direction) NEW-VALUE OBJECT

Package

Methods

Method: socket-direction (TCP-SOCKET tcp-socket)

automatically generated reader method

Source: tcp.lisp (file)

Method: (setf socket-direction) NEW-VALUE (TCP-SOCKET tcp-socket)

automatically generated writer method

Source: tcp.lisp (file)

Generic Function: socket-drain-read-buffer OBJECT

Generic Function: (setf socket-drain-read-buffer) NEW-VALUE OBJECT

Package

Methods

Method: socket-drain-read-buffer (SOCKET socket)

automatically generated reader method

Source: socket.lisp (file)

Method: (setf socket-drain-read-buffer) NEW-VALUE (SOCKET socket)

automatically generated writer method

Source: socket.lisp (file)

Generic Function: socket-server-bind SERVER ADDRESS FD

Bind socket server to the specified address, return libuv errno. Specify FD to bind the server to an existing file descriptor.

Package

Source

socket.lisp (file)

Methods

Method: socket-server-bind (SERVER pipe-server) ADDRESS FD

Source: pipe.lisp (file)

Method: socket-server-bind (SERVER tcp-server) ADDRESS FD

Source: tcp.lisp (file)

Generic Function: socket-server-c OBJECT

Generic Function: (setf socket-server-c) NEW-VALUE OBJECT

Package

Methods

Method: socket-server-c (SOCKET-SERVER socket-server)

automatically generated reader method

Source: socket.lisp (file)

Method: (setf socket-server-c) NEW-VALUE (SOCKET-SERVER socket-server)

automatically generated writer method

Source: socket.lisp (file)

Generic Function: socket-server-closed OBJECT

Generic Function: (setf socket-server-closed) NEW-VALUE OBJECT

Package

Methods

Method: socket-server-closed (SOCKET-SERVER socket-server)

automatically generated reader method

Source: socket.lisp (file)

Method: (setf socket-server-closed) NEW-VALUE (SOCKET-SERVER socket-server)

automatically generated writer method

Source: socket.lisp (file)

Generic Function: socket-server-stream OBJECT

Generic Function: (setf socket-server-stream) NEW-VALUE OBJECT

Package

Methods

Method: socket-server-stream (SOCKET-SERVER socket-server)

automatically generated reader method

Source: socket.lisp (file)

Method: (setf socket-server-stream) NEW-VALUE (SOCKET-SERVER socket-server)

automatically generated writer method

Source: socket.lisp (file)

Generic Function: stream-append-bytes STREAM BYTES

Package

Methods

Method: stream-append-bytes (STREAM async-stream) BYTES

Append some data to a stream’s underlying buffer.

Source: async-stream.lisp (file)

Generic Function: stream-buffer OBJECT

Generic Function: (setf stream-buffer) NEW-VALUE OBJECT

Package

Methods

Method: stream-buffer (ASYNC-STREAM async-stream)

automatically generated reader method

Source: async-stream.lisp (file)

Method: (setf stream-buffer) NEW-VALUE (ASYNC-STREAM async-stream)

automatically generated writer method

Source: async-stream.lisp (file)

Generic Function: stream-output-type STREAM

Package

Methods

Method: stream-output-type (STREAM async-stream)

This is always a binary stream.

Source: async-stream.lisp (file)

Generic Function: streamish-c OBJECT

Generic Function: (setf streamish-c) NEW-VALUE OBJECT

Package

Methods

Method: streamish-c (STREAMISH streamish)

automatically generated reader method

Source: streamish.lisp (file)

Method: (setf streamish-c) NEW-VALUE (STREAMISH streamish)

automatically generated writer method

Source: streamish.lisp (file)

Generic Function: streamish-data OBJECT

Generic Function: (setf streamish-data) NEW-VALUE OBJECT

Package

Methods

Method: streamish-data (STREAMISH streamish)

Method: (setf streamish-data) NEW-VALUE (STREAMISH streamish)

Used to store arbitrary (app-defined) data with a streamish.

Source: streamish.lisp (file)

Generic Function: streamish-drain-read-buffer OBJECT

Generic Function: (setf streamish-drain-read-buffer) NEW-VALUE OBJECT

Package

Methods

Method: streamish-drain-read-buffer (STREAMISH streamish)

automatically generated reader method

Source: streamish.lisp (file)

Method: (setf streamish-drain-read-buffer) NEW-VALUE (STREAMISH streamish)

automatically generated writer method

Source: streamish.lisp (file)

Generic Function: tcp-server-bind-error-addr CONDITION

Generic Function: (setf tcp-server-bind-error-addr) NEW-VALUE CONDITION

Package

Methods

Method: tcp-server-bind-error-addr (CONDITION tcp-server-bind-error)

Method: (setf tcp-server-bind-error-addr) NEW-VALUE (CONDITION tcp-server-bind-error)

Source: tcp.lisp (file)

Generic Function: tcp-server-bind-error-port CONDITION

Generic Function: (setf tcp-server-bind-error-port) NEW-VALUE CONDITION

Package

Methods

Method: tcp-server-bind-error-port (CONDITION tcp-server-bind-error)

Method: (setf tcp-server-bind-error-port) NEW-VALUE (CONDITION tcp-server-bind-error)

Source: tcp.lisp (file)

Generic Function: write-pending-socket-data SOCKET

Write any pending data on the given socket to its underlying stream.

Package

Source

socket.lisp (file)

Methods

Method: write-pending-socket-data (SOCKET socket)

6.2.4 Conditions

Condition: notifier-freed ()

Thrown when a freed notifier is operated on.

Package

Source

notify.lisp (file)

Direct superclasses

event-error (condition)

Direct methods

notifier-freed-notifier (method)
notifier-freed-notifier (method)

Direct slots

Slot: notifier

Initargs: :notifier
Initform: (quote nil)
Readers: notifier-freed-notifier (generic function)
Writers: (setf notifier-freed-notifier) (generic function)

6.2.5 Classes

Class: fs-monitor ()

Package

Source

fsevent.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

initialize-instance (method)
fs-monitor-c (method)
fs-monitor-c (method)

Direct slots

Slot: c

Readers: fs-monitor-c (generic function)
Writers: (setf fs-monitor-c) (generic function)

Class: pipe ()

Package

Source

pipe.lisp (file)

Direct superclasses

socket (class)
pipe-mixin (class)

Class: pipe-mixin ()

Package

Source

pipe.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

pipe (class)
pipe-server (class)

Direct methods

make-socket-handle (method)

Class: process ()

Package

Source

process.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

initialize-instance (method)
process-error-output (method)
process-error-output (method)
process-output (method)
process-output (method)
process-input (method)
process-input (method)
process-c (method)
process-c (method)

Direct slots

Slot: c

Initargs: :c
Readers: process-c (generic function)
Writers: (setf process-c) (generic function)

Slot: input

Initargs: :input
Readers: process-input (generic function)
Writers: (setf process-input) (generic function)

Slot: output

Initargs: :output
Readers: process-output (generic function)
Writers: (setf process-output) (generic function)

Slot: error-output

Initargs: :error-output
Readers: process-error-output (generic function)
Writers: (setf process-error-output) (generic function)

Class: socket-server ()

Wraps around a connection listener.

Package

Source

socket.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

tcp-server (class)
pipe-server (class)

Direct methods

initialize-instance (method)
close-socket-server (method)
socket-server-stream (method)
socket-server-stream (method)
socket-server-closed (method)
socket-server-closed (method)
socket-server-c (method)
socket-server-c (method)

Direct slots

Slot: c

Initargs: :c
Initform: (cffi-sys:null-pointer)
Readers: socket-server-c (generic function)
Writers: (setf socket-server-c) (generic function)

Slot: closed

Initargs: :closed
Readers: socket-server-closed (generic function)
Writers: (setf socket-server-closed) (generic function)

Slot: stream

Initargs: :stream
Readers: socket-server-stream (generic function)
Writers: (setf socket-server-stream) (generic function)

Class: tcp-mixin ()

Package