The journal Reference Manual

This is the journal Reference Manual, version 0.1.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Sun Jan 15 06:33:06 2023 GMT+0.

Table of Contents


1 Introduction


2 Systems

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


2.1 journal

A library for logging, tracing, testing and persistence.

Author

Gábor Melis <>

Home Page

http://github.com/melisgl/journal

Source Control

(GIT https://github.com/melisgl/journal.git)

Bug Tracker

http://github.com/melisgl/journal/issues

License

MIT, see COPYING.

Version

0.1.0

Dependencies
  • alexandria (system).
  • bordeaux-threads (system).
  • local-time (system).
  • mgl-pax (system).
  • trivial-features (system).
  • trivial-garbage (system).
  • osicat (system)., for feature (:not (:or :abcl :allegro :sbcl :cmucl))
  • sb-posix (system)., for feature :sbcl
Source

journal.asd.

Child Component

src (module).


3 Modules

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


3.1 journal/src

Source

journal.asd.

Parent Component

journal (system).

Child Components

4 Files

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


4.1 Lisp


4.1.1 journal/journal.asd

Source

journal.asd.

Parent Component

journal (system).

ASDF Systems

journal.


4.1.2 journal/src/package.lisp

Source

journal.asd.

Parent Component

src (module).

Packages

journal.


4.1.3 journal/src/interrupt.lisp

Dependency

package.lisp (file).

Source

journal.asd.

Parent Component

src (module).

Internals

4.1.4 journal/src/journal.lisp

Dependency

interrupt.lisp (file).

Source

journal.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.5 journal/src/doc.lisp

Dependency

journal.lisp (file).

Source

journal.asd.

Parent Component

src (module).

Internals

5 Packages

Packages are listed by definition order.


5.1 journal

Source

package.lisp.

Nickname

jrn

Use List
  • common-lisp.
  • editor-hints.named-readtables.
  • mgl-pax.
  • pythonic-string-reader.
Public Interface
Internals

6 Definitions

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


6.1 Public Interface


6.1.1 Special variables

Special Variable: *force-insertable*

The default value of the INSERTABLE argument of JOURNALED for VERSIONED-EVENTs. Binding this to T allows en-masse structural upgrades in combination with WITH-REPLAY-FILTER. Does not affect EXTERNAL-EVENTs. See @UPGRADES-AND-REPLAY.

Package

journal.

Source

journal.lisp.

Special Variable: *trace-journal*

The JOURNAL where JTRACE writes LOG-EVENTs. By default it is a PPRINT-JOURNAL that sets up a SYNONYM-STREAM to *TRACE-OUTPUT* and sends its output there. It pays attention to *TRACE-PRETTY*, and its log decorator is affected by *TRACE-TIME* and *TRACE-THREAD*. However, by changing JOURNAL-LOG-DECORATOR and PPRINT-JOURNAL-PRETTIFIER content and output can be customized.

Package

journal.

Source

journal.lisp.

Special Variable: *trace-pretty*

If *TRACE-PRETTY* is true, then JTRACE produces output like PPRINT-EVENTS, else it’s like PRINT-EVENTS.

Package

journal.

Source

journal.lisp.

Special Variable: *trace-real-time*

Controls whether to decorate the trace with the internal real-time. See MAKE-LOG-DECORATOR.

Package

journal.

Source

journal.lisp.

Special Variable: *trace-run-time*

Controls whether to decorate the trace with the internal run-time. See MAKE-LOG-DECORATOR.

Package

journal.

Source

journal.lisp.

Special Variable: *trace-thread*

Controls whether to decorate the trace with the name of the originating thread. See MAKE-LOG-DECORATOR.

Package

journal.

Source

journal.lisp.

Special Variable: *trace-time*

Controls whether to decorate the trace with a timestamp. See MAKE-LOG-DECORATOR.

Package

journal.

Source

journal.lisp.

Special Variable: @block
Package

journal.

Source

journal.lisp.

Special Variable: @bundles
Package

journal.

Source

journal.lisp.

Special Variable: @bundles-reference
Package

journal.

Source

journal.lisp.

Special Variable: @comparing-journals
Package

journal.

Source

journal.lisp.

Special Variable: @customizing-logs
Package

journal.

Source

journal.lisp.

Special Variable: @decoration
Package

journal.

Source

journal.lisp.

Special Variable: @event-versions
Package

journal.

Source

journal.lisp.

Special Variable: @events-reference
Package

journal.

Source

journal.lisp.

Special Variable: @file-bundles
Package

journal.

Source

journal.lisp.

Special Variable: @file-journals
Package

journal.

Source

journal.lisp.

Special Variable: @frame
Package

journal.

Source

journal.lisp.

Special Variable: @in-events
Package

journal.

Source

journal.lisp.

Special Variable: @in-events-reference
Package

journal.

Source

journal.lisp.

Special Variable: @in-memory-bundles
Package

journal.

Source

journal.lisp.

Special Variable: @in-memory-journals
Package

journal.

Source

journal.lisp.

Special Variable: @journal-background
Package

journal.

Source

journal.lisp.

Special Variable: @journal-basics
Package

journal.

Source

journal.lisp.

Special Variable: @journal-error-handling
Package

journal.

Source

journal.lisp.

Special Variable: @journal-features
Package

journal.

Source

journal.lisp.

Package

journal.

Source

journal.lisp.

Special Variable: @journal-manual
Package

journal.

Source

journal.lisp.

Special Variable: @journal-portability
Package

journal.

Source

journal.lisp.

Special Variable: @journal-slime-integration
Package

journal.

Source

journal.lisp.

Special Variable: @journal-utilities
Package

journal.

Source

journal.lisp.

Special Variable: @journal/glossary
Package

journal.

Source

journal.lisp.

Special Variable: @journaled-for-replay
Package

journal.

Source

journal.lisp.

Special Variable: @journals-reference
Package

journal.

Source

journal.lisp.

Special Variable: @leaf-events-reference
Package

journal.

Source

journal.lisp.

Special Variable: @log-record
Package

journal.

Source

journal.lisp.

Special Variable: @logging
Package

journal.

Source

journal.lisp.

Special Variable: @logging-with-leaves
Package

journal.

Source

journal.lisp.

Special Variable: @matching-in-events
Package

journal.

Source

journal.lisp.

Special Variable: @matching-out-events
Package

journal.

Source

journal.lisp.

Special Variable: @opening-and-closing
Package

journal.

Source

journal.lisp.

Special Variable: @out-events
Package

journal.

Source

journal.lisp.

Special Variable: @out-events-reference
Package

journal.

Source

journal.lisp.

Special Variable: @persistence
Package

journal.

Source

journal.lisp.

Special Variable: @persistence-tutorial
Package

journal.

Source

journal.lisp.

Special Variable: @pprint-journals
Package

journal.

Source

journal.lisp.

Special Variable: @pretty-printing
Package

journal.

Source

journal.lisp.

Special Variable: @reading-from-streamlets
Package

journal.

Source

journal.lisp.

Special Variable: @replay
Package

journal.

Source

journal.lisp.

Special Variable: @replay-failures
Package

journal.

Source

journal.lisp.

Special Variable: @replaying-the-outcome
Package

journal.

Source

journal.lisp.

Special Variable: @safety
Package

journal.

Source

journal.lisp.

Special Variable: @streamlets-reference
Package

journal.

Source

journal.lisp.

Special Variable: @synchronization
Package

journal.

Source

journal.lisp.

Special Variable: @synchronization-strategies
Package

journal.

Source

journal.lisp.

Special Variable: @synchronization-with-file-journals
Package

journal.

Source

journal.lisp.

Special Variable: @synchronization-with-in-memory-journals
Package

journal.

Source

journal.lisp.

Special Variable: @testing
Package

journal.

Source

journal.lisp.

Special Variable: @testing-on-multiple-levels
Package

journal.

Source

journal.lisp.

Special Variable: @the-replay-strategy
Package

journal.

Source

journal.lisp.

Special Variable: @tracing
Package

journal.

Source

journal.lisp.

Special Variable: @upgrades-and-replay
Package

journal.

Source

journal.lisp.

Special Variable: @working-with-unreadable-values
Package

journal.

Source

journal.lisp.

Special Variable: @writing-to-streamlets
Package

journal.

Source

journal.lisp.

Special Variable: aborted-execution
Package

journal.

Source

journal.lisp.

Special Variable: condition-outcome
Package

journal.

Source

journal.lisp.

Special Variable: data-event
Package

journal.

Source

journal.lisp.

Special Variable: error-outcome
Package

journal.

Source

journal.lisp.

Special Variable: expected-outcome
Package

journal.

Source

journal.lisp.

Special Variable: invoked
Package

journal.

Source

journal.lisp.

Special Variable: nlx-outcome
Package

journal.

Source

journal.lisp.

Special Variable: replay-event
Package

journal.

Source

journal.lisp.

Special Variable: unexpected-outcome
Package

journal.

Source

journal.lisp.

Special Variable: values-outcome
Package

journal.

Source

journal.lisp.


6.1.2 Macros

Macro: checked ((name &key version args values condition insertable) &body body)

A wrapper around JOURNALED to produce @FRAMEs of VERSIONED-EVENTs. VERSION defaults to 1. CHECKED is for ensuring that supposedly deterministic processing does not veer off the replay.

With CHECKED, BODY - which must be deterministic - is always run and REPLAY-FAILUREs are triggered when the events generated do not match the events in the replay journal. BODY may have side-effects.

For further discussion of determinism, see REPLAYED.

Package

journal.

Source

journal.lisp.

Macro: define-file-bundle-test ((name &key directory equivalentp) &body body)

Define a function with NAME for record-and-replay testing. The function’s BODY is executed in a WITH-BUNDLE to guarantee replayability. The bundle in question is a FILE-BUNDLE created in DIRECTORY. The function has a single keyword argument, RERECORD. If RERECORD is true, the bundle is deleted with DELETE-FILE-BUNDLE to start afresh.

Furthermore, if BODY returns normally, and it is a replay of a previous run, and EQUIVALENTP, then it is ASSERTed that the record and replay journals are EQUIVALENT-REPLAY-JOURNALS-P. If this check fails, RECORD-JOURNAL is discarded when the function returns. In addition to the replay consistency, this checks that no inserts or upgrades were performed (see @THE-REPLAY-STRATEGY).

Package

journal.

Source

journal.lisp.

Macro: define-invoked (function-name args (name &key version insertable) &body body)

DEFINE-INVOKED is intended for recording asynchronous function invocations like event or signal handlers. It defines a function that records VERSIONED-EVENTs with ARGS set to the actual arguments. At replay, it is invoked whenever the recorded IN-EVENT becomes the REPLAY-EVENT.

DEFUN and CHECKED rolled into one, DEFINE-INVOKED defines a top-level function with FUNCTION-NAME and ARGS (only simple positional arguments are allowed) and wraps CHECKED with NAME, the same ARGS and INSERTABLE around BODY. Whenever an IN-EVENT becomes the REPLAY-EVENT and it has a DEFINE-INVOKED defined with the name of the event, then FUNCTION-NAME is invoked with EVENT-ARGS.

While BODY’s return values are recorded as usual, the defined function returns no values to make it less likely to affect control flow in a way that’s not possible to reproduce when the function is called by the replay mechanism.

“‘
(defvar *state*)

(define-invoked foo (x) ("foo")
(setq *state* (1+ x)))

(define-invoked bar (x) ("bar")
(setq *state* (+ 2 x)))

(if (zerop (random 2))
(foo 0)
(bar 1))
“‘

The above can be alternatively implemented with REPLAYED explicitly encapsulating the non-determinism:

“‘
(let ((x (replayed (choose) (random 2))))
(if (zerop x)
(checked (foo :args ‘(,x))
(setq *state* (1+ x)))
(checked (bar :args ‘(,x))
(setq *state* (+ 2 x)))))
“‘

Package

journal.

Source

journal.lisp.

Macro: flet-invoked (definitions &body body)

Like DEFINE-INVOKED, but with FLET instead of DEFUN. The event name and the function are associated in the dynamic extent of BODY. WITH-JOURNALING does not change the bindings. The example in DEFINE-INVOKED can be rewritten as:

“‘
(let ((state nil))
(flet-invoked ((foo (x) ("foo")
(setq state (1+ x)))
(bar (x) ("bar")
(setq state (+ 2 x))))
(if (zerop (random 2))
(foo 0)
(bar 1))))
“‘

Package

journal.

Source

journal.lisp.

Macro: framed ((name &key log-record args values condition) &body body)

A wrapper around JOURNALED to produce @FRAMEs of LOG-EVENTs. That is, VERSION is always NIL, and some irrelevant arguments are omitted. The related LOGGED creates a single LEAF-EVENT.

With FRAMED, BODY is always run and no REPLAY-FAILUREs are triggered. BODY is not required to be deterministic and it may have side-effects.

Package

journal.

Source

journal.lisp.

Macro: journaled ((name &key log-record version args values condition insertable replay-values replay-condition) &body body)

JOURNALED generates events upon entering and leaving the dynamic extent of BODY (also known as the journaled @BLOCK), which we call the @IN-EVENTS and @OUT-EVENTS. Between generating the two events, BODY is typically executed normally (except for @REPLAYING-THE-OUTCOME).

Where the generated events are written is determined by the :RECORD argument of the enclosing WITH-JOURNALING. If there is no enclosing WITH-JOURNALING and LOG-RECORD is NIL, then event recording is turned off and JOURNALED imposes minimal overhead.

- NAME can be of any type except [NULL][type], not evaluated. For names, and for anything that gets written to a journal, a non-keyword symbol is a reasonable choice as it can be easily made unique. However, it also exposes the package structure, which might make reading stuff back more difficult. Keywords and strings do not have this problem.

- ARGS can be of any type, but is typically a list.

Also see in @LOG-RECORD in the @LOGGING section. For a description of VERSION, INSERTABLE, REPLAY-VALUES and REPLAY-CONDITION, see @JOURNALED-FOR-REPLAY.

Package

journal.

Source

journal.lisp.

Macro: jtrace (&rest names)

Like CL:TRACE, JTRACE takes a list of symbols. When functions denoted by those NAMES are invoked, their names, arguments and outcomes are printed in human readable form to *TRACE-OUTPUT*. These values may not be @READABLE, JTRACE does not care.

The format of the output is the same as that of PPRINT-EVENTS. Behind the scenes, JTRACE encapsulates the global functions with NAMES in wrapper that behaves as if ‘FOO‘ in the example above was defined like this:

“‘
(defun foo (x)
(framed (foo :args ‘(,x) :log-record *trace-journal*)
(1+ x)))
“‘

If JTRACE is invoked with no arguments, it returns the list of symbols currently traced.

On Lisps other than SBCL, where a function encapsulation facility is not available or it is not used by Journal, JTRACE simply sets SYMBOL-FUNCTION. This solution loses the tracing encapsulation when the function is recompiled. On these platforms, ‘(JTRACE)‘ also retraces all functions that should be traced, but aren’t.

The main advantage of JTRACE over CL:TRACE is the ability to trace errors, not just normal return values. As it is built on JOURNALED, it can also detect - somewhat heuristically - THROWs and similar.

Package

journal.

Source

journal.lisp.

Macro: juntrace (&rest names)

Like CL:UNTRACE, JUNTRACE makes it so that the global functions denoted by the symbols NAMES are no longer traced by JTRACE. When invoked with no arguments, it untraces all traced functions.

Package

journal.

Source

journal.lisp.

Macro: logged ((&optional log-record) format-control &rest format-args)

LOGGED creates a single LEAF-EVENT whose name is the string constructed by FORMAT. For example:

“‘
(with-journaling (:record t)
(logged () "Hello, ~A." "world")
(list-events))
=> ((:LEAF "Hello, world."))
“‘

LEAF-EVENTs are LOG-EVENTs with no separate in- and out-events. They have an EVENT-NAME and no other properties. Use LOGGED for point-in-time textual log messages, and JOURNALED with VERSION NIL (i.e. FRAMED) to provide context.

Also see @LOG-RECORD.

Package

journal.

Source

journal.lisp.

Macro: replayed ((name &key args values condition insertable replay-values replay-condition) &body body)

A wrapper around JOURNALED to produce @FRAMEs of EXTERNAL-EVENTs. VERSION is :INFINITY. REPLAYED is for primarily for marking and isolating non-deterministic processing.

With REPLAYED, the IN-EVENT is checked for consistency with the replay (as with CHECKED), but BODY is not run (assuming it has a recorded EXPECTED-OUTCOME) and the outcome in the OUT-EVENT is reproduced (see @REPLAYING-THE-OUTCOME). For this scheme to work, REPLAYED requires its BODY to be side-effect free, but it may be non-deterministic.

Package

journal.

Source

journal.lisp.

Macro: save-excursion ((streamlet) &body body)

Save READ-POSITION of STREAMLET, execute BODY, and make sure to restore the saved read position.

Package

journal.

Source

journal.lisp.

Macro: with-bundle ((bundle) &body body)

This is like WITH-JOURNALING where the REPLAY-JOURNAL is the last successfully completed one in BUNDLE, and the RECORD-JOURNAL is a new one created in BUNDLE. When WITH-BUNDLE finishes, the record journal is in JOURNAL-STATE :FAILED or :COMPLETED.

To avoid accumulating useless data, the new record is immediately deleted when WITH-BUNDLE finishes if it has not diverged from the replay journal (see JOURNAL-DIVERGENT-P). Because :FAILED journals are always divergent in this sense, they are deleted instead based on whether there is already a previous failed journal in the bundle and the new record is identical to that journal (see IDENTICAL-JOURNALS-P).

It is a JOURNAL-ERROR to have concurrent or nested WITH-BUNDLEs on the same bundle.

Package

journal.

Source

journal.lisp.

Macro: with-journaling ((&key record replay replay-eoj-error-p) &body body)

Turn recording and/or replaying of events on or off for the duration of BODY. Both RECORD and REPLAY should be a JOURNAL designator (in the sense of TO-JOURNAL) or NIL.

If RECORD designates a JOURNAL, then events generated by enclosed JOURNALED @BLOCKs are written to that journal (with exceptions, see the LOG-RECORD argument of JOURNALED). If REPLAY designates a JOURNAL, then the generated events are matched against events from that journal according to the rules of @REPLAY.

A JOURNAL-ERROR is signalled, if RECORD is a JOURNAL that has been previously recorded to by another WITH-JOURNALING (that is, if its JOURNAL-STATE is not :NEW), or if REPLAY is a JOURNAL that is not a complete recording of successful replay (i.e. its JOURNAL-STATE is not :COMPLETED). These checks are intended to catch mistakes that would render the new or existing records unusable for replay. When WITH-JOURNALING finishes, the RECORD journal is marked :COMPLETED or :FAILED in its JOURNAL-STATE.

REPLAY-EOJ-ERROR-P controls whether an END-OF-JOURNAL is signalled when a new event is being matched to the replay journal from which there are no more events to read. If there was a JOURNALING-FAILURE or a REPLAY-FAILURE during execution, then END-OF-JOURNAL is not signalled.

If BODY completes successfully, but REPLAY has unprocessed events, then signal REPLAY-INCOMPLETE.

WITH-JOURNALING for different RECORD journals can be nested and run independently.

Package

journal.

Source

journal.lisp.

Macro: with-open-journal ((var journal &key direction) &body body)

This is like WITH-OPEN-FILE. Open the journal designated by JOURNAL (see TO-JOURNAL) with OPEN-STREAMLET, passing DIRECTION along, and bind VAR to the resulting STREAMLET. Call CLOSE-STREAMLET after BODY finishes. If JOURNAL is NIL, then VAR is bound to NIL and no streamlet is created.

Package

journal.

Source

journal.lisp.

Macro: with-replay-filter ((&key map skip no-replay-outcome) &body body)

WITH-REPLAY-FILTER performs journal upgrade during replay by allowing events to be transformed as they are read from the replay journal or skipped if they match some patterns. For how to add new blocks in a code upgrade, see JOURNALED’s :INSERTABLE argument. In addition, it also allows some control over @REPLAYING-THE-OUTCOME.

- MAP: A function called with an event read from the replay journal which returns a transformed event. See @EVENTS-REFERENCE. MAP takes effect before before SKIP.

- SKIP: In addition to filtering out LOG-EVENTs (which always happens during replay), filter out all events that belong to descendant frames that match any of its SKIP patterns. Filtered out events are never seen by JOURNALED as it replays events. SKIP patterns are of the format ‘(&KEY NAME VERSION<)‘, where VERSION< is a valid [EVENT-VERSION][type], and NAME may be NIL, which acts as a wildcard.

SKIP is for when JOURNALED @BLOCKs are removed from the code, which would render replaying previously recorded journals impossible. Note that, for reasons of safety, it is not possible to filter EXTERNAL-EVENTs.

- NO-REPLAY-OUTCOME is a list of EVENT-NAMEs. @REPLAYING-THE-OUTCOME is prevented for frames with EQUAL names. See @TESTING-ON-MULTIPLE-LEVELS for an example.

WITH-REPLAY-FILTER affects only the immediately enclosing WITH-JOURNALING. A WITH-REPLAY-FILTER nested within another in the same WITH-JOURNALING inherits the SKIP patterns of its parent, to which it adds its own. The MAP function is applied to before the parent’s MAP.

Examples of SKIP patterns:

“‘
;; Match events with name FOO and version 1, 2, 3 or 4
(:name foo :version< 5)
;; Match events with name BAR and any version
(:name bar :version< :infinity)
;; Same as the previous
(:name bar)
;; Match all names
(:name nil)
;; Same as the previous
()
“‘

Skipping can be thought of as removing nodes of the tree of frames, connecting its children to its parent. The following example removes frames ‘J1‘ and ‘J2‘ from around ‘J3‘, the ‘J1‘ frame from within ‘J3‘, and the third ‘J1‘ frame.

“‘
(let ((journal (make-in-memory-journal)))
;; Record trees J1 -> J2 -> J3 -> J1, and J1.
(with-journaling (:record journal)
(checked (j1)
(checked (j2)
(checked (j3)
(checked (j1)
42))))
(checked (j1)
7))
;; Filter out all occurrences of VERSIONED-EVENTs named J1 and ;; J2 from the replay, leaving only J3 to match. (with-journaling (:replay journal :record t :replay-eoj-error-p t) (with-replay-filter (:skip ’((:name j1) (:name j2))) (checked (j3)
42))))
“‘

Package

journal.

Source

journal.lisp.

Macro: with-replay-streamlet ((var) &body body)

Open REPLAY-JOURNAL for reading with WITH-OPEN-JOURNAL set the READ-POSITION on it to the event next read by the @REPLAY mechanism (which is never a LOG-EVENT). The low-level @READING-FROM-STREAMLETS api is then available to inspect the contents of the replay. It is an error if REPLAY-JOURNAL is NIL.

Package

journal.

Source

journal.lisp.


6.1.3 Setf expanders

Setf Expander: (setf read-position) (streamlet)
Package

journal.

Source

journal.lisp.

Reader

read-position (generic function).

Writer

set-read-position (generic function).


6.1.4 Ordinary functions

Function: delete-file-bundle (directory)

Delete all journal files (‘*.jrn‘) from DIRECTORY. Delete the directory if empty after the journal files were deleted, else signal an error. Existing FILE-BUNDLE objects are not updated, so MAKE-FILE-JOURNAL with FORCE-RELOAD may be required.

Package

journal.

Source

journal.lisp.

Function: event-args (in-event)

Return the arguments of IN-EVENT, normally populated with the ARGS form in JOURNALED.

Package

journal.

Source

journal.lisp.

Function: event-exit (out-event)

Return how the journaled @BLOCK finished. See [EVENT-EXIT][type] for the possible types.

Package

journal.

Source

journal.lisp.

Function: event-name (event)

The name of an event can be of any type. It is often a symbol or a string. When replaying, names may be compared with EQUAL. All EVENTs have names. The names of the in- and out-events belonging to the same @FRAME are the same.

Package

journal.

Source

journal.lisp.

Function: event-outcome (out-event)

Return the outcome of the @FRAME (or loosely speaking of a @BLOCK) to which OUT-EVENT belongs.

Package

journal.

Source

journal.lisp.

Function: event-version (event)

Return the version of EVENT of type EVENT-VERSION.

Package

journal.

Source

journal.lisp.

Function: event= (event-1 event-2)

Return whether EVENT-1 and EVENT-2 represent the same event. In- and out-events belonging to the same @FRAME are _not_ the same event. EVENT-OUTCOME is not compared when EVENT-EXIT is :ERROR to avoid undue dependence on implementation specific string representations. This function is useful in conjunction with MAKE-IN-EVENT and MAKE-OUT-EVENT to write tests.

Package

journal.

Source

journal.lisp.

Function: events-to-frames (events)

Convert a flat list of events, such as those returned by LIST-EVENTS, to a nested list representing the @FRAMEs. Each frame is a list of the form ‘(<in-event> <nested-frames>* <out-event>?)‘. Like in PRINT-EVENTS, EVENTS may be a JOURNAL.

“‘
(events-to-frames ’((:in foo :args (1 2))
(:in bar :args (7))
(:leaf "leaf")
(:out bar :values (8))
(:out foo :values (2))
(:in foo :args (3 4))
(:in bar :args (8))))
=> (((:IN FOO :ARGS (1 2))
((:IN BAR :ARGS (7))
(:LEAF "leaf")
(:OUT BAR :VALUES (8)))
(:OUT FOO :VALUES (2)))
((:IN FOO :ARGS (3 4)) ((:IN BAR :ARGS (8)))))
“‘

Note that, as in the above example, incomplete frames (those without an OUT-EVENT) are included in the output.

Package

journal.

Source

journal.lisp.

Function: expected-outcome-p (out-event)

See if OUT-EVENT has an EXPECTED-OUTCOME.

Package

journal.

Source

journal.lisp.

Function: expected-type (type)

Return a function suitable as the CONDITION argument of JOURNALED, which returns the type of its single argument as a string if it is of TYPE, else NIL.

Package

journal.

Source

journal.lisp.

Function: external-event-p (event)

See if EVENT is an EXTERNAL-EVENT.

Package

journal.

Source

journal.lisp.

Function: in-event-p (event)

See if EVENT is a IN-EVENT.

Package

journal.

Source

journal.lisp.

Function: input-streamlet-p (streamlet)

See if STREAMLET was opened for input (the DIRECTION argument of OPEN-STREAMLET was :INPUT or :IO).

Package

journal.

Source

journal.lisp.

Function: journal-divergent-p (journal)

See if WITH-JOURNALING recorded any event so far in this journal which was not EQUAL to its REPLAY-EVENT or it had no corresponding replay event. This completely ignores LOG-EVENTs in both journals being compared, and is updated continuously during @REPLAY. It plays a role in WITH-BUNDLE deciding when a journal is important enough to keep, and also in @SYNCHRONIZATION-WITH-IN-MEMORY-JOURNALS.

The position of the first mismatch that is available via JOURNAL-REPLAY-MISMATCH.

Package

journal.

Source

journal.lisp.

Function: journaling-failure (condition-type &rest args)
Package

journal.

Source

journal.lisp.

Function: leaf-event-p (event)

See if EVENT is a LEAF-EVENT.

Package

journal.

Source

journal.lisp.

Function: list-events (&optional journal)

Return a list of all the events in the journal designated by JOURNAL. Calls SYNC-JOURNAL first, to make sure that all writes are taken into account.

Package

journal.

Source

journal.lisp.

Function: log-event-p (event)

See if EVENT is a LOG-EVENT.

Package

journal.

Source

journal.lisp.

Function: make-file-bundle (directory &key max-n-failed max-n-completed sync)

Return a FILE-BUNDLE object backed by FILE-JOURNALs in DIRECTORY. See [MAX-N-FAILED][(accessor bundle)] and [MAX-N-COMPLETED][(accessor bundle)]. For a description of SYNC, see @SYNCHRONIZATION-STRATEGIES.

If there is already a FILE-BUNDLE with the same directory (according to TRUENAME), return that object is returned if it has the same MAX-N-FAILED, MAX-N-COMPLETED and SYNC options, else JOURNAL-ERROR is signalled.

Package

journal.

Source

journal.lisp.

Function: make-file-journal (pathname &key sync)

Return a FILE-JOURNAL backed by the file with PATHNAME. The file is created when the journal is opened for writing. For a description of SYNC, see @SYNCHRONIZATION-STRATEGIES.

If there is already an existing FILE-JOURNAL backed by the same file, then that object is returned. If the existing object has different options (e.g. it has SYNC T while the SYNC argument is NIL here), then a JOURNAL-ERROR is signalled.

If there is already an existing FILE-JOURNAL backed by the same file, the JOURNAL-STATE is not :NEW, but the file doesn’t exist, then the existing object is __invalidated__: attempts to write will fail with JOURNAL-ERROR. If the existing journal object is being written, then invalidation fails with a JOURNAL-ERROR. After invalidation, a new FILE-JOURNAL object is created.

Package

journal.

Source

journal.lisp.

Function: make-in-event (&key name version args)

Create an IN-EVENT with NAME, VERSION (of type EVENT-VERSION) and ARGS as its EVENT-NAME, [EVENT-VERSION][function] and EVENT-ARGS.

Package

journal.

Source

journal.lisp.

Function: make-in-memory-bundle (&key max-n-failed max-n-completed sync sync-fn)

Create a new IN-MEMORY-BUNDLE with [MAX-N-FAILED][(accessor bundle)] and [MAX-N-COMPLETED][(accessor bundle)]. SYNC and SYNC-FN are passed on to MAKE-IN-MEMORY-JOURNAL.

Package

journal.

Source

journal.lisp.

Function: make-in-memory-journal (&key events state sync sync-fn)

By default, creates an empty IN-MEMORY-JOURNAL in JOURNAL-STATE
:NEW, which is suitable for recording. To make a replay journal, use :STATE :COMPLETED with some sequence of EVENTS:

“‘
(make-in-memory-journal :events ’((:in foo :version 1)) :state :completed) “‘

If the EVENTS argument is provided, then STATE defaults to :NEW,
else to :COMPLETED.

SYNC determines when SYNC-FN will be invoked on the RECORD-JOURNAL. SYNC defaults to T if SYNC-FN, else to NIL. For a description of possible values, see @SYNCHRONIZATION-STRATEGIES. For more
discussion, see @SYNCHRONIZATION-WITH-IN-MEMORY-JOURNALS.

Package

journal.

Source

journal.lisp.

Function: make-leaf-event (name)

Create a LEAF-EVENT with NAME.

Package

journal.

Source

journal.lisp.

Function: make-log-decorator (&key thread time real-time run-time)

Return a function suitable as JOURNAL-LOG-DECORATOR that may add
the name of the thread, a timestamp, the internal real-time or run-time (both in seconds) to events. THREAD, TIME, REAL-TIME and RUN-TIME are @BOOLEAN-VALUED-SYMBOLs.

“‘
(funcall (make-log-decorator :thread t :time t :real-time t :run-time t) (make-leaf-event :foo))
=> (:LEAF :FOO :TIME "2020-08-31T13:38:58.129178+02:00"
:REAL-TIME 66328.82 :RUN-TIME 98.663 :THREAD "worker")
“‘

Package

journal.

Source

journal.lisp.

Function: make-out-event (&key name version exit outcome)

Create an OUT-EVENT with NAME, VERSION (of type EVENT-VERSION), EXIT (of type EVENT-EXIT), and OUTCOME as its EVENT-NAME, [EVENT-VERSION][function], [EVENT-EXIT][function] and EVENT-OUTCOME.

Package

journal.

Source

journal.lisp.

Function: make-pprint-journal (&key stream pretty prettifier log-decorator)

Creates a PPRINT-JOURNAL.

Package

journal.

Source

journal.lisp.

Function: out-event-p (event)

See if EVENT is an OUT-EVENT.

Package

journal.

Source

journal.lisp.

Function: output-streamlet-p (streamlet)

See if STREAMLET was opened for input (the DIRECTION argument of OPEN-STREAMLET was :OUTPUT or :IO).

Package

journal.

Source

journal.lisp.

Function: peek-replay-event ()

Return the REPLAY-EVENT to be read from REPLAY-JOURNAL. This is roughly equivalent to

“‘
(when (replay-journal)
(with-replay-streamlet (streamlet)
(peek-event streamlet))
“‘

except PEEK-REPLAY-EVENT takes into account WITH-REPLAY-FILTER :MAP, and it may return ‘(:INDETERMINATE)‘ if WITH-REPLAY-FILTER :SKIP is in effect and what events are to be skipped cannot be decided until the next in-event generated by the code.

Imagine a business process for paying an invoice. In the first version of this process, we just pay the invoice:

“‘
(replayed (pay))
“‘

We have left the implementation of PAY blank. In the second version, we need to get an approval first:

“‘
(when (replayed (get-approval)
(= (random 2) 0))
(replayed (pay)))
“‘

Replaying a journal produced by the first version of the code with the second version would run into difficulties because inserting EXTERNAL-EVENTs is tricky.

We have to first decide how to handle the lack of approval in the first version. Here, we just assume the processes started by the first version get approval automatically. The implementation is based on a dummy ‘PROCESS‘ block whose version is bumped when the payment process changes and is inspected at the start of journaling.

When v1 is replayed with v2, we introduce an INSERTABLE, versioned ‘GET-APPROVAL‘ block that just returns T. When replaying the code again, still with v2, the ‘GET-APPROVAL‘ block will be upgraded to :INFINITY.

“‘
(let ((bundle (make-in-memory-bundle)))
;; First version of the payment process. Just pay. (with-bundle (bundle)
(checked (process :version 1))
(replayed (pay)))
;; Second version of the payment process. Only pay if approved. (loop repeat 2 do
(with-bundle (bundle)
(let ((replay-process-event (peek-replay-event)))
(checked (process :version 2))
(when (if (and replay-process-event
(< (event-version replay-process-event) 2)) ;; This will be upgraded to :INFINITY the second ;; time around the LOOP.
(checked (get-approval :insertable t) t)
(replayed (get-approval)
(= (random 2) 0)))
(replayed (pay)))))))
“‘

Package

journal.

Source

journal.lisp.

Function: pprint-events (events &key stream prettifier)

Like PRINT-EVENTS, but produces terser, more human readable output.

“‘
(pprint-events ’((:in log :args ("first arg" 2))
(:in versioned :version 1 :args (3))
(:leaf "This is a leaf, not a frame.") (:out versioned :version 1 :values (42 t)) (:out log :condition "a :CONDITION outcome") (:in log-2)
(:out log-2 :nlx nil)
(:in external :version :infinity)
(:out external :version :infinity
:error ("ERROR" "an :ERROR outcome")))) ..
.. (LOG "first arg" 2)
.. (VERSIONED 3) v1
.. This is a leaf, not a frame.
.. => 42, T
.. =C "a :CONDITION outcome"
.. (LOG-2)
.. =X
.. (EXTERNAL) ext
.. =E "ERROR" "an :ERROR outcome"
=> ; No value
“‘

The function given as the PRETTIFIER argument formats individual events. The above output was produced with PRETTIFY-EVENT. For a description of PRETTIFIER’s arguments see PRETTIFY-EVENT.

Package

journal.

Source

journal.lisp.

Function: prettify-event (event depth stream)

Write EVENT to STREAM in a somewhat human-friendly format. This
is the function PPRINT-JOURNAL, PPRINT-EVENTS, and @TRACING use by default. In addition to the basic example in PPRINT-EVENTS,
@DECORATION on events is printed before normal, indented output like this:

“‘
(pprint-events ’((:leaf "About to sleep" :time "19:57:00" :function "FOO"))) ..
.. 19:57:00 FOO: About to sleep
“‘

DEPTH is the nesting level of the EVENT. Top-level events have depth
0. PRETTIFY-EVENT prints indents the output, after printing the decorations, by 2 spaces per depth.

Package

journal.

Source

journal.lisp.

Function: print-events (events &key stream)

Print EVENTS to STREAM as lists, starting a new line for each
event and indenting them according to their nesting structure.
EVENTS may be a JOURNAL, in which case LIST-EVENTS is called on it first.

“‘
(print-events ’((:in log :args ("first arg" 2))
(:in versioned :version 1 :args (3))
(:out versioned :version 1 :values (42 t))
(:out log :condition "a :CONDITION outcome")
(:in log-2)
(:out log-2 :nlx nil)
(:in external :version :infinity)
(:out external :version :infinity
:error ("ERROR" "an :ERROR outcome"))))
..
.. (:IN LOG :ARGS ("first arg" 2))
.. (:IN VERSIONED :VERSION 1 :ARGS (3))
.. (:OUT VERSIONED :VERSION 1 :VALUES (42 T))
.. (:OUT LOG :CONDITION "a :CONDITION outcome")
.. (:IN LOG-2)
.. (:OUT LOG-2 :NLX NIL)
.. (:IN EXTERNAL :VERSION :INFINITY)
.. (:OUT EXTERNAL :VERSION :INFINITY :ERROR ("ERROR" "an :ERROR outcome")) => ; No value
“‘

Package

journal.

Source

journal.lisp.

Function: record-journal ()

Return the journal in which events are currently being recorded (see WITH-JOURNALING and WITH-BUNDLE) or NIL.

Package

journal.

Source

journal.lisp.

Function: replay-failure (condition-type &key new-event replay-event insert-restart upgrade-restart continue-restart)
Package

journal.

Source

journal.lisp.

Function: replay-journal ()

Return the journal from which events are currently being replayed (see WITH-JOURNALING and WITH-BUNDLE) or NIL.

Package

journal.

Source

journal.lisp.

Function: sync-journal (&optional journal)

Durably persist all preceding writes made to JOURNAL during an enclosing WITH-JOURNALING or via LOG-RECORD from any thread. Writes made in a WITH-JOURNALING in another thread are not persisted. The changes in question are WRITE-EVENT calls and state changes. This is a noop JOURNAL-SYNC is NIL. This function is safe to call from any thread.

Package

journal.

Source

journal.lisp.

Function: unexpected-outcome-p (out-event)

See if OUT-EVENT has an UNEXPECTED-OUTCOME.

Package

journal.

Source

journal.lisp.

Function: values-> (&rest fns)

A utility to create a function suitable as the [VALUES][argument] argument of JOURNALED. The VALUES function is called with the list of values returned by the @BLOCK and returns a transformed set of values that may be recorded in a journal. While arbitrary transformations are allowed, ‘VALUES->‘ handles the common case of transforming individual elements of the list independently by calling the functions in FN with the values of the list of the same position.

“‘
(funcall (values-> #’1+) ’(7 :something))
=> (8 :SOMETHING)
“‘

Note how ‘#’1+‘ is applied only to the first element of the values list. The list of functions is shorter than the values list, so ‘:SOMETHING‘ is not transformed. A value can be left explicitly untransformed by specifying #’IDENTITY or NIL as the function:

“‘
(funcall (values-> #’1+ nil #’symbol-name)
’(7 :something :another))
=> (8 :SOMETHING "ANOTHER")
“‘

Package

journal.

Source

journal.lisp.

Function: values<- (&rest fns)

The inverse of ‘VALUES->‘, this returns a function suitable as the REPLAY-VALUES argument of JOURNALED. It does pretty much what ‘VALUES->‘ does, but the function returned returns the transformed list as multiple values instead of as a list.

“‘
(funcall (values<- #’1-) ’(8 :something))
=> 7
=> :SOMETHING
“‘

Package

journal.

Source

journal.lisp.

Function: versioned-event-p (event)

See if EVENT is a VERSIONED-EVENT.

Package

journal.

Source

journal.lisp.


6.1.5 Generic functions

Generic Function: close-streamlet (streamlet)

Close STREAMLET, which was returned by
OPEN-STREAMLET. After closing, STREAMLET may not longer be used for IO.

Package

journal.

Source

journal.lisp.

Methods
Method: close-streamlet ((streamlet file-streamlet))
Method: close-streamlet ((streamlet in-memory-streamlet))
Method: close-streamlet ((streamlet pprint-streamlet))
Method: close-streamlet :around ((streamlet streamlet))
Generic Reader: directory-of (object)
Package

journal.

Methods
Reader Method: directory-of ((file-bundle file-bundle))

The directory where the files backing the FILE-JOURNALs in the FILE-BUNDLE are kept.

Source

journal.lisp.

Target Slot

directory.

Generic Function: equivalent-replay-journals-p (journal-1 journal-2)

See if two journals are equivalent when used the
for REPLAY in WITH-JOURNALING. EQUIVALENT-REPLAY-JOURNALS-P is like IDENTICAL-JOURNALS-P, but it ignores LOG-EVENTs and allows events with EVENT-EXIT :ERROR to differ in their outcomes, which may very well be implementation specific, anyway. Also, it considers two groups of states as different :NEW, :REPLAYING, :MISMATCHED, :FAILED vs :RECORDING, :LOGGING, COMPLETED.

Package

journal.

Source

journal.lisp.

Methods
Method: equivalent-replay-journals-p :around (journal-1 journal-2)
Method: equivalent-replay-journals-p (journal-1 journal-2)
Generic Function: identical-journals-p (journal-1 journal-2)

Compare two journals in a strict sense: whether
they have the same JOURNAL-STATE and the lists of their events (as in LIST-EVENTS) are EQUAL.

Package

journal.

Source

journal.lisp.

Methods
Method: identical-journals-p ((journal-1 in-memory-journal) (journal-2 in-memory-journal))
Method: identical-journals-p :around (journal-1 journal-2)
Method: identical-journals-p (journal-1 journal-2)
Generic Reader: journal (object)
Package

journal.

Methods
Reader Method: journal ((condition end-of-journal))
Source

journal.lisp.

Target Slot

journal.

Reader Method: journal ((condition journal-error))
Source

journal.lisp.

Target Slot

journal.

Reader Method: journal ((streamlet streamlet))

The JOURNAL that was passed to OPEN-STREAMLET.
This is the journal [STREAMLET][dislocated] operates on.

Source

journal.lisp.

Target Slot

journal.

Generic Reader: journal-events (object)
Package

journal.

Methods
Reader Method: journal-events ((in-memory-journal in-memory-journal))

A sequence of events in the journal. Not to be mutated by client code.

Source

journal.lisp.

Target Slot

events.

Generic Reader: journal-log-decorator (object)
Generic Writer: (setf journal-log-decorator) (object)
Package

journal.

Methods
Reader Method: journal-log-decorator ((journal journal))
Writer Method: (setf journal-log-decorator) ((journal journal))

If non-NIL, a function to add @DECORATION to
LOG-EVENTs before they are written to a journal. The only allowed transformation is to _append_ a plist to the event, which is a plist itself. The keys can be anything.

Source

journal.lisp.

Target Slot

log-decorator.

Generic Reader: journal-previous-sync-position (object)
Package

journal.

Methods
Reader Method: journal-previous-sync-position ((in-memory-journal in-memory-journal))

The length of JOURNAL-EVENTS at the time of the most recent invocation of SYNC-FN.

Source

journal.lisp.

Target Slot

previous-sync-position.

Generic Reader: journal-replay-mismatch (object)
Package

journal.

Methods
Reader Method: journal-replay-mismatch ((journal journal))

If JOURNAL-DIVERGENT-P, then this is a list of two
elements: the READ-POSITIONs in the RECORD-JOURNAL and REPLAY-JOURNAL of the first events that were different (ignoring LOG-EVENTs). It is NIL, otherwise.

Source

journal.lisp.

Target Slot

replay-mismatch.

Generic Reader: journal-state (object)
Package

journal.

Methods
Reader Method: journal-state ((journal journal))

Return the state of JOURNAL, which is of type [JOURNAL-STATE][TYPE].

Source

journal.lisp.

Target Slot

state.

Generic Reader: journal-sync (object)
Package

journal.

Methods
Reader Method: journal-sync ((journal journal))

The SYNC argument specified at instantiation. See @SYNCHRONIZATION-STRATEGIES.

Source

journal.lisp.

Target Slot

sync.

Generic Reader: journaling-failure-embedded-condition (condition)
Package

journal.

Methods
Reader Method: journaling-failure-embedded-condition ((condition journaling-failure))
Source

journal.lisp.

Target Slot

embedded-condition.

Generic Function: make-streamlet-finalizer (streamlet)

Return NIL or a function of no arguments suitable
as a finalizer for STREAMLET. That is, the function closes STREAMLET, but holds no reference to it. This is intended for streamlets which are not dynamic-extent, so using WITH-OPEN-JOURNAL is not appropriate.

Package

journal.

Source

journal.lisp.

Methods
Method: make-streamlet-finalizer ((streamlet file-streamlet))
Method: make-streamlet-finalizer ((streamlet in-memory-streamlet))
Method: make-streamlet-finalizer ((streamlet pprint-streamlet))
Generic Reader: max-n-completed (object)
Generic Writer: (setf max-n-completed) (object)
Package

journal.

Methods
Reader Method: max-n-completed ((bundle bundle))
Writer Method: (setf max-n-completed) ((bundle bundle))

If MAX-N-COMPLETED is non-NIL, and the number of
journals of [JOURNAL-STATE][type] :COMPLETED in the bundle exceeds its value, then some journals (starting with the oldest) are deleted.

Source

journal.lisp.

Target Slot

max-n-completed.

Generic Reader: max-n-failed (object)
Generic Writer: (setf max-n-failed) (object)
Package

journal.

Methods
Reader Method: max-n-failed ((bundle bundle))
Writer Method: (setf max-n-failed) ((bundle bundle))

If MAX-N-FAILED is non-NIL, and the number of
journals of [JOURNAL-STATE][type] :FAILED in the bundle exceeds its value, then some journals (starting with the oldest) are deleted.

Source

journal.lisp.

Target Slot

max-n-failed.

Generic Function: open-streamlet (journal &key direction)

Return a STREAMLET suitable for performing I/O on
JOURNAL. DIRECTION (defaults to :INPUT) is one of :INPUT, :OUTPUT, :IO and it has the same purpose as the similarly named argument of CL:OPEN.

Package

journal.

Source

journal.lisp.

Methods
Method: open-streamlet ((bundle bundle) &key direction)
Method: open-streamlet ((journal file-journal) &key direction)
Method: open-streamlet ((journal in-memory-journal) &key direction)
Method: open-streamlet ((journal pprint-journal) &key direction)
Method: open-streamlet :around (journal &key direction)
Generic Function: open-streamlet-p (streamlet)

Return true if STREAMLET is open. STREAMLETs are
open until they have been explicitly closed with CLOSE-STREAMLET.

Package

journal.

Source

journal.lisp.

Methods
Method: open-streamlet-p ((streamlet streamlet))
Generic Reader: pathname-of (object)
Package

journal.

Methods
Reader Method: pathname-of ((file-journal file-journal))

The pathname of the file backing the journal.

Source

journal.lisp.

Target Slot

pathname.

Generic Function: peek-event (streamlet)

Read the next event from STREAMLET without changing
the read position, or return NIL if there is no event to be read.

Package

journal.

Source

journal.lisp.

Methods
Method: peek-event ((streamlet file-streamlet))
Method: peek-event ((streamlet in-memory-streamlet))
Method: peek-event ((streamlet streamlet))

This is a slow default implementation, which relies on SAVE-EXCURSION and READ-EVENT.

Generic Reader: pprint-journal-prettifier (object)
Generic Writer: (setf pprint-journal-prettifier) (object)
Package

journal.

Methods
Reader Method: pprint-journal-prettifier ((pprint-journal pprint-journal))
Writer Method: (setf pprint-journal-prettifier) ((pprint-journal pprint-journal))

A function like PRETTIFY-EVENT that writes its an
event to a stream. Only used when PPRINT-JOURNAL-PRETTY, this is the output format customization knob. Also see @DECORATIONs.

Source

journal.lisp.

Target Slot

prettifier.

Generic Reader: pprint-journal-pretty (object)
Generic Writer: (setf pprint-journal-pretty) (object)
Package

journal.

Methods
Reader Method: pprint-journal-pretty ((pprint-journal pprint-journal))
Writer Method: (setf pprint-journal-pretty) ((pprint-journal pprint-journal))

Whether to use PPRINT-JOURNAL-PRETTIFIER or write events in as the property lists they are. A @BOOLEAN-VALUED-SYMBOL.

Source

journal.lisp.

Target Slot

pretty.

Generic Reader: pprint-journal-stream (object)
Generic Writer: (setf pprint-journal-stream) (object)
Package

journal.

Methods
Reader Method: pprint-journal-stream ((pprint-journal pprint-journal))
Writer Method: (setf pprint-journal-stream) ((pprint-journal pprint-journal))

The stream where events are dumped. May be set any time to another STREAM.

Source

journal.lisp.

Target Slot

stream.

Generic Function: read-event (streamlet &optional eoj-error-p)

Read the event at the current read position from
STREAMLET and move the read position to the event after. If there are no more events, signal END-OF-JOURNAL or return NIL depending on EOJ-ERROR-P. Signals STREAMLET-ERROR if STREAMLET is not INPUT-STREAMLET-P or not OPEN-STREAMLET-P.

Package

journal.

Source

journal.lisp.

Methods
Method: read-event ((streamlet file-streamlet) &optional eoj-error-p)
Method: read-event ((streamlet in-memory-streamlet) &optional eoj-error-p)
Method: read-event :around ((streamlet streamlet) &optional eoj-error-p)
Generic Function: read-position (streamlet)

Return an integer that identifies the position of
the next event to be read from STREAMLET. ‘SETF‘able, see SET-READ-POSITION.

Package

journal.

Source

journal.lisp.

Setf expander for this generic function

(setf read-position).

Methods
Method: read-position ((streamlet file-streamlet))
Reader Method: read-position ((in-memory-streamlet in-memory-streamlet))

automatically generated reader method

Target Slot

%read-position.

Generic Reader: replay-failure-new-event (condition)
Package

journal.

Methods
Reader Method: replay-failure-new-event ((condition replay-failure))
Source

journal.lisp.

Target Slot

new-event.

Generic Reader: replay-failure-replay-event (condition)
Package

journal.

Methods
Reader Method: replay-failure-replay-event ((condition replay-failure))
Source

journal.lisp.

Target Slot

replay-event.

Generic Reader: replay-failure-replay-journal (condition)
Package

journal.

Methods
Reader Method: replay-failure-replay-journal ((condition replay-failure))
Source

journal.lisp.

Target Slot

replay-journal.

Generic Function: request-completed-on-abort (streamlet)

Make it so that upon ABORTED-EXECUTION STREAMLET’s
JOURNAL will be in JOURNAL-STATE :COMPLETED when loaded fresh (e.g. FILE-JOURNAL from a file). Any previously written events must be persisted before making this change. Before REQUEST-COMPLETED-ON-ABORT is called, a journal must be reloaded in state :FAILED.

It is permissible to defer carrying out this request until the next SYNC-STREAMLET call. If the request was carried out, return true. If it was deferred, return NIL.

Package

journal.

Source

journal.lisp.

Methods
Method: request-completed-on-abort ((streamlet file-streamlet))
Method: request-completed-on-abort ((streamlet in-memory-streamlet))
Method: request-completed-on-abort ((streamlet pprint-streamlet))
Method: request-completed-on-abort :around ((streamlet streamlet))
Generic Function: set-read-position (streamlet position)

Set the read position of STREAMLET to POSITION, which must have been acquired from READ-POSITION.

Package

journal.

Source

journal.lisp.

Setf expanders to this generic function

(setf read-position).

Methods
Method: set-read-position ((streamlet file-streamlet) read-position)
Method: set-read-position ((streamlet in-memory-streamlet) read-position)
Generic Reader: streamlet (condition)
Package

journal.

Methods
Reader Method: streamlet ((condition streamlet-error))
Source

journal.lisp.

Target Slot

streamlet.

Generic Function: sync-streamlet (streamlet)

Durably persist the effects of all preceding
WRITE-EVENT calls made via STREAMLET to its journal and any deferred REQUEST-COMPLETED-ON-ABORT in this order.

Package

journal.

Source

journal.lisp.

Methods
Method: sync-streamlet ((streamlet file-streamlet))
Method: sync-streamlet ((streamlet in-memory-streamlet))
Method: sync-streamlet ((streamlet pprint-streamlet))
Method: sync-streamlet :around ((streamlet streamlet))
Generic Function: to-journal (designator)

Return the journal designated by DESIGNATOR or
signal an error. The default implementation:

- returns DESIGNATOR itself if it is of type JOURNAL, - returns a new IN-MEMORY-JOURNAL if DESIGNATOR is T, - returns a new FILE-JOURNAL if DESIGNATOR is a PATHNAME.

Package

journal.

Source

journal.lisp.

Methods
Method: to-journal ((bundle bundle))
Method: to-journal ((designator journal))
Method: to-journal ((designator (eql t)))
Method: to-journal ((designator pathname))
Method: to-journal (designator)
Generic Function: write-event (event streamlet)

Write EVENT to STREAMLET. Writing always happens at
the end of STREAMLET’s journal regardless of the READ-POSITION and the read position is not changed. Signals STREAMLET-ERROR if STREAMLET is not OUTPUT-STREAMLET-P or not OPEN-STREAMLET-P.

Package

journal.

Source

journal.lisp.

Methods
Method: write-event (event (streamlet file-streamlet))
Method: write-event (event (streamlet in-memory-streamlet))
Method: write-event (event (streamlet pprint-streamlet))
Method: write-event :around (event (streamlet streamlet))
Method: write-event (event (journal journal))

For convenience, it is possible to write directly to a JOURNAL, in which case the journal’s internal output streamlet is used. This internal streamlet is opened for :OUTPUT and may be used by LOG-RECORD.

Generic Function: write-position (streamlet)

Return an integer that identifies the position of the next event to be written to STREAMLET.

Package

journal.

Source

journal.lisp.

Methods
Method: write-position ((streamlet file-streamlet))
Method: write-position ((streamlet in-memory-streamlet))
Method: write-position :around ((streamlet streamlet))

6.1.6 Standalone methods

Method: print-object ((journal file-journal) stream)
Source

journal.lisp.

Method: print-object ((streamlet streamlet) stream)
Source

journal.lisp.

Method: print-object ((journal journal) stream)
Source

journal.lisp.

Method: print-object ((bundle bundle) stream)
Source

journal.lisp.

Method: print-object ((bundle file-bundle) stream)
Source

journal.lisp.

Method: print-object ((journal in-memory-journal) stream)
Source

journal.lisp.


6.1.7 Conditions

Condition: data-event-lossage

Signalled when a DATA-EVENT is about to be recorded
in JOURNAL-STATE :MISMATCHED or :LOGGING. Since the data event will not be replayed that constitutes data loss.

Package

journal.

Source

journal.lisp.

Direct superclasses

journaling-failure.

Condition: end-of-journal

This might be signalled by the replay mechanism if WITH-JOURNALING’s REPLAY-EOJ-ERROR-P is true. Unlike REPLAY-FAILUREs, this does not affect JOURNAL-STATE of RECORD-JOURNAL. At a lower level, it is signalled by READ-EVENT upon reading past the end of the JOURNAL if EOJ-ERROR-P.

Package

journal.

Source

journal.lisp.

Direct superclasses

journal-error.

Direct methods

journal.

Direct slots
Slot: journal
Initargs

:journal

Readers

journal.

Writers

This slot is read-only.

Condition: journal-error

Signalled by WITH-JOURNALING, WITH-BUNDLE and by @LOG-RECORD. It is also signalled by the low-level streamlet interface (see @STREAMLETS-REFERENCE).

Package

journal.

Source

journal.lisp.

Direct superclasses

error.

Direct subclasses

end-of-journal.

Direct methods
Direct slots
Slot: journal

The JOURNAL in question.

Initargs

:journal

Readers

journal.

Writers

This slot is read-only.

Slot: format-control
Initargs

:format-control

Readers

format-control.

Writers

This slot is read-only.

Slot: format-args
Initform

(quote nil)

Initargs

:format-args

Readers

format-args.

Writers

This slot is read-only.

Condition: journaling-failure

Signalled during the dynamic extent of
WITH-JOURNALING when an error threatens to leave the journaling mechanism in an inconsistent state. These include I/O errors encountered reading or writing journals by WITH-JOURNALING, JOURNALED, LOGGED, WITH-REPLAY-FILTER, SYNC-JOURNAL, but also STORAGE-CONDITIONs, assertion failures, and errors calling JOURNALED’s [VALUES][argument] and [CONDITION][argument] function arguments. Crucially, this does not apply to non-local exits from other code, such as JOURNALED @BLOCKs, whose error handling is largely unaltered (see @OUT-EVENTS and @REPLAY-FAILURES).

In general, any @NON-LOCAL-EXIT from critical parts of the code is turned into a JOURNALING-FAILURE to protect the integrity of the RECORD-JOURNAL. The condition that caused the unwinding is in JOURNALING-FAILURE-EMBEDDED-CONDITION, or NIL if it was a pure @NON-LOCAL-EXIT like THROW. This is a SERIOUS-CONDITION, not to be handled within WITH-JOURNALING.

After a JOURNALING-FAILURE, the journaling mechanism cannot be trusted anymore. The REPLAY-JOURNAL might have failed a read and be out-of-sync. The RECORD-JOURNAL may have missing events (or even half-written events with FILE-JOURNALs without SYNC, see @SYNCHRONIZATION-STRATEGIES), and further writes to it would risk replayability, which is equivalent to database corruption. Thus, upon signalling JOURNALING-FAILURE, JOURNAL-STATE is set to

- :COMPLETED if the journal is in state :RECORDING or :LOGGING and the transition to :RECORDING was reflected in storage,

- else it is set to :FAILED.

After a JOURNALING-FAILURE, any further attempt within the affected WITH-JOURNALING to use the critical machinery mentioned
above (JOURNALED, LOGGED, etc) resignals the same journal failure condition. As a consequence, the record journal cannot be changed and the only way to recover is to leave WITH-JOURNALING. This does not affect processing in other threads, which by design cannot write to the record journal.

Note that in contrast with JOURNALING-FAILURE and REPLAY-FAILURE, which necessitate leaving WITH-JOURNALING to recover from, the other conditions - JOURNAL-ERROR, and STREAMLET-ERROR - are subclasses of [ERROR][condition] as the their handling need not be so heavy-handed.

Package

journal.

Source

journal.lisp.

Direct superclasses

serious-condition.

Direct subclasses

data-event-lossage.

Direct methods
Direct slots
Slot: embedded-condition
Initargs

:embedded-condition

Readers

journaling-failure-embedded-condition.

Writers

This slot is read-only.

Slot: n-resignallings
Initform

(quote 0)

Readers

journaling-failure-n-resignallings.

Writers

(setf journaling-failure-n-resignallings).

Condition: record-unexpected-outcome

Signalled (with SIGNAL: this is not an
[ERROR][condition]) by JOURNALED when a VERSIONED-EVENT or an EXTERNAL-EVENT had an UNEXPECTED-OUTCOME while in JOURNAL-STATE :RECORDING. Upon signalling this condition, JOURNAL-STATE is set to :LOGGING, thus no more events can be recorded that will affect replay of the journal being recorded. The event that triggered this condition is recorded in state :LOGGING, with its version downgraded. Since @REPLAY (except INVOKED) is built on the assumption that control flow is deterministic, an unexpected outcome is significant because it makes this assumption to hold unlikely.

Also see REPLAY-UNEXPECTED-OUTCOME.

Package

journal.

Source

journal.lisp.

Direct superclasses

condition.

Direct methods

new-event.

Direct slots
Slot: new-event

The event that triggered this condition.

Initargs

:new-event

Readers

new-event.

Writers

This slot is read-only.

Condition: replay-args-mismatch

Signaled when the new event’s and REPLAY-EVENT’s
EVENT-ARGS are not EQUAL. The REPLAY-FORCE-UPGRADE restart is provided.

Package

journal.

Source

journal.lisp.

Direct superclasses

replay-failure.

Condition: replay-failure

A common superclass (never signalled itself) for
all kinds of mismatches between the events produced and the replay journal. Signalled only in JOURNAL-STATE :REPLAYING and only once per WITH-JOURNALING. If a REPLAY-FAILURE is signalled for an EVENT, then the event will be recorded, but RECORD-JOURNAL will transition to JOURNAL-STATE :MISMATCHED. Like JOURNALING-FAILURE, this is a serious condition because it is to be handled outside the enclosing WITH-JOURNALING. If a REPLAY-FAILURE were to be handled inside the WITH-JOURNALING, keep in mind that in :MISMATCHED, replay always uses the _insert_ replay strategy (see @THE-REPLAY-STRATEGY).

Package

journal.

Source

journal.lisp.

Direct superclasses

serious-condition.

Direct subclasses
Direct methods
Direct slots
Slot: new-event

The event being generated.

Initargs

:new-event

Readers

replay-failure-new-event.

Writers

This slot is read-only.

Slot: replay-event

The event read from the replay journal.

Initargs

:replay-event

Readers

replay-failure-replay-event.

Writers

This slot is read-only.

Slot: record-journal

The RECORD-JOURNAL in effect at the time of signalling the error.

Initform

(quote (journal:record-journal))

Readers

replay-failure-record-journal.

Writers

This slot is read-only.

Slot: replay-journal

The REPLAY-JOURNAL in effect at the time of signalling the error.

Initform

(quote (journal:replay-journal))

Readers

replay-failure-replay-journal.

Writers

This slot is read-only.

Slot: replay-position
Initform

(quote (journal:read-position journal::*replay-streamlet*))

Readers

replay-failure-replay-position.

Writers

This slot is read-only.

Condition: replay-incomplete

Signaled if there are unprocessed non-log events in REPLAY-JOURNAL when WITH-JOURNALING finishes and the body of WITH-JOURNALING returned normally, which is to prevent this condition to cancel an ongoing unwinding. No restarts are provided.

Package

journal.

Source

journal.lisp.

Direct superclasses

replay-failure.

Condition: replay-name-mismatch

Signaled when the new event’s and REPLAY-EVENT’s EVENT-NAME are not EQUAL. The REPLAY-FORCE-INSERT, REPLAY-FORCE-UPGRADE restarts are provided.

Package

journal.

Source

journal.lisp.

Direct superclasses

replay-failure.

Condition: replay-outcome-mismatch

Signaled when the new event’s and REPLAY-EVENT’s EVENT-EXIT and/or EVENT-OUTCOME are not EQUAL. The REPLAY-FORCE-UPGRADE restart is provided.

Package

journal.

Source

journal.lisp.

Direct superclasses

replay-failure.

Condition: replay-unexpected-outcome

Signaled when the new event has an
UNEXPECTED-OUTCOME. Note that the REPLAY-EVENT always has an EXPECTED-OUTCOME due to the logic of RECORD-UNEXPECTED-OUTCOME. No restarts are provided.

Package

journal.

Source

journal.lisp.

Direct superclasses

replay-failure.

Condition: replay-version-downgrade

Signaled when the new event and the REPLAY-EVENT
have the same EVENT-NAME, but the new event has a lower version. The REPLAY-FORCE-UPGRADE restart is provided.

Package

journal.

Source

journal.lisp.

Direct superclasses

replay-failure.

Condition: streamlet-error

Like CL:STREAM-ERROR: failures regarding trying to
perform I/O on a closed STREAMLET or of the wrong DIRECTION. Actual I/O errors are _not_ encapsulated in STREAMLET-ERROR.

Package

journal.

Source

journal.lisp.

Direct superclasses

error.

Direct methods
Direct slots
Slot: streamlet
Initargs

:streamlet

Readers

streamlet.

Writers

This slot is read-only.

Slot: format-control
Initargs

:format-control

Readers

format-control.

Writers

This slot is read-only.

Slot: format-args
Initform

(quote nil)

Initargs

:format-args

Readers

format-args.

Writers

This slot is read-only.


6.1.8 Classes

Class: bundle

This is an abstract base class. Direct subclasses
are IN-MEMORY-BUNDLE and FILE-BUNDLE.

A BUNDLE consists of a sequence of journals which are all reruns of the same code, hopefully making more and more progress towards completion. These journals are @REPLAYs of the previous successful one, extending it with new events. Upon replay (see WITH-BUNDLE), the latest journal in the bundle in JOURNAL-STATE :COMPLETED plays the role of the replay journal, and a new journal is added to the bundle for recording. If the replay succeeds, this new journal eventually becomes :COMPLETED and takes over the role of the replay journal for future replays until another replay succeeds. When the bundle is created and it has no journals yet, the replay journal is an empty, completed one.

Package

journal.

Source

journal.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: journals
Initargs

:journals

Readers
Writers

(setf %journals).

Slot: max-n-failed

If MAX-N-FAILED is non-NIL, and the number of
journals of [JOURNAL-STATE][type] :FAILED in the bundle exceeds its value, then some journals (starting with the oldest) are deleted.

Initform

1

Initargs

:max-n-failed

Readers

max-n-failed.

Writers

(setf max-n-failed).

Slot: max-n-completed

If MAX-N-COMPLETED is non-NIL, and the number of
journals of [JOURNAL-STATE][type] :COMPLETED in the bundle exceeds its value, then some journals (starting with the oldest) are deleted.

Initform

1

Initargs

:max-n-completed

Readers

max-n-completed.

Writers

(setf max-n-completed).

Slot: lock
Initform

(bordeaux-threads:make-recursive-lock "a bundle-lock")

Slot: n-writers
Initform

0

Class: file-bundle

A FILE-BUNDLE is a BUNDLE that is built on FILE-JOURNALs. It provides easy replay-based persistence.

Package

journal.

Source

journal.lisp.

Direct superclasses

bundle.

Direct methods
Direct slots
Slot: directory

The directory where the files backing the FILE-JOURNALs in the FILE-BUNDLE are kept.

Package

common-lisp.

Initargs

:directory

Readers

directory-of.

Writers

This slot is read-only.

Slot: sync
Initargs

:sync

Class: file-journal

A FILE-JOURNAL is a journal whose contents and
JOURNAL-STATE are persisted in a file. This is the [JOURNAL][class] subclass with out-of-the-box persistence, but see @FILE-BUNDLES for a more full-featured solution for repeated @REPLAYs.

Since serialization in FILE-JOURNALs is built on top of Lisp READ and WRITE, everything that JOURNALED records in events (i.e. its NAME, ARGS arguments, but also the return VALUES of the block, or the value returned by CONDITION) must be @READABLE.

File journals are human-readable, and editable by hand with some care. When editing, the following needs to be remembered:

- The first character of the file represents its JOURNAL-STATE. It is a ‘#\Space‘ (for state :NEW, :REPLAYING, :MISMATCHED and :FAILED), or a ‘#\Newline‘ (for state :RECORDING, :LOGGING and :COMPLETED).

- If the journal has SYNC (see @SYNCHRONIZATION-STRATEGIES), then in between events, there may be ‘#\Del‘ (also called ‘#\Rubout‘) or ‘#\Ack‘ characters (CHAR-CODE 127 and 6). ‘#\Del‘ marks the end of the journal contents which may be read back: it’s kind of an uncommitted-transaction marker for the events that follow it. ‘#\Ack‘ characters, of which there may be many in the file, mark the sequence of events until the next marker of either kind as valid (or committed). ‘#\Ack‘ characters are ignored when reading the journal.

Thus, when editing a file, don’t change the first character and leave the ‘#\Del‘ character, if any, where it is. Also see @SYNCHRONIZATION-WITH-FILE-JOURNALS.

Package

journal.

Source

journal.lisp.

Direct superclasses

journal.

Direct methods
Direct slots
Slot: pathname

The pathname of the file backing the journal.

Package

common-lisp.

Initargs

:pathname

Readers

pathname-of.

Writers

This slot is read-only.

Class: in-memory-bundle

An IN-MEMORY-BUNDLE is a BUNDLE that is built on IN-MEMORY-JOURNALs. IN-MEMORY-BUNDLEs have limited utility as a persistence mechanism and are provided mainly for reasons of symmetry and for testing. See @SYNCHRONIZATION-WITH-IN-MEMORY-JOURNALS for an example of how to achieve persistence without bundles.

Package

journal.

Source

journal.lisp.

Direct superclasses

bundle.

Direct methods
Direct slots
Slot: sync
Initargs

:sync

Slot: sync-fn
Initargs

:sync-fn

Class: in-memory-journal

IN-MEMORY-JOURNALs are backed by a non-persistent,
Lisp array of events. Much quicker than FILE-JOURNALs, they are ideal for smallish journals persisted manually (see @SYNCHRONIZATION-WITH-IN-MEMORY-JOURNALS for an example).

They are also useful for writing tests based on what events were generated. They differ from FILE-JOURNALs in that events written to IN-MEMORY-JOURNALs are not serialized (and deserialized on replay) with the following consequences for the objects recorded by JOURNALED (i.e. its NAME, ARGS arguments, but also the return VALUES of the block, or the value returned by CONDITION):

- These objects need not be @READABLE.

- Their identity (‘EQ‘ness) is not lost.

- They must __must not be mutated__ in any way.

Package

journal.

Source

journal.lisp.

Direct superclasses

journal.

Direct methods
Direct slots
Slot: events

A sequence of events in the journal. Not to be mutated by client code.

Initargs

:events

Readers
Writers

This slot is read-only.

Slot: sync-fn
Initargs

:sync-fn

Slot: previous-sync-position

The length of JOURNAL-EVENTS at the time of the most recent invocation of SYNC-FN.

Initform

0

Readers

journal-previous-sync-position.

Writers

This slot is read-only.

Class: journal

A journal is, conceptually, a sequence of events.
JOURNAL is an abstract base class. In case of FILE-JOURNALs, the events are stored in a file, while for IN-MEMORY-JOURNALs, they are in a Lisp array. When a journal is opened, it is possible to perform I/O on it (see @STREAMLETS-REFERENCE), which is normally taken care of by WITH-JOURNALING. For this reason, the user’s involvement with journals normally only consists of creating and using them in WITH-JOURNALING.

Package

journal.

Source

journal.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: state

Return the state of JOURNAL, which is of type [JOURNAL-STATE][TYPE].

Type

journal:journal-state

Initargs

:state

Readers
Writers

(setf %state).

Slot: sync

The SYNC argument specified at instantiation. See @SYNCHRONIZATION-STRATEGIES.

Initargs

:sync

Readers

journal-sync.

Writers

This slot is read-only.

Slot: output-streamlet
Readers

%output-streamlet-of.

Writers

(setf %output-streamlet-of).

Slot: log-decorator

If non-NIL, a function to add @DECORATION to
LOG-EVENTs before they are written to a journal. The only allowed transformation is to _append_ a plist to the event, which is a plist itself. The keys can be anything.

Initargs

:log-decorator

Readers

journal-log-decorator.

Writers

(setf journal-log-decorator).

Slot: lock
Initform

(bordeaux-threads:make-recursive-lock "a journal-lock")

Slot: n-readers
Initform

0

Slot: n-writers
Initform

0

Slot: replay-mismatch

If JOURNAL-DIVERGENT-P, then this is a list of two
elements: the READ-POSITIONs in the RECORD-JOURNAL and REPLAY-JOURNAL of the first events that were different (ignoring LOG-EVENTs). It is NIL, otherwise.

Readers

journal-replay-mismatch.

Writers

This slot is read-only.

Class: pprint-journal

When an event is written to a PPRINT-JOURNAL it
writes that event to a stream in a customizable format. They are intended for producing prettier output for @LOGGING and @TRACING, but they do not support reads so they cannot be used as a REPLAY-JOURNAL, or in LIST-EVENTS, for example. On the other hand, events written to PPRINT-JOURNALs need not be @READABLE.

Package

journal.

Source

journal.lisp.

Direct superclasses

journal.

Direct methods
Direct slots
Slot: stream

The stream where events are dumped. May be set any time to another STREAM.

Package

common-lisp.

Type

stream

Initform

*standard-output*

Initargs

:stream

Readers

pprint-journal-stream.

Writers

(setf pprint-journal-stream).

Slot: pretty

Whether to use PPRINT-JOURNAL-PRETTIFIER or write events in as the property lists they are. A @BOOLEAN-VALUED-SYMBOL.

Initform

t

Initargs

:pretty

Readers

pprint-journal-pretty.

Writers

(setf pprint-journal-pretty).

Slot: prettifier

A function like PRETTIFY-EVENT that writes its an
event to a stream. Only used when PPRINT-JOURNAL-PRETTY, this is the output format customization knob. Also see @DECORATIONs.

Initform

(quote journal:prettify-event)

Initargs

:prettifier

Readers

pprint-journal-prettifier.

Writers

(setf pprint-journal-prettifier).

Class: streamlet

A STREAMLET is a handle to perform I/O on a
JOURNAL. The high-level stuff (WITH-JOURNALING, JOURNALED, etc) is built on top of streamlets.

Package

journal.

Source

journal.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: journal

The JOURNAL that was passed to OPEN-STREAMLET.
This is the journal [STREAMLET][dislocated] operates on.

Initargs

:journal

Readers

journal.

Writers

This slot is read-only.

Slot: direction
Type

(or journal::direction null)

Initargs

:direction

Readers

%direction.

Writers

(setf %direction).

Slot: in-depth
Initform

0

Readers

%in-depth.

Writers

(setf %in-depth).

Slot: sync
Initform

t

Initargs

:sync

Slot: %trusted
Slot: completed-on-abort-deferred-p

6.1.9 Types

Type: event ()

An event is either an IN-EVENT, an OUT-EVENT or a LEAF-EVENT.

Package

journal.

Source

journal.lisp.

Type: event-exit ()

One of :VALUES, :CONDITION, :ERROR and :NLX. Indicates whether a journaled @BLOCK:

- returned normally (:VALUES, see VALUES-OUTCOME),

- unwound on an expected condition (:CONDITION, see CONDITION-OUTCOME),

- unwound on an unexpected condition (:ERROR, see ERROR-OUTCOME),

- unwound by performing a @NON-LOCAL-EXIT of some other kind such as a throw (:NLX, see NLX-OUTCOME).

The first two are EXPECTED-OUTCOMEs, while the latter two are UNEXPECTED-OUTCOMEs.

Package

journal.

Source

journal.lisp.

Type: event-version ()

An event’s version is either NIL, a positive fixnum, or :INFINITY, which correspond to LOG-EVENTs, VERSIONED-EVENTs, and EXTERNAL-EVENTs, respectively, and have an increasingly strict behaviour with regards to @REPLAY. All EVENTs have versions. The versions of the in- and out-events belonging to the same @FRAME are the same.

Package

journal.

Source

journal.lisp.

Type: external-event ()

Events with [EVENT-VERSION][type] :INFINITY are called external events. They are like VERSIONED-EVENTs whose version was bumped all the way to infinity, which rules out easy, non-matching upgrades. Also, they are never inserted to the record without a matching replay
event (see @THE-REPLAY-STRATEGY).

In return for these restrictions, external events can be replayed without running the corresponding @BLOCK (see @REPLAYING-THE-OUTCOME). This allows their out-event variety, called DATA-EVENTs, to be non-deterministic. Data events play a crucial role in @PERSISTENCE.

If an EXTERNAL-EVENT has an UNEXPECTED-OUTCOME, RECORD-UNEXPECTED-OUTCOME is signalled.

Package

journal.

Source

journal.lisp.

Type: in-event ()

IN-EVENTs are triggered upon entering the dynamic extent of a JOURNALED @BLOCK. IN-EVENTs have EVENT-NAME, [EVENT-VERSION][function], and EVENT-ARGS. See @IN-EVENTS for a more introductory treatment.

Package

journal.

Source

journal.lisp.

Type: journal-state ()

JOURNAL’s state, with respect to replay, is updated during
WITH-JOURNALING. This possible states are:

- __:NEW__: This journal was just created, but never recorded to.

- __:REPLAYING__: Replaying events has started, some events may have
been replayed successfuly, but there are more, non-log events to replay.

- __:MISMATCHED__: There was a REPLAY-FAILURE. In this state, VERSIONED-EVENTs generated are downgraded to LOG-EVENTs, EXTERNAL-EVENTs and INVOKED trigger a DATA-EVENT-LOSSAGE.

- __:RECORDING__: All events from the replay journal were
successfully replayed and now new events are being recorded
without being matched to the replay journal.

- __:LOGGING__: There was a RECORD-UNEXPECTED-OUTCOME. In this
state, VERSIONED-EVENTs generated are downgraded to LOG-EVENTs, EXTERNAL-EVENTs and INVOKED trigger a DATA-EVENT-LOSSAGE.

- __:FAILED__: The journal is to be discarded. It encountered a JOURNALING-FAILURE or a REPLAY-FAILURE without completing the
replay and reaching :RECORDING.

- __:COMPLETED__: All events were successfully replayed and WITH-JOURNALING finished or a JOURNALING-FAILURE occurred while :RECORDING or :LOGGING.

The state transitions are:

:NEW -> :REPLAYING (on entering WITH-JOURNALING) :REPLAYING -> :MISMATCHED (on REPLAY-FAILURE)
:REPLAYING -> :FAILED (on REPLAY-INCOMPLETE)
:REPLAYING -> :FAILED (on JOURNALING-FAILURE)
:REPLAYING -> :RECORDING (on successfully replaying all events) :MISMATCHED -> :FAILED (on leaving WITH-JOURNALING) :RECORDING -> :LOGGING (on RECORD-UNEXPECTED-OUTCOME) :RECORDING/:LOGGING -> :COMPLETED (on leaving WITH-JOURNALING) :RECORDING/:LOGGING -> :COMPLETED (on JOURNALING-FAILURE)

:NEW is the starting state. It is a JOURNAL-ERROR to attempt to
write to journals in :COMPLETED. Note that once in :RECORDING, the
only possible terminal state is :COMPLETED.

Package

journal.

Source

journal.lisp.

Type: leaf-event ()

Leaf events are triggered by LOGGED. Unlike IN-EVENTs and OUT-EVENTs, which represent a @FRAME, leaf events stand alone and thus cannot have children. They are also the poorest of their kind: they only have an EVENT-NAME. Their VERSION is always NIL, which makes them LOG-EVENTs.

Package

journal.

Source

journal.lisp.

Type: log-event ()

Events with [EVENT-VERSION][type] NIL called log events. During @REPLAY, they are never matched to events from the replay journal, and log events in the replay do not affect events being recorded either. These properties allow log events to be recorded in arbitrary journals with JOURNALED’s LOG-RECORD argument. The convenience macro FRAMED is creating frames of log-events, while the LOGGED generates a log-event that’s a LEAF-EVENT.

Package

journal.

Source

journal.lisp.

Type: out-event ()

OUT-EVENTs are triggered upon leaving the dynamic extent of the JOURNALED @BLOCK. OUT-EVENTs have EVENT-NAME, [EVENT-VERSION][function], [EVENT-EXIT][function] and EVENT-OUTCOME. See @OUT-EVENTS for a more introductory treatment.

Package

journal.

Source

journal.lisp.

Type: versioned-event ()

Events with a positive integer [EVENT-VERSION][type] are called versioned events. In @REPLAY, they undergo consistency checks unlike LOG-EVENTs, but the rules for them are less strict than for EXTERNAL-EVENTs. In particular, higher versions are always considered compatible with lower versions, they become an _upgrade_ in terms of the @THE-REPLAY-STRATEGY, and versioned events can be inserted into the record without a corresponding REPLAY-EVENT with JOURNALED’s INSERTABLE.

If a VERSIONED-EVENT has an UNEXPECTED-OUTCOME, RECORD-UNEXPECTED-OUTCOME is signalled.

Package

journal.

Source

journal.lisp.


6.2 Internals


6.2.1 Special variables

Special Variable: *file-bundle-lock*
Package

journal.

Source

journal.lisp.

Special Variable: *file-journal-lock*
Package

journal.

Source

journal.lisp.

Special Variable: *invoked-event-name-to-function-name*
Package

journal.

Source

journal.lisp.

Special Variable: *journaling-failure*
Package

journal.

Source

journal.lisp.

Special Variable: *local-invoked-event-name-to-function*
Package

journal.

Source

journal.lisp.

Special Variable: *next-write-event-fn*
Package

journal.

Source

journal.lisp.

Special Variable: *no-replay-outcome-names*
Package

journal.

Source

journal.lisp.

Special Variable: *record-journal-state*
Package

journal.

Source

journal.lisp.

Special Variable: *record-streamlet*
Package

journal.

Source

journal.lisp.

Special Variable: *replay-eoj-error-p*
Package

journal.

Source

journal.lisp.

Special Variable: *replay-event-mapper*
Package

journal.

Source

journal.lisp.

Special Variable: *replay-failure*
Package

journal.

Source

journal.lisp.

Special Variable: *replay-filter-base-depth*
Package

journal.

Source

journal.lisp.

Special Variable: *replay-streamlet*
Package

journal.

Source

journal.lisp.

Special Variable: *skip-events*
Package

journal.

Source

journal.lisp.

Special Variable: *skip-patterns*
Package

journal.

Source

journal.lisp.

Special Variable: *skipped-events-until*
Package

journal.

Source

journal.lisp.

Special Variable: *suppress-trace*
Package

journal.

Source

journal.lisp.

Special Variable: *testing*
Package

journal.

Source

journal.lisp.

Special Variable: *traced-functions*
Package

journal.

Source

journal.lisp.

Special Variable: *truename-to-file-bundle*
Package

journal.

Source

journal.lisp.

Special Variable: *truename-to-file-journal*
Package

journal.

Source

journal.lisp.

Special Variable: *with-interrupts-available*
Package

journal.

Source

interrupt.lisp.

Special Variable: *with-journaling-failure-on-nlx-body-completed*
Package

journal.

Source

journal.lisp.

Special Variable: *without-interrupts-available*
Package

journal.

Source

interrupt.lisp.

Special Variable: @async-unwind
Package

journal.

Source

journal.lisp.

Special Variable: @boolean-valued-symbol
Package

journal.

Source

journal.lisp.

Special Variable: @non-local-exit
Package

journal.

Source

journal.lisp.

Special Variable: @readable
Package

journal.

Source

journal.lisp.


6.2.2 Macros

Macro: async-signal-safe (&body body)
Package

journal.

Source

interrupt.lisp.

Macro: jtrace-1 (name)
Package

journal.

Source

journal.lisp.

Macro: nlx-protect ((&key on-return on-nlx) &body body)
Package

journal.

Source

journal.lisp.

Macro: unwind-protect* (protected &body cleanup)
Package

journal.

Source

interrupt.lisp.

Macro: with-bundle-locked ((bundle) &body body)
Package

journal.

Source

journal.lisp.

Macro: with-interrupts (&body body)
Package

journal.

Source

interrupt.lisp.

Macro: with-journal-locked ((journal) &body body)
Package

journal.

Source

journal.lisp.

Macro: with-journaling-failure-on-nlx (&body body)
Package

journal.

Source

journal.lisp.

Macro: with-nlx-cancelled ((datum &rest arguments) &body body)
Package

journal.

Source

journal.lisp.

Macro: with-standard-io-syntax* (&body body)
Package

journal.

Source

journal.lisp.

Macro: without-interrupts (&body body)
Package

journal.

Source

interrupt.lisp.


6.2.3 Ordinary functions

Function: %commit-file-journal-events (streamlet)
Package

journal.

Source

journal.lisp.

Function: %fsync (fd)
Package

journal.

Source

journal.lisp.

Function: %print-events (events stream prettifier)
Package

journal.

Source

journal.lisp.

Function: %print-journal-object-slots (journal stream)
Package

journal.

Source

journal.lisp.

Function: %read-event-from-stream (stream eof)
Package

journal.

Source

journal.lisp.

Function: %read-event-from-streamlet (streamlet eoj-error-p)
Package

journal.

Source

journal.lisp.

Function: %set-file-journal-completed-on-abort (streamlet)
Package

journal.

Source

journal.lisp.

Function: %set-in-memory-streamlet-read-position (streamlet read-position)
Package

journal.

Source

journal.lisp.

Function: %truename (pathname)
Package

journal.

Source

journal.lisp.

Function: ->recording-p (record-streamlet replay-streamlet)
Package

journal.

Source

journal.lisp.

Function: apply-key (key-fn obj)
Package

journal.

Source

journal.lisp.

Function: bundle-file-version (pathname)
Package

journal.

Source

journal.lisp.

Function: bundle-record-journal (bundle)
Package

journal.

Source

journal.lisp.

Function: bundle-replay-journal (bundle)
Package

journal.

Source

journal.lisp.

Function: call-journaled (function record-streamlet log-record name version args values-key condition-key replay-streamlet insertable replay-values replay-condition replay-eoj-error-p)
Package

journal.

Source

journal.lisp.

Function: call-with-journaling (fn record replay replay-eoj-error-p)
Package

journal.

Source

journal.lisp.

Function: call-with-journaling-failure-on-nlx (fn)
Package

journal.

Source

journal.lisp.

Function: call-with-open-journal (journal direction fn)
Package

journal.

Source

journal.lisp.

Function: check-args (in-event replayed-in-event)
Package

journal.

Source

journal.lisp.

Function: check-concurrent-write-access (journal)
Package

journal.

Source

journal.lisp.

Function: check-file-bundle-options (bundle max-n-failed max-n-completed sync)
Package

journal.

Source

journal.lisp.

Function: check-file-journal-options (journal sync)
Package

journal.

Source

journal.lisp.

Function: check-input-streamlet-p (streamlet)
Package

journal.

Source

journal.lisp.

Function: check-journal-state (name journal expected-state)
Package

journal.

Source

journal.lisp.

Function: check-okay-for-input (streamlet)
Package

journal.

Source

journal.lisp.

Function: check-okay-for-output (streamlet)
Package

journal.

Source

journal.lisp.

Function: check-open-streamlet-p (streamlet)
Package

journal.

Source

journal.lisp.

Function: check-outcome (out-event replayed-out-event)
Package

journal.

Source

journal.lisp.

Function: check-output-streamlet-p (streamlet)
Package

journal.

Source

journal.lisp.

Function: check-sync-value (sync)
Package

journal.

Source

journal.lisp.

Function: check-within-with-journaling-failure-on-nlx ()
Package

journal.

Source

journal.lisp.

Function: cleanup (obj)
Package

journal.

Source

journal.lisp.

Function: condition-event-p (out-event)
Package

journal.

Source

journal.lisp.

Function: condition-to-string (c)
Package

journal.

Source

journal.lisp.

Function: delete-file-journal (journal)
Package

journal.

Source

journal.lisp.

Function: eat-event (event streamlet)
Package

journal.

Source

journal.lisp.

Function: eat-events (pred streamlet base-depth in-or-leaf-event-p)
Package

journal.

Source

journal.lisp.

Function: eat-full-frames-of-events (pred streamlet base-depth)
Package

journal.

Source

journal.lisp.

Function: echo-current-frame (input-streamlet output-streamlet)
Package

journal.

Source

journal.lisp.

Function: end-of-frame-position (streamlet &key depth)
Package

journal.

Source

journal.lisp.

Function: ensure-txn (streamlet stream)
Package

journal.

Source

journal.lisp.

Function: equivalent-states-p (state-1 state-2)
Package

journal.

Source

journal.lisp.

Function: error-event-p (out-event)
Package

journal.

Source

journal.lisp.

Function: every-event-in-frame (pred streamlet)
Package

journal.

Source

journal.lisp.

Function: fail-with-journaling-failure (record-streamlet condition)
Package

journal.

Source

journal.lisp.

Function: finalize-journal-state (record-streamlet abort)
Package

journal.

Source

journal.lisp.

Function: flet-invoked/1 (definition)
Package

journal.

Source

journal.lisp.

Function: fsync (stream)
Package

journal.

Source

journal.lisp.

Function: fsync-directory (pathname)
Package

journal.

Source

journal.lisp.

Function: getf* (list indicator &optional default)
Package

journal.

Source

journal.lisp.

Function: handle-in-event (record-streamlet log-record name version args replay-streamlet insertable replay-values replay-condition replay-eoj-error-p)
Package

journal.

Source

journal.lisp.

Function: handle-leaf-event (record-streamlet log-record name)
Package

journal.

Source

journal.lisp.

Function: handle-out-event (record-streamlet log-record out-event in-event-strategy insertable replay-streamlet replay-eoj-error-p)
Package

journal.

Source

journal.lisp.

Function: in-with-journaling-p ()
Package

journal.

Source

journal.lisp.

Function: initialize-journal-state (record-streamlet replay-streamlet)
Package

journal.

Source

journal.lisp.

Function: input-direction-p (direction)
Package

journal.

Source

journal.lisp.

Function: invalidate-journal (journal)
Package

journal.

Source

journal.lisp.

Function: invoked-function (event-name)
Package

journal.

Source

journal.lisp.

Function: invoked/1 (function-name args name version insertable body)
Package

journal.

Source

journal.lisp.

Function: journal-output-streamlet (journal)
Package

journal.

Source

journal.lisp.

Function: jtracedp (name)
Package

journal.

Source

journal.lisp.

Function: juntrace-1 (name)
Package

journal.

Source

journal.lisp.

Function: list-journal-files-in-directory (directory)
Package

journal.

Source

journal.lisp.

Function: list-traced-functions ()
Package

journal.

Source

journal.lisp.

Function: make-file-journals-for-bundle (directory sync)
Package

journal.

Source

journal.lisp.

Function: make-in-event* (replay-event name version args)
Package

journal.

Source

journal.lisp.

Function: make-out-event* (replay-event name version exit outcome)
Package

journal.

Source

journal.lisp.

Function: match-version (event replay-event)
Package

journal.

Source

journal.lisp.

Function: maybe-downgrade-version (version name record-streamlet)
Package

journal.

Source

journal.lisp.

Function: maybe-handle-invoked (in-event)
Package

journal.

Source

journal.lisp.

Function: maybe-mark-record-as-divergent (version &optional replay-read-position)
Package

journal.

Source

journal.lisp.

Function: maybe-print-resignalling-message (condition stream)
Package

journal.

Source

journal.lisp.

Function: maybe-replay-outcome (record-streamlet replay-streamlet replayed-out-event replay-values replay-condition)
Package

journal.

Source

journal.lisp.

Function: maybe-resignal-journaling-failure ()
Package

journal.

Source

journal.lisp.

Function: maybe-sync-after-in-event (in-event record-streamlet)
Package

journal.

Source

journal.lisp.

Function: maybe-sync-after-out-event (out-event record-streamlet)
Package

journal.

Source

journal.lisp.

Function: nlx-event-p (out-event)
Package

journal.

Source

journal.lisp.

Function: nlx-outcome-and-maybe->logging (version record-streamlet condition condition-key)
Package

journal.

Source

journal.lisp.

Function: output-direction-p (direction)
Package

journal.

Source

journal.lisp.

Function: pattern-to-pred (pattern)
Package

journal.

Source

journal.lisp.

Function: patterns-to-disjunction (patterns)
Package

journal.

Source

journal.lisp.

Function: pax-pages ()
Package

journal.

Source

doc.lisp.

Function: pax-sections ()
Package

journal.

Source

doc.lisp.

Function: peek-at-out-event (streamlet)
Package

journal.

Source

journal.lisp.

Function: peek-mapped-replay-event (replay-streamlet)
Package

journal.

Source

journal.lisp.

Function: position-to-read (streamlet)
Package

journal.

Source

journal.lisp.

Function: position-to-write (streamlet)
Package

journal.

Source

journal.lisp.

Function: print-record-closed (stream)
Package

journal.

Source

journal.lisp.

Function: read-file-journal-state (pathname)
Package

journal.

Source

journal.lisp.

Function: read-mapped-replay-event (replay-streamlet)
Package

journal.

Source

journal.lisp.

Function: reap-identical-or-non-divergent-journals (bundle)
Package

journal.

Source

journal.lisp.

Function: reap-journals-in-bundle (bundle)
Package

journal.

Source

journal.lisp.

Function: replay-filter-at-base-depth-p ()
Package

journal.

Source

journal.lisp.

Function: replay-strategy (event insertable record-streamlet replay-streamlet replay-eoj-error-p)
Package

journal.

Source

journal.lisp.

Function: replaying-outcome-allowed-p (in-event)
Package

journal.

Source

journal.lisp.

Function: resolve-log-record (log-record)
Package

journal.

Source

journal.lisp.

Function: route-event (event record-streamlet log-record)
Package

journal.

Source

journal.lisp.

Function: set-file-journal-completed-on-abort (streamlet)
Package

journal.

Source

journal.lisp.

Function: set-journal-state (streamlet state)
Package

journal.

Source

journal.lisp.

Function: skip-events (replay-streamlet in-or-leaf-event-p)
Package

journal.

Source

journal.lisp.

Function: skip-events-and-maybe->recording (record-streamlet replay-streamlet &optional in-or-leaf-event-p)
Package

journal.

Source

journal.lisp.

Function: skip-log-events (streamlet)
Package

journal.

Source

journal.lisp.

Function: stream-fd (stream)
Package

journal.

Source

journal.lisp.

Function: swank-toggle-jtrace (spec-string)
Package

journal.

Source

journal.lisp.

Function: turn-off-with-journaling-failure-on-nlx ()
Package

journal.

Source

journal.lisp.

Function: untrace-all ()
Package

journal.

Source

journal.lisp.

Function: values-event-p (out-event)
Package

journal.

Source

journal.lisp.

Function: version< (version-1 version-2)
Package

journal.

Source

journal.lisp.

Function: version= (version-1 version-2)
Package

journal.

Source

journal.lisp.

Function: write-file-journal-state (stream state)
Package

journal.

Source

journal.lisp.


6.2.4 Generic functions

Generic Reader: %direction (object)
Package

journal.

Methods
Reader Method: %direction ((streamlet streamlet))

automatically generated reader method

Source

journal.lisp.

Target Slot

direction.

Generic Writer: (setf %direction) (object)
Package

journal.

Methods
Writer Method: (setf %direction) ((streamlet streamlet))

automatically generated writer method

Source

journal.lisp.

Target Slot

direction.

Generic Reader: %in-depth (object)
Package

journal.

Methods
Reader Method: %in-depth ((streamlet streamlet))

automatically generated reader method

Source

journal.lisp.

Target Slot

in-depth.

Generic Writer: (setf %in-depth) (object)
Package

journal.

Methods
Writer Method: (setf %in-depth) ((streamlet streamlet))

automatically generated writer method

Source

journal.lisp.

Target Slot

in-depth.

Generic Reader: %journals (object)
Package

journal.

Methods
Reader Method: %journals ((bundle bundle))

automatically generated reader method

Source

journal.lisp.

Target Slot

journals.

Generic Writer: (setf %journals) (object)
Package

journal.

Methods
Writer Method: (setf %journals) ((bundle bundle))

automatically generated writer method

Source

journal.lisp.

Target Slot

journals.

Generic Reader: %out-depth (object)
Package

journal.

Methods
Reader Method: %out-depth ((file-streamlet file-streamlet))

automatically generated reader method

Source

journal.lisp.

Target Slot

out-depth.

Reader Method: %out-depth ((pprint-streamlet pprint-streamlet))

automatically generated reader method

Source

journal.lisp.

Target Slot

out-depth.

Generic Writer: (setf %out-depth) (object)
Package

journal.

Methods
Writer Method: (setf %out-depth) ((file-streamlet file-streamlet))

automatically generated writer method

Source

journal.lisp.

Target Slot

out-depth.

Writer Method: (setf %out-depth) ((pprint-streamlet pprint-streamlet))

automatically generated writer method

Source

journal.lisp.

Target Slot

out-depth.

Generic Reader: %output-streamlet-of (object)
Package

journal.

Methods
Reader Method: %output-streamlet-of ((journal journal))

automatically generated reader method

Source

journal.lisp.

Target Slot

output-streamlet.

Generic Writer: (setf %output-streamlet-of) (object)
Package

journal.

Methods
Writer Method: (setf %output-streamlet-of) ((journal journal))

automatically generated writer method

Source

journal.lisp.

Target Slot

output-streamlet.

Generic Reader: %state (object)
Generic Writer: (setf %state) (object)
Package

journal.

Methods
Reader Method: %state ((journal journal))
Writer Method: (setf %state) ((journal journal))

Return the state of JOURNAL, which is of type [JOURNAL-STATE][TYPE].

Source

journal.lisp.

Target Slot

state.

Generic Reader: %stream (object)
Package

journal.

Methods
Reader Method: %stream ((file-streamlet file-streamlet))

automatically generated reader method

Source

journal.lisp.

Target Slot

stream.

Generic Writer: (setf %stream) (object)
Package

journal.

Methods
Writer Method: (setf %stream) ((file-streamlet file-streamlet))

automatically generated writer method

Source

journal.lisp.

Target Slot

stream.

Generic Function: delete-journal-from-bundle (bundle journal)
Package

journal.

Source

journal.lisp.

Methods
Method: delete-journal-from-bundle ((bundle file-bundle) journal)
Method: delete-journal-from-bundle ((bundle in-memory-bundle) journal)
Method: delete-journal-from-bundle :around (bundle journal)
Generic Reader: events (object)
Package

journal.

Methods
Reader Method: events ((in-memory-journal in-memory-journal))

A sequence of events in the journal. Not to be mutated by client code.

Source

journal.lisp.

Target Slot

events.

Generic Reader: format-args (condition)
Package

journal.

Methods
Reader Method: format-args ((condition journal-error))
Source

journal.lisp.

Target Slot

format-args.

Reader Method: format-args ((condition streamlet-error))
Source

journal.lisp.

Target Slot

format-args.

Generic Reader: format-control (condition)
Package

journal.

Methods
Reader Method: format-control ((condition journal-error))
Source

journal.lisp.

Target Slot

format-control.

Reader Method: format-control ((condition streamlet-error))
Source

journal.lisp.

Target Slot

format-control.

Generic Reader: journaling-failure-n-resignallings (condition)
Generic Writer: (setf journaling-failure-n-resignallings) (condition)
Package

journal.

Methods
Reader Method: journaling-failure-n-resignallings ((condition journaling-failure))
Writer Method: (setf journaling-failure-n-resignallings) ((condition journaling-failure))
Source

journal.lisp.

Target Slot

n-resignallings.

Generic Reader: journals (object)
Package

journal.

Methods
Reader Method: journals ((bundle bundle))

automatically generated reader method

Source

journal.lisp.

Target Slot

journals.

Generic Function: make-record-journal-in-bundle (bundle)
Package

journal.

Source

journal.lisp.

Methods
Method: make-record-journal-in-bundle ((bundle file-bundle))
Method: make-record-journal-in-bundle ((bundle in-memory-bundle))
Generic Reader: new-event (condition)
Package

journal.

Methods
Reader Method: new-event ((condition record-unexpected-outcome))
Source

journal.lisp.

Target Slot

new-event.

Generic Reader: read-file-position (object)
Package

journal.

Methods
Reader Method: read-file-position ((file-streamlet file-streamlet))

automatically generated reader method

Source

journal.lisp.

Target Slot

read-file-position.

Generic Writer: (setf read-file-position) (object)
Package

journal.

Methods
Writer Method: (setf read-file-position) ((file-streamlet file-streamlet))

automatically generated writer method

Source

journal.lisp.

Target Slot

read-file-position.

Generic Reader: replay-failure-record-journal (condition)
Package

journal.

Methods
Reader Method: replay-failure-record-journal ((condition replay-failure))
Source

journal.lisp.

Target Slot

record-journal.

Generic Reader: replay-failure-replay-position (condition)
Package

journal.

Methods
Reader Method: replay-failure-replay-position ((condition replay-failure))
Source

journal.lisp.

Target Slot

replay-position.

Generic Reader: wrote-last-p (object)
Package

journal.

Methods
Reader Method: wrote-last-p ((file-streamlet file-streamlet))

automatically generated reader method

Source

journal.lisp.

Target Slot

wrote-last-p.

Generic Writer: (setf wrote-last-p) (object)
Package

journal.

Methods
Writer Method: (setf wrote-last-p) ((file-streamlet file-streamlet))

automatically generated writer method

Source

journal.lisp.

Target Slot

wrote-last-p.


6.2.5 Classes

Class: file-streamlet
Package

journal.

Source

journal.lisp.

Direct superclasses

streamlet.

Direct methods
Direct slots
Slot: stream
Package

common-lisp.

Type

(or stream null)

Initargs

:stream

Readers

%stream.

Writers

(setf %stream).

Slot: wrote-last-p
Readers

wrote-last-p.

Writers

(setf wrote-last-p).

Slot: read-file-position
Readers

read-file-position.

Writers

(setf read-file-position).

Slot: peeked
Slot: out-depth
Initform

0

Readers

%out-depth.

Writers

(setf %out-depth).

Slot: txn-start-file-position
Slot: set-complete-on-abort-on-commit-p
Class: in-memory-streamlet

A streamlet for performing IO on IN-MEMORY-JOURNALs.

Package

journal.

Source

journal.lisp.

Direct superclasses

streamlet.

Direct methods
Direct slots
Slot: %read-position
Initform

0

Readers

read-position.

Writers

This slot is read-only.

Slot: peeked
Class: pprint-streamlet
Package

journal.

Source

journal.lisp.

Direct superclasses

streamlet.

Direct methods
Direct slots
Slot: out-depth
Initform

0

Readers

%out-depth.

Writers

(setf %out-depth).


6.2.6 Types

Type: direction ()
Package

journal.

Source

journal.lisp.

Type: safe-condition ()
Package

journal.

Source

journal.lisp.

Type: unsafe-condition ()
Package

journal.

Source

journal.lisp.


Appendix A Indexes


A.1 Concepts


A.2 Functions

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

%
%commit-file-journal-events: Private ordinary functions
%direction: Private generic functions
%direction: Private generic functions
%fsync: Private ordinary functions
%in-depth: Private generic functions
%in-depth: Private generic functions
%journals: Private generic functions
%journals: Private generic functions
%out-depth: Private generic functions
%out-depth: Private generic functions
%out-depth: Private generic functions
%output-streamlet-of: Private generic functions
%output-streamlet-of: Private generic functions
%print-events: Private ordinary functions
%print-journal-object-slots: Private ordinary functions
%read-event-from-stream: Private ordinary functions
%read-event-from-streamlet: Private ordinary functions
%set-file-journal-completed-on-abort: Private ordinary functions
%set-in-memory-streamlet-read-position: Private ordinary functions
%state: Private generic functions
%state: Private generic functions
%stream: Private generic functions
%stream: Private generic functions
%truename: Private ordinary functions

(
(setf %direction): Private generic functions
(setf %direction): Private generic functions
(setf %in-depth): Private generic functions
(setf %in-depth): Private generic functions
(setf %journals): Private generic functions
(setf %journals): Private generic functions
(setf %out-depth): Private generic functions
(setf %out-depth): Private generic functions
(setf %out-depth): Private generic functions
(setf %output-streamlet-of): Private generic functions
(setf %output-streamlet-of): Private generic functions
(setf %state): Private generic functions
(setf %state): Private generic functions
(setf %stream): Private generic functions
(setf %stream): Private generic functions
(setf journal-log-decorator): Public generic functions
(setf journal-log-decorator): Public generic functions
(setf journaling-failure-n-resignallings): Private generic functions
(setf journaling-failure-n-resignallings): Private generic functions
(setf max-n-completed): Public generic functions
(setf max-n-completed): Public generic functions
(setf max-n-failed): Public generic functions
(setf max-n-failed): Public generic functions
(setf pprint-journal-prettifier): Public generic functions
(setf pprint-journal-prettifier): Public generic functions
(setf pprint-journal-pretty): Public generic functions
(setf pprint-journal-pretty): Public generic functions
(setf pprint-journal-stream): Public generic functions
(setf pprint-journal-stream): Public generic functions
(setf read-file-position): Private generic functions
(setf read-file-position): Private generic functions
(setf read-position): Public setf expanders
(setf wrote-last-p): Private generic functions
(setf wrote-last-p): Private generic functions

-
->recording-p: Private ordinary functions

A
apply-key: Private ordinary functions
async-signal-safe: Private macros

B
bundle-file-version: Private ordinary functions
bundle-record-journal: Private ordinary functions
bundle-replay-journal: Private ordinary functions

C
call-journaled: Private ordinary functions
call-with-journaling: Private ordinary functions
call-with-journaling-failure-on-nlx: Private ordinary functions
call-with-open-journal: Private ordinary functions
check-args: Private ordinary functions
check-concurrent-write-access: Private ordinary functions
check-file-bundle-options: Private ordinary functions
check-file-journal-options: Private ordinary functions
check-input-streamlet-p: Private ordinary functions
check-journal-state: Private ordinary functions
check-okay-for-input: Private ordinary functions
check-okay-for-output: Private ordinary functions
check-open-streamlet-p: Private ordinary functions
check-outcome: Private ordinary functions
check-output-streamlet-p: Private ordinary functions
check-sync-value: Private ordinary functions
check-within-with-journaling-failure-on-nlx: Private ordinary functions
checked: Public macros
cleanup: Private ordinary functions
close-streamlet: Public generic functions
close-streamlet: Public generic functions
close-streamlet: Public generic functions
close-streamlet: Public generic functions
close-streamlet: Public generic functions
condition-event-p: Private ordinary functions
condition-to-string: Private ordinary functions

D
define-file-bundle-test: Public macros
define-invoked: Public macros
delete-file-bundle: Public ordinary functions
delete-file-journal: Private ordinary functions
delete-journal-from-bundle: Private generic functions
delete-journal-from-bundle: Private generic functions
delete-journal-from-bundle: Private generic functions
delete-journal-from-bundle: Private generic functions
directory-of: Public generic functions
directory-of: Public generic functions

E
eat-event: Private ordinary functions
eat-events: Private ordinary functions
eat-full-frames-of-events: Private ordinary functions
echo-current-frame: Private ordinary functions
end-of-frame-position: Private ordinary functions
ensure-txn: Private ordinary functions
equivalent-replay-journals-p: Public generic functions
equivalent-replay-journals-p: Public generic functions
equivalent-replay-journals-p: Public generic functions
equivalent-states-p: Private ordinary functions
error-event-p: Private ordinary functions
event-args: Public ordinary functions
event-exit: Public ordinary functions
event-name: Public ordinary functions
event-outcome: Public ordinary functions
event-version: Public ordinary functions
event=: Public ordinary functions
events: Private generic functions
events: Private generic functions
events-to-frames: Public ordinary functions
every-event-in-frame: Private ordinary functions
expected-outcome-p: Public ordinary functions
expected-type: Public ordinary functions
external-event-p: Public ordinary functions

F
fail-with-journaling-failure: Private ordinary functions
finalize-journal-state: Private ordinary functions
flet-invoked: Public macros
flet-invoked/1: Private ordinary functions
format-args: Private generic functions
format-args: Private generic functions
format-args: Private generic functions
format-control: Private generic functions
format-control: Private generic functions
format-control: Private generic functions
framed: Public macros
fsync: Private ordinary functions
fsync-directory: Private ordinary functions
Function, %commit-file-journal-events: Private ordinary functions
Function, %fsync: Private ordinary functions
Function, %print-events: Private ordinary functions
Function, %print-journal-object-slots: Private ordinary functions
Function, %read-event-from-stream: Private ordinary functions
Function, %read-event-from-streamlet: Private ordinary functions
Function, %set-file-journal-completed-on-abort: Private ordinary functions
Function, %set-in-memory-streamlet-read-position: Private ordinary functions
Function, %truename: Private ordinary functions
Function, ->recording-p: Private ordinary functions
Function, apply-key: Private ordinary functions
Function, bundle-file-version: Private ordinary functions
Function, bundle-record-journal: Private ordinary functions
Function, bundle-replay-journal: Private ordinary functions
Function, call-journaled: Private ordinary functions
Function, call-with-journaling: Private ordinary functions
Function, call-with-journaling-failure-on-nlx: Private ordinary functions
Function, call-with-open-journal: Private ordinary functions
Function, check-args: Private ordinary functions
Function, check-concurrent-write-access: Private ordinary functions
Function, check-file-bundle-options: Private ordinary functions
Function, check-file-journal-options: Private ordinary functions
Function, check-input-streamlet-p: Private ordinary functions
Function, check-journal-state: Private ordinary functions
Function, check-okay-for-input: Private ordinary functions
Function, check-okay-for-output: Private ordinary functions
Function, check-open-streamlet-p: Private ordinary functions
Function, check-outcome: Private ordinary functions
Function, check-output-streamlet-p: Private ordinary functions
Function, check-sync-value: Private ordinary functions
Function, check-within-with-journaling-failure-on-nlx: Private ordinary functions
Function, cleanup: Private ordinary functions
Function, condition-event-p: Private ordinary functions
Function, condition-to-string: Private ordinary functions
Function, delete-file-bundle: Public ordinary functions
Function, delete-file-journal: Private ordinary functions
Function, eat-event: Private ordinary functions
Function, eat-events: Private ordinary functions
Function, eat-full-frames-of-events: Private ordinary functions
Function, echo-current-frame: Private ordinary functions
Function, end-of-frame-position: Private ordinary functions
Function, ensure-txn: Private ordinary functions
Function, equivalent-states-p: Private ordinary functions
Function, error-event-p: Private ordinary functions
Function, event-args: Public ordinary functions
Function, event-exit: Public ordinary functions
Function, event-name: Public ordinary functions
Function, event-outcome: Public ordinary functions
Function, event-version: Public ordinary functions
Function, event=: Public ordinary functions
Function, events-to-frames: Public ordinary functions
Function, every-event-in-frame: Private ordinary functions
Function, expected-outcome-p: Public ordinary functions
Function, expected-type: Public ordinary functions
Function, external-event-p: Public ordinary functions
Function, fail-with-journaling-failure: Private ordinary functions
Function, finalize-journal-state: Private ordinary functions
Function, flet-invoked/1: Private ordinary functions
Function, fsync: Private ordinary functions
Function, fsync-directory: Private ordinary functions
Function, getf*: Private ordinary functions
Function, handle-in-event: Private ordinary functions
Function, handle-leaf-event: Private ordinary functions
Function, handle-out-event: Private ordinary functions
Function, in-event-p: Public ordinary functions
Function, in-with-journaling-p: Private ordinary functions
Function, initialize-journal-state: Private ordinary functions
Function, input-direction-p: Private ordinary functions
Function, input-streamlet-p: Public ordinary functions
Function, invalidate-journal: Private ordinary functions
Function, invoked-function: Private ordinary functions
Function, invoked/1: Private ordinary functions
Function, journal-divergent-p: Public ordinary functions
Function, journal-output-streamlet: Private ordinary functions
Function, journaling-failure: Public ordinary functions
Function, jtracedp: Private ordinary functions
Function, juntrace-1: Private ordinary functions
Function, leaf-event-p: Public ordinary functions
Function, list-events: Public ordinary functions
Function, list-journal-files-in-directory: Private ordinary functions
Function, list-traced-functions: Private ordinary functions
Function, log-event-p: Public ordinary functions
Function, make-file-bundle: Public ordinary functions
Function, make-file-journal: Public ordinary functions
Function, make-file-journals-for-bundle: Private ordinary functions
Function, make-in-event: Public ordinary functions
Function, make-in-event*: Private ordinary functions
Function, make-in-memory-bundle: Public ordinary functions
Function, make-in-memory-journal: Public ordinary functions
Function, make-leaf-event: Public ordinary functions
Function, make-log-decorator: Public ordinary functions
Function, make-out-event: Public ordinary functions
Function, make-out-event*: Private ordinary functions
Function, make-pprint-journal: Public ordinary functions
Function, match-version: Private ordinary functions
Function, maybe-downgrade-version: Private ordinary functions
Function, maybe-handle-invoked: Private ordinary functions
Function, maybe-mark-record-as-divergent: Private ordinary functions
Function, maybe-print-resignalling-message: Private ordinary functions
Function, maybe-replay-outcome: Private ordinary functions
Function, maybe-resignal-journaling-failure: Private ordinary functions
Function, maybe-sync-after-in-event: Private ordinary functions
Function, maybe-sync-after-out-event: Private ordinary functions
Function, nlx-event-p: Private ordinary functions
Function, nlx-outcome-and-maybe->logging: Private ordinary functions
Function, out-event-p: Public ordinary functions
Function, output-direction-p: Private ordinary functions
Function, output-streamlet-p: Public ordinary functions
Function, pattern-to-pred: Private ordinary functions
Function, patterns-to-disjunction: Private ordinary functions
Function, pax-pages: Private ordinary functions
Function, pax-sections: Private ordinary functions
Function, peek-at-out-event: Private ordinary functions
Function, peek-mapped-replay-event: Private ordinary functions
Function, peek-replay-event: Public ordinary functions
Function, position-to-read: Private ordinary functions
Function, position-to-write: Private ordinary functions
Function, pprint-events: Public ordinary functions
Function, prettify-event: Public ordinary functions
Function, print-events: Public ordinary functions
Function, print-record-closed: Private ordinary functions
Function, read-file-journal-state: Private ordinary functions
Function, read-mapped-replay-event: Private ordinary functions
Function, reap-identical-or-non-divergent-journals: Private ordinary functions
Function, reap-journals-in-bundle: Private ordinary functions
Function, record-journal: Public ordinary functions
Function, replay-failure: Public ordinary functions
Function, replay-filter-at-base-depth-p: Private ordinary functions
Function, replay-journal: Public ordinary functions
Function, replay-strategy: Private ordinary functions
Function, replaying-outcome-allowed-p: Private ordinary functions
Function, resolve-log-record: Private ordinary functions
Function, route-event: Private ordinary functions
Function, set-file-journal-completed-on-abort: Private ordinary functions
Function, set-journal-state: Private ordinary functions
Function, skip-events: Private ordinary functions
Function, skip-events-and-maybe->recording: Private ordinary functions
Function, skip-log-events: Private ordinary functions
Function, stream-fd: Private ordinary functions
Function, swank-toggle-jtrace: Private ordinary functions
Function, sync-journal: Public ordinary functions
Function, turn-off-with-journaling-failure-on-nlx: Private ordinary functions
Function, unexpected-outcome-p: Public ordinary functions
Function, untrace-all: Private ordinary functions
Function, values->: Public ordinary functions
Function, values-event-p: Private ordinary functions
Function, values<-: Public ordinary functions
Function, version<: Private ordinary functions
Function, version=: Private ordinary functions
Function, versioned-event-p: Public ordinary functions
Function, write-file-journal-state: Private ordinary functions

G
Generic Function, %direction: Private generic functions
Generic Function, %in-depth: Private generic functions
Generic Function, %journals: Private generic functions
Generic Function, %out-depth: Private generic functions
Generic Function, %output-streamlet-of: Private generic functions
Generic Function, %state: Private generic functions
Generic Function, %stream: Private generic functions
Generic Function, (setf %direction): Private generic functions
Generic Function, (setf %in-depth): Private generic functions
Generic Function, (setf %journals): Private generic functions
Generic Function, (setf %out-depth): Private generic functions
Generic Function, (setf %output-streamlet-of): Private generic functions
Generic Function, (setf %state): Private generic functions
Generic Function, (setf %stream): Private generic functions
Generic Function, (setf journal-log-decorator): Public generic functions
Generic Function, (setf journaling-failure-n-resignallings): Private generic functions
Generic Function, (setf max-n-completed): Public generic functions
Generic Function, (setf max-n-failed): Public generic functions
Generic Function, (setf pprint-journal-prettifier): Public generic functions
Generic Function, (setf pprint-journal-pretty): Public generic functions
Generic Function, (setf pprint-journal-stream): Public generic functions
Generic Function, (setf read-file-position): Private generic functions
Generic Function, (setf wrote-last-p): Private generic functions
Generic Function, close-streamlet: Public generic functions
Generic Function, delete-journal-from-bundle: Private generic functions
Generic Function, directory-of: Public generic functions
Generic Function, equivalent-replay-journals-p: Public generic functions
Generic Function, events: Private generic functions
Generic Function, format-args: Private generic functions
Generic Function, format-control: Private generic functions
Generic Function, identical-journals-p: Public generic functions
Generic Function, journal: Public generic functions
Generic Function, journal-events: Public generic functions
Generic Function, journal-log-decorator: Public generic functions
Generic Function, journal-previous-sync-position: Public generic functions
Generic Function, journal-replay-mismatch: Public generic functions
Generic Function, journal-state: Public generic functions
Generic Function, journal-sync: Public generic functions
Generic Function, journaling-failure-embedded-condition: Public generic functions
Generic Function, journaling-failure-n-resignallings: Private generic functions
Generic Function, journals: Private generic functions
Generic Function, make-record-journal-in-bundle: Private generic functions
Generic Function, make-streamlet-finalizer: Public generic functions
Generic Function, max-n-completed: Public generic functions
Generic Function, max-n-failed: Public generic functions
Generic Function, new-event: Private generic functions
Generic Function, open-streamlet: Public generic functions
Generic Function, open-streamlet-p: Public generic functions
Generic Function, pathname-of: Public generic functions
Generic Function, peek-event: Public generic functions
Generic Function, pprint-journal-prettifier: Public generic functions
Generic Function, pprint-journal-pretty: Public generic functions
Generic Function, pprint-journal-stream: Public generic functions
Generic Function, read-event: Public generic functions
Generic Function, read-file-position: Private generic functions
Generic Function, read-position: Public generic functions
Generic Function, replay-failure-new-event: Public generic functions
Generic Function, replay-failure-record-journal: Private generic functions
Generic Function, replay-failure-replay-event: Public generic functions
Generic Function, replay-failure-replay-journal: Public generic functions
Generic Function, replay-failure-replay-position: Private generic functions
Generic Function, request-completed-on-abort: Public generic functions
Generic Function, set-read-position: Public generic functions
Generic Function, streamlet: Public generic functions
Generic Function, sync-streamlet: Public generic functions
Generic Function, to-journal: Public generic functions
Generic Function, write-event: Public generic functions
Generic Function, write-position: Public generic functions
Generic Function, wrote-last-p: Private generic functions
getf*: Private ordinary functions

H
handle-in-event: Private ordinary functions
handle-leaf-event: Private ordinary functions
handle-out-event: Private ordinary functions

I
identical-journals-p: Public generic functions
identical-journals-p: Public generic functions
identical-journals-p: Public generic functions
identical-journals-p: Public generic functions
in-event-p: Public ordinary functions
in-with-journaling-p: Private ordinary functions
initialize-journal-state: Private ordinary functions
input-direction-p: Private ordinary functions
input-streamlet-p: Public ordinary functions
invalidate-journal: Private ordinary functions
invoked-function: Private ordinary functions
invoked/1: Private ordinary functions

J
journal: Public generic functions
journal: Public generic functions
journal: Public generic functions
journal: Public generic functions
journal-divergent-p: Public ordinary functions
journal-events: Public generic functions
journal-events: Public generic functions
journal-log-decorator: Public generic functions
journal-log-decorator: Public generic functions
journal-output-streamlet: Private ordinary functions
journal-previous-sync-position: Public generic functions
journal-previous-sync-position: Public generic functions
journal-replay-mismatch: Public generic functions
journal-replay-mismatch: Public generic functions
journal-state: Public generic functions
journal-state: Public generic functions
journal-sync: Public generic functions
journal-sync: Public generic functions
journaled: Public macros
journaling-failure: Public ordinary functions
journaling-failure-embedded-condition: Public generic functions
journaling-failure-embedded-condition: Public generic functions
journaling-failure-n-resignallings: Private generic functions
journaling-failure-n-resignallings: Private generic functions
journals: Private generic functions
journals: Private generic functions
jtrace: Public macros
jtrace-1: Private macros
jtracedp: Private ordinary functions
juntrace: Public macros
juntrace-1: Private ordinary functions

L
leaf-event-p: Public ordinary functions
list-events: Public ordinary functions
list-journal-files-in-directory: Private ordinary functions
list-traced-functions: Private ordinary functions
log-event-p: Public ordinary functions
logged: Public macros

M
Macro, async-signal-safe: Private macros
Macro, checked: Public macros
Macro, define-file-bundle-test: Public macros
Macro, define-invoked: Public macros
Macro, flet-invoked: Public macros
Macro, framed: Public macros
Macro, journaled: Public macros
Macro, jtrace: Public macros
Macro, jtrace-1: Private macros
Macro, juntrace: Public macros
Macro, logged: Public macros
Macro, nlx-protect: Private macros
Macro, replayed: Public macros
Macro, save-excursion: Public macros
Macro, unwind-protect*: Private macros
Macro, with-bundle: Public macros
Macro, with-bundle-locked: Private macros
Macro, with-interrupts: Private macros
Macro, with-journal-locked: Private macros
Macro, with-journaling: Public macros
Macro, with-journaling-failure-on-nlx: Private macros
Macro, with-nlx-cancelled: Private macros
Macro, with-open-journal: Public macros
Macro, with-replay-filter: Public macros
Macro, with-replay-streamlet: Public macros
Macro, with-standard-io-syntax*: Private macros
Macro, without-interrupts: Private macros
make-file-bundle: Public ordinary functions
make-file-journal: Public ordinary functions
make-file-journals-for-bundle: Private ordinary functions
make-in-event: Public ordinary functions
make-in-event*: Private ordinary functions
make-in-memory-bundle: Public ordinary functions
make-in-memory-journal: Public ordinary functions
make-leaf-event: Public ordinary functions
make-log-decorator: Public ordinary functions
make-out-event: Public ordinary functions
make-out-event*: Private ordinary functions
make-pprint-journal: Public ordinary functions
make-record-journal-in-bundle: Private generic functions
make-record-journal-in-bundle: Private generic functions
make-record-journal-in-bundle: Private generic functions
make-streamlet-finalizer: Public generic functions
make-streamlet-finalizer: Public generic functions
make-streamlet-finalizer: Public generic functions
make-streamlet-finalizer: Public generic functions
match-version: Private ordinary functions
max-n-completed: Public generic functions
max-n-completed: Public generic functions
max-n-failed: Public generic functions
max-n-failed: Public generic functions
maybe-downgrade-version: Private ordinary functions
maybe-handle-invoked: Private ordinary functions
maybe-mark-record-as-divergent: Private ordinary functions
maybe-print-resignalling-message: Private ordinary functions
maybe-replay-outcome: Private ordinary functions
maybe-resignal-journaling-failure: Private ordinary functions
maybe-sync-after-in-event: Private ordinary functions
maybe-sync-after-out-event: Private ordinary functions
Method, %direction: Private generic functions
Method, %in-depth: Private generic functions
Method, %journals: Private generic functions
Method, %out-depth: Private generic functions
Method, %out-depth: Private generic functions
Method, %output-streamlet-of: Private generic functions
Method, %state: Private generic functions
Method, %stream: Private generic functions
Method, (setf %direction): Private generic functions
Method, (setf %in-depth): Private generic functions
Method, (setf %journals): Private generic functions
Method, (setf %out-depth): Private generic functions
Method, (setf %out-depth): Private generic functions
Method, (setf %output-streamlet-of): Private generic functions
Method, (setf %state): Private generic functions
Method, (setf %stream): Private generic functions
Method, (setf journal-log-decorator): Public generic functions
Method, (setf journaling-failure-n-resignallings): Private generic functions
Method, (setf max-n-completed): Public generic functions
Method, (setf max-n-failed): Public generic functions
Method, (setf pprint-journal-prettifier): Public generic functions
Method, (setf pprint-journal-pretty): Public generic functions
Method, (setf pprint-journal-stream): Public generic functions
Method, (setf read-file-position): Private generic functions
Method, (setf wrote-last-p): Private generic functions
Method, close-streamlet: Public generic functions
Method, close-streamlet: Public generic functions
Method, close-streamlet: Public generic functions
Method, close-streamlet: Public generic functions
Method, delete-journal-from-bundle: Private generic functions
Method, delete-journal-from-bundle: Private generic functions
Method, delete-journal-from-bundle: Private generic functions
Method, directory-of: Public generic functions
Method, equivalent-replay-journals-p: Public generic functions
Method, equivalent-replay-journals-p: Public generic functions
Method, events: Private generic functions
Method, format-args: Private generic functions
Method, format-args: Private generic functions
Method, format-control: Private generic functions
Method, format-control: Private generic functions
Method, identical-journals-p: Public generic functions
Method, identical-journals-p: Public generic functions
Method, identical-journals-p: Public generic functions
Method, journal: Public generic functions
Method, journal: Public generic functions
Method, journal: Public generic functions
Method, journal-events: Public generic functions
Method, journal-log-decorator: Public generic functions
Method, journal-previous-sync-position: Public generic functions
Method, journal-replay-mismatch: Public generic functions
Method, journal-state: Public generic functions
Method, journal-sync: Public generic functions
Method, journaling-failure-embedded-condition: Public generic functions
Method, journaling-failure-n-resignallings: Private generic functions
Method, journals: Private generic functions
Method, make-record-journal-in-bundle: Private generic functions
Method, make-record-journal-in-bundle: Private generic functions
Method, make-streamlet-finalizer: Public generic functions
Method, make-streamlet-finalizer: Public generic functions
Method, make-streamlet-finalizer: Public generic functions
Method, max-n-completed: Public generic functions
Method, max-n-failed: Public generic functions
Method, new-event: Private generic functions
Method, open-streamlet: Public generic functions
Method, open-streamlet: Public generic functions
Method, open-streamlet: Public generic functions
Method, open-streamlet: Public generic functions
Method, open-streamlet: Public generic functions
Method, open-streamlet-p: Public generic functions
Method, pathname-of: Public generic functions
Method, peek-event: Public generic functions
Method, peek-event: Public generic functions
Method, peek-event: Public generic functions
Method, pprint-journal-prettifier: Public generic functions
Method, pprint-journal-pretty: Public generic functions
Method, pprint-journal-stream: Public generic functions
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, read-event: Public generic functions
Method, read-event: Public generic functions
Method, read-event: Public generic functions
Method, read-file-position: Private generic functions
Method, read-position: Public generic functions
Method, read-position: Public generic functions
Method, replay-failure-new-event: Public generic functions
Method, replay-failure-record-journal: Private generic functions
Method, replay-failure-replay-event: Public generic functions
Method, replay-failure-replay-journal: Public generic functions
Method, replay-failure-replay-position: Private generic functions
Method, request-completed-on-abort: Public generic functions
Method, request-completed-on-abort: Public generic functions
Method, request-completed-on-abort: Public generic functions
Method, request-completed-on-abort: Public generic functions
Method, set-read-position: Public generic functions
Method, set-read-position: Public generic functions
Method, streamlet: Public generic functions
Method, sync-streamlet: Public generic functions
Method, sync-streamlet: Public generic functions
Method, sync-streamlet: Public generic functions
Method, sync-streamlet: Public generic functions
Method, to-journal: Public generic functions
Method, to-journal: Public generic functions
Method, to-journal: Public generic functions
Method, to-journal: Public generic functions
Method, to-journal: Public generic functions
Method, write-event: Public generic functions
Method, write-event: Public generic functions
Method, write-event: Public generic functions
Method, write-event: Public generic functions
Method, write-event: Public generic functions
Method, write-position: Public generic functions
Method, write-position: Public generic functions
Method, write-position: Public generic functions
Method, wrote-last-p: Private generic functions

N
new-event: Private generic functions
new-event: Private generic functions
nlx-event-p: Private ordinary functions
nlx-outcome-and-maybe->logging: Private ordinary functions
nlx-protect: Private macros

O
open-streamlet: Public generic functions
open-streamlet: Public generic functions
open-streamlet: Public generic functions
open-streamlet: Public generic functions
open-streamlet: Public generic functions
open-streamlet: Public generic functions
open-streamlet-p: Public generic functions
open-streamlet-p: Public generic functions
out-event-p: Public ordinary functions
output-direction-p: Private ordinary functions
output-streamlet-p: Public ordinary functions

P
pathname-of: Public generic functions
pathname-of: Public generic functions
pattern-to-pred: Private ordinary functions
patterns-to-disjunction: Private ordinary functions
pax-pages: Private ordinary functions
pax-sections: Private ordinary functions
peek-at-out-event: Private ordinary functions
peek-event: Public generic functions
peek-event: Public generic functions
peek-event: Public generic functions
peek-event: Public generic functions
peek-mapped-replay-event: Private ordinary functions
peek-replay-event: Public ordinary functions
position-to-read: Private ordinary functions
position-to-write: Private ordinary functions
pprint-events: Public ordinary functions
pprint-journal-prettifier: Public generic functions
pprint-journal-prettifier: Public generic functions
pprint-journal-pretty: Public generic functions
pprint-journal-pretty: Public generic functions
pprint-journal-stream: Public generic functions
pprint-journal-stream: Public generic functions
prettify-event: Public ordinary functions
print-events: Public ordinary functions
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-record-closed: Private ordinary functions

R
read-event: Public generic functions
read-event: Public generic functions
read-event: Public generic functions
read-event: Public generic functions
read-file-journal-state: Private ordinary functions
read-file-position: Private generic functions
read-file-position: Private generic functions
read-mapped-replay-event: Private ordinary functions
read-position: Public generic functions
read-position: Public generic functions
read-position: Public generic functions
reap-identical-or-non-divergent-journals: Private ordinary functions
reap-journals-in-bundle: Private ordinary functions
record-journal: Public ordinary functions
replay-failure: Public ordinary functions
replay-failure-new-event: Public generic functions
replay-failure-new-event: Public generic functions
replay-failure-record-journal: Private generic functions
replay-failure-record-journal: Private generic functions
replay-failure-replay-event: Public generic functions
replay-failure-replay-event: Public generic functions
replay-failure-replay-journal: Public generic functions
replay-failure-replay-journal: Public generic functions
replay-failure-replay-position: Private generic functions
replay-failure-replay-position: Private generic functions
replay-filter-at-base-depth-p: Private ordinary functions
replay-journal: Public ordinary functions
replay-strategy: Private ordinary functions
replayed: Public macros
replaying-outcome-allowed-p: Private ordinary functions
request-completed-on-abort: Public generic functions
request-completed-on-abort: Public generic functions
request-completed-on-abort: Public generic functions
request-completed-on-abort: Public generic functions
request-completed-on-abort: Public generic functions
resolve-log-record: Private ordinary functions
route-event: Private ordinary functions

S
save-excursion: Public macros
set-file-journal-completed-on-abort: Private ordinary functions
set-journal-state: Private ordinary functions
set-read-position: Public generic functions
set-read-position: Public generic functions
set-read-position: Public generic functions
Setf Expander, (setf read-position): Public setf expanders
skip-events: Private ordinary functions
skip-events-and-maybe->recording: Private ordinary functions
skip-log-events: Private ordinary functions
stream-fd: Private ordinary functions
streamlet: Public generic functions
streamlet: Public generic functions
swank-toggle-jtrace: Private ordinary functions
sync-journal: Public ordinary functions
sync-streamlet: Public generic functions
sync-streamlet: Public generic functions
sync-streamlet: Public generic functions
sync-streamlet: Public generic functions
sync-streamlet: Public generic functions

T
to-journal: Public generic functions
to-journal: Public generic functions
to-journal: Public generic functions
to-journal: Public generic functions
to-journal: Public generic functions
to-journal: Public generic functions
turn-off-with-journaling-failure-on-nlx: Private ordinary functions

U
unexpected-outcome-p: Public ordinary functions
untrace-all: Private ordinary functions
unwind-protect*: Private macros

V
values->: Public ordinary functions
values-event-p: Private ordinary functions
values<-: Public ordinary functions
version<: Private ordinary functions
version=: Private ordinary functions
versioned-event-p: Public ordinary functions

W
with-bundle: Public macros
with-bundle-locked: Private macros
with-interrupts: Private macros
with-journal-locked: Private macros
with-journaling: Public macros
with-journaling-failure-on-nlx: Private macros
with-nlx-cancelled: Private macros
with-open-journal: Public macros
with-replay-filter: Public macros
with-replay-streamlet: Public macros
with-standard-io-syntax*: Private macros
without-interrupts: Private macros
write-event: Public generic functions
write-event: Public generic functions
write-event: Public generic functions
write-event: Public generic functions
write-event: Public generic functions
write-event: Public generic functions
write-file-journal-state: Private ordinary functions
write-position: Public generic functions
write-position: Public generic functions
write-position: Public generic functions
write-position: Public generic functions
wrote-last-p: Private generic functions
wrote-last-p: Private generic functions


A.3 Variables

Jump to:   %   *   @  
A   C   D   E   F   I   J   L   M   N   O   P   R   S   T   U   V   W  
Index Entry  Section

%
%read-position: Private classes
%trusted: Public classes

*
*file-bundle-lock*: Private special variables
*file-journal-lock*: Private special variables
*force-insertable*: Public special variables
*invoked-event-name-to-function-name*: Private special variables
*journaling-failure*: Private special variables
*local-invoked-event-name-to-function*: Private special variables
*next-write-event-fn*: Private special variables
*no-replay-outcome-names*: Private special variables
*record-journal-state*: Private special variables
*record-streamlet*: Private special variables
*replay-eoj-error-p*: Private special variables
*replay-event-mapper*: Private special variables
*replay-failure*: Private special variables
*replay-filter-base-depth*: Private special variables
*replay-streamlet*: Private special variables
*skip-events*: Private special variables
*skip-patterns*: Private special variables
*skipped-events-until*: Private special variables
*suppress-trace*: Private special variables
*testing*: Private special variables
*trace-journal*: Public special variables
*trace-pretty*: Public special variables
*trace-real-time*: Public special variables
*trace-run-time*: Public special variables
*trace-thread*: Public special variables
*trace-time*: Public special variables
*traced-functions*: Private special variables
*truename-to-file-bundle*: Private special variables
*truename-to-file-journal*: Private special variables
*with-interrupts-available*: Private special variables
*with-journaling-failure-on-nlx-body-completed*: Private special variables
*without-interrupts-available*: Private special variables

@
@async-unwind: Private special variables
@block: Public special variables
@boolean-valued-symbol: Private special variables
@bundles: Public special variables
@bundles-reference: Public special variables
@comparing-journals: Public special variables
@customizing-logs: Public special variables
@decoration: Public special variables
@event-versions: Public special variables
@events-reference: Public special variables
@file-bundles: Public special variables
@file-journals: Public special variables
@frame: Public special variables
@in-events: Public special variables
@in-events-reference: Public special variables
@in-memory-bundles: Public special variables
@in-memory-journals: Public special variables
@journal-background: Public special variables
@journal-basics: Public special variables
@journal-error-handling: Public special variables
@journal-features: Public special variables
@journal-links: Public special variables
@journal-manual: Public special variables
@journal-portability: Public special variables
@journal-slime-integration: Public special variables
@journal-utilities: Public special variables
@journal/glossary: Public special variables
@journaled-for-replay: Public special variables
@journals-reference: Public special variables
@leaf-events-reference: Public special variables
@log-record: Public special variables
@logging: Public special variables
@logging-with-leaves: Public special variables
@matching-in-events: Public special variables
@matching-out-events: Public special variables
@non-local-exit: Private special variables
@opening-and-closing: Public special variables
@out-events: Public special variables
@out-events-reference: Public special variables
@persistence: Public special variables
@persistence-tutorial: Public special variables
@pprint-journals: Public special variables
@pretty-printing: Public special variables
@readable: Private special variables
@reading-from-streamlets: Public special variables
@replay: Public special variables
@replay-failures: Public special variables
@replaying-the-outcome: Public special variables
@safety: Public special variables
@streamlets-reference: Public special variables
@synchronization: Public special variables
@synchronization-strategies: Public special variables
@synchronization-with-file-journals: Public special variables
@synchronization-with-in-memory-journals: Public special variables
@testing: Public special variables
@testing-on-multiple-levels: Public special variables
@the-replay-strategy: Public special variables
@tracing: Public special variables
@upgrades-and-replay: Public special variables
@working-with-unreadable-values: Public special variables
@writing-to-streamlets: Public special variables

A
aborted-execution: Public special variables

C
completed-on-abort-deferred-p: Public classes
condition-outcome: Public special variables

D
data-event: Public special variables
direction: Public classes
directory: Public classes

E
embedded-condition: Public conditions
error-outcome: Public special variables
events: Public classes
expected-outcome: Public special variables

F
format-args: Public conditions
format-args: Public conditions
format-control: Public conditions
format-control: Public conditions

I
in-depth: Public classes
invoked: Public special variables

J
journal: Public conditions
journal: Public conditions
journal: Public classes
journals: Public classes

L
lock: Public classes
lock: Public classes
log-decorator: Public classes

M
max-n-completed: Public classes
max-n-failed: Public classes

N
n-readers: Public classes
n-resignallings: Public conditions
n-writers: Public classes
n-writers: Public classes
new-event: Public conditions
new-event: Public conditions
nlx-outcome: Public special variables

O
out-depth: Private classes
out-depth: Private classes
output-streamlet: Public classes

P
pathname: Public classes
peeked: Private classes
peeked: Private classes
prettifier: Public classes
pretty: Public classes
previous-sync-position: Public classes

R
read-file-position: Private classes
record-journal: Public conditions
replay-event: Public special variables
replay-event: Public conditions
replay-journal: Public conditions
replay-mismatch: Public classes
replay-position: Public conditions

S
set-complete-on-abort-on-commit-p: Private classes
Slot, %read-position: Private classes
Slot, %trusted: Public classes
Slot, completed-on-abort-deferred-p: Public classes
Slot, direction: Public classes
Slot, directory: Public classes
Slot, embedded-condition: Public conditions
Slot, events: Public classes
Slot, format-args: Public conditions
Slot, format-args: Public conditions
Slot, format-control: Public conditions
Slot, format-control: Public conditions
Slot, in-depth: Public classes
Slot, journal: Public conditions
Slot, journal: Public conditions
Slot, journal: Public classes
Slot, journals: Public classes
Slot, lock: Public classes
Slot, lock: Public classes
Slot, log-decorator: Public classes
Slot, max-n-completed: Public classes
Slot, max-n-failed: Public classes
Slot, n-readers: Public classes
Slot, n-resignallings: Public conditions
Slot, n-writers: Public classes
Slot, n-writers: Public classes
Slot, new-event: Public conditions
Slot, new-event: Public conditions
Slot, out-depth: Private classes
Slot, out-depth: Private classes
Slot, output-streamlet: Public classes
Slot, pathname: Public classes
Slot, peeked: Private classes
Slot, peeked: Private classes
Slot, prettifier: Public classes
Slot, pretty: Public classes
Slot, previous-sync-position: Public classes
Slot, read-file-position: Private classes
Slot, record-journal: Public conditions
Slot, replay-event: Public conditions
Slot, replay-journal: Public conditions
Slot, replay-mismatch: Public classes
Slot, replay-position: Public conditions
Slot, set-complete-on-abort-on-commit-p: Private classes
Slot, state: Public classes
Slot, stream: Public classes
Slot, stream: Private classes
Slot, streamlet: Public conditions
Slot, sync: Public classes
Slot, sync: Public classes
Slot, sync: Public classes
Slot, sync: Public classes
Slot, sync-fn: Public classes
Slot, sync-fn: Public classes
Slot, txn-start-file-position: Private classes
Slot, wrote-last-p: Private classes
Special Variable, *file-bundle-lock*: Private special variables
Special Variable, *file-journal-lock*: Private special variables
Special Variable, *force-insertable*: Public special variables
Special Variable, *invoked-event-name-to-function-name*: Private special variables
Special Variable, *journaling-failure*: Private special variables
Special Variable, *local-invoked-event-name-to-function*: Private special variables
Special Variable, *next-write-event-fn*: Private special variables
Special Variable, *no-replay-outcome-names*: Private special variables
Special Variable, *record-journal-state*: Private special variables
Special Variable, *record-streamlet*: Private special variables
Special Variable, *replay-eoj-error-p*: Private special variables
Special Variable, *replay-event-mapper*: Private special variables
Special Variable, *replay-failure*: Private special variables
Special Variable, *replay-filter-base-depth*: Private special variables
Special Variable, *replay-streamlet*: Private special variables
Special Variable, *skip-events*: Private special variables
Special Variable, *skip-patterns*: Private special variables
Special Variable, *skipped-events-until*: Private special variables
Special Variable, *suppress-trace*: Private special variables
Special Variable, *testing*: Private special variables
Special Variable, *trace-journal*: Public special variables
Special Variable, *trace-pretty*: Public special variables
Special Variable, *trace-real-time*: Public special variables
Special Variable, *trace-run-time*: Public special variables
Special Variable, *trace-thread*: Public special variables
Special Variable, *trace-time*: Public special variables
Special Variable, *traced-functions*: Private special variables
Special Variable, *truename-to-file-bundle*: Private special variables
Special Variable, *truename-to-file-journal*: Private special variables
Special Variable, *with-interrupts-available*: Private special variables
Special Variable, *with-journaling-failure-on-nlx-body-completed*: Private special variables
Special Variable, *without-interrupts-available*: Private special variables
Special Variable, @async-unwind: Private special variables
Special Variable, @block: Public special variables
Special Variable, @boolean-valued-symbol: Private special variables
Special Variable, @bundles: Public special variables
Special Variable, @bundles-reference: Public special variables
Special Variable, @comparing-journals: Public special variables
Special Variable, @customizing-logs: Public special variables
Special Variable, @decoration: Public special variables
Special Variable, @event-versions: Public special variables
Special Variable, @events-reference: Public special variables
Special Variable, @file-bundles: Public special variables
Special Variable, @file-journals: Public special variables
Special Variable, @frame: Public special variables
Special Variable, @in-events: Public special variables
Special Variable, @in-events-reference: Public special variables
Special Variable, @in-memory-bundles: Public special variables
Special Variable, @in-memory-journals: Public special variables
Special Variable, @journal-background: Public special variables
Special Variable, @journal-basics: Public special variables
Special Variable, @journal-error-handling: Public special variables
Special Variable, @journal-features: Public special variables
Special Variable, @journal-links: Public special variables
Special Variable, @journal-manual: Public special variables
Special Variable, @journal-portability: Public special variables
Special Variable, @journal-slime-integration: Public special variables
Special Variable, @journal-utilities: Public special variables
Special Variable, @journal/glossary: Public special variables
Special Variable, @journaled-for-replay: Public special variables
Special Variable, @journals-reference: Public special variables
Special Variable, @leaf-events-reference: Public special variables
Special Variable, @log-record: Public special variables
Special Variable, @logging: Public special variables
Special Variable, @logging-with-leaves: Public special variables
Special Variable, @matching-in-events: Public special variables
Special Variable, @matching-out-events: Public special variables
Special Variable, @non-local-exit: Private special variables
Special Variable, @opening-and-closing: Public special variables
Special Variable, @out-events: Public special variables
Special Variable, @out-events-reference: Public special variables
Special Variable, @persistence: Public special variables
Special Variable, @persistence-tutorial: Public special variables
Special Variable, @pprint-journals: Public special variables
Special Variable, @pretty-printing: Public special variables
Special Variable, @readable: Private special variables
Special Variable, @reading-from-streamlets: Public special variables
Special Variable, @replay: Public special variables
Special Variable, @replay-failures: Public special variables
Special Variable, @replaying-the-outcome: Public special variables
Special Variable, @safety: Public special variables
Special Variable, @streamlets-reference: Public special variables
Special Variable, @synchronization: Public special variables
Special Variable, @synchronization-strategies: Public special variables
Special Variable, @synchronization-with-file-journals: Public special variables
Special Variable, @synchronization-with-in-memory-journals: Public special variables
Special Variable, @testing: Public special variables
Special Variable, @testing-on-multiple-levels: Public special variables
Special Variable, @the-replay-strategy: Public special variables
Special Variable, @tracing: Public special variables
Special Variable, @upgrades-and-replay: Public special variables
Special Variable, @working-with-unreadable-values: Public special variables
Special Variable, @writing-to-streamlets: Public special variables
Special Variable, aborted-execution: Public special variables
Special Variable, condition-outcome: Public special variables
Special Variable, data-event: Public special variables
Special Variable, error-outcome: Public special variables
Special Variable, expected-outcome: Public special variables
Special Variable, invoked: Public special variables
Special Variable, nlx-outcome: Public special variables
Special Variable, replay-event: Public special variables
Special Variable, unexpected-outcome: Public special variables
Special Variable, values-outcome: Public special variables
state: Public classes
stream: Public classes
stream: Private classes
streamlet: Public conditions
sync: Public classes
sync: Public classes
sync: Public classes
sync: Public classes
sync-fn: Public classes
sync-fn: Public classes

T
txn-start-file-position: Private classes

U
unexpected-outcome: Public special variables

V
values-outcome: Public special variables

W
wrote-last-p: Private classes


A.4 Data types

Jump to:   B   C   D   E   F   I   J   L   M   O   P   R   S   T   U   V  
Index Entry  Section

B
bundle: Public classes

C
Class, bundle: Public classes
Class, file-bundle: Public classes
Class, file-journal: Public classes
Class, file-streamlet: Private classes
Class, in-memory-bundle: Public classes
Class, in-memory-journal: Public classes
Class, in-memory-streamlet: Private classes
Class, journal: Public classes
Class, pprint-journal: Public classes
Class, pprint-streamlet: Private classes
Class, streamlet: Public classes
Condition, data-event-lossage: Public conditions
Condition, end-of-journal: Public conditions
Condition, journal-error: Public conditions
Condition, journaling-failure: Public conditions
Condition, record-unexpected-outcome: Public conditions
Condition, replay-args-mismatch: Public conditions
Condition, replay-failure: Public conditions
Condition, replay-incomplete: Public conditions
Condition, replay-name-mismatch: Public conditions
Condition, replay-outcome-mismatch: Public conditions
Condition, replay-unexpected-outcome: Public conditions
Condition, replay-version-downgrade: Public conditions
Condition, streamlet-error: Public conditions

D
data-event-lossage: Public conditions
direction: Private types
doc.lisp: The journal/src/doc․lisp file

E
end-of-journal: Public conditions
event: Public types
event-exit: Public types
event-version: Public types
external-event: Public types

F
File, doc.lisp: The journal/src/doc․lisp file
File, interrupt.lisp: The journal/src/interrupt․lisp file
File, journal.asd: The journal/journal․asd file
File, journal.lisp: The journal/src/journal․lisp file
File, package.lisp: The journal/src/package․lisp file
file-bundle: Public classes
file-journal: Public classes
file-streamlet: Private classes

I
in-event: Public types
in-memory-bundle: Public classes
in-memory-journal: Public classes
in-memory-streamlet: Private classes
interrupt.lisp: The journal/src/interrupt․lisp file

J
journal: The journal system
journal: The journal package
journal: Public classes
journal-error: Public conditions
journal-state: Public types
journal.asd: The journal/journal․asd file
journal.lisp: The journal/src/journal․lisp file
journaling-failure: Public conditions

L
leaf-event: Public types
log-event: Public types

M
Module, src: The journal/src module

O
out-event: Public types

P
Package, journal: The journal package
package.lisp: The journal/src/package․lisp file
pprint-journal: Public classes
pprint-streamlet: Private classes

R
record-unexpected-outcome: Public conditions
replay-args-mismatch: Public conditions
replay-failure: Public conditions
replay-incomplete: Public conditions
replay-name-mismatch: Public conditions
replay-outcome-mismatch: Public conditions
replay-unexpected-outcome: Public conditions
replay-version-downgrade: Public conditions

S
safe-condition: Private types
src: The journal/src module
streamlet: Public classes
streamlet-error: Public conditions
System, journal: The journal system

T
Type, direction: Private types
Type, event: Public types
Type, event-exit: Public types
Type, event-version: Public types
Type, external-event: Public types
Type, in-event: Public types
Type, journal-state: Public types
Type, leaf-event: Public types
Type, log-event: Public types
Type, out-event: Public types
Type, safe-condition: Private types
Type, unsafe-condition: Private types
Type, versioned-event: Public types

U
unsafe-condition: Private types

V
versioned-event: Public types