The lfarm-gss Reference Manual

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

The lfarm-gss Reference Manual

This is the lfarm-gss Reference Manual, generated automatically by Declt version 4.0 beta 2 "William Riker" on Thu Sep 15 05:12:11 2022 GMT+0.

Table of Contents


1 Introduction

lfarm

lfarm is a Common Lisp library for distributing work across machines using the [lparallel] (http://lparallel.org) API.

Download

The easiest way to obtain lfarm is through Quicklisp. Alternatively, one may clone the repository.

Synopsis

In lparallel a kernel was defined as abstract entity that schedules and executes tasks. lparallel implements it with a thread pool, while in lfarm it is implemented with a set of servers that execute tasks.

;; Create two servers bound to ports 11111 and 22222.
(ql:quickload :lfarm-server)
(lfarm-server:start-server "127.0.0.1" 11111 :background t)
(lfarm-server:start-server "127.0.0.1" 22222 :background t)

;; Connect to the servers. `lfarm' is a package nickname for `lfarm-client'.
(ql:quickload :lfarm-client)
(setf lfarm:*kernel* (lfarm:make-kernel '(("127.0.0.1" 11111)
                                          ("127.0.0.1" 22222))))

;; Use the lparallel API.
(defpackage :example (:use :cl :lfarm))
(in-package :example)

(let ((channel (make-channel)))
  (submit-task channel #'+ 3 4)
  (receive-result channel))
;; => 7

(let ((f (future (+ 3 4))))
  (force f))
;; => 7

(plet ((x (+ 3 4))
       (y (+ 5 6)))
  (+ x y))
;; => 18

(pmapcar '1+ #(1 2 3))         ; => (2 3 4)
(pmapcar #'1+ #(1 2 3))        ; => (2 3 4)
(preduce '+ #(1 2 3))          ; => 6
(pmap-reduce '1+ '+ #(1 2 3))  ; => 9

Although the servers in this example are local, lfarm servers may run in separate Lisp instances on remote machines.

Tasks

There are some restrictions on a task slated for remote execution. A task must be

  1. a lambda form, or
  2. a function that exists on the remote servers, or
  3. a function defined with deftask.

deftask is just like defun except the function definition is recorded. (A Lisp implementation may record a function definition, but is not required to do so.)

(deftask add (x y)
  (+ x y))

(let ((channel (make-channel)))
  (submit-task channel #'add 3 4)
  (receive-result channel))
;; => 7

submit-task notices that add was defined with deftask and converts it to a named lambda before submitting it to a server.

To define add remotely use broadcast-task, which executes a given task on all servers.

(broadcast-task (lambda () (defun add (x y) (+ x y))))

Or more likely add would be part of a system that is loaded on all servers.

(broadcast-task #'ql:quickload :my-stuff)

Limited support for closures is available on SBCL, CCL, LispWorks, and Allegro. Lexical variables and symbol macrolets are captured, but lexical functions (flet, labels) are not.

Tasks are not macroexpanded in order to ensure portability across clients and servers.

API

The lfarm-client system defines the lfarm-client package which has the nickname lfarm. It exports the lparallel kernel API with the following differences.

Promises and a limited number of cognates are also available, found in the packages lfarm-client.promise and lfarm-client.cognate respectively and also exported by lfarm-client.

The systems lfarm-server and lfarm-admin provide the following functions.

Security

The purpose of an lfarm server is to execute arbitrary code, so it is highly advised to enable some form of security. lfarm directly supports Kerberos (or Active Directory) authentication. Alternatively, SSH tunnels may be used.

Security with SSH tunneling

;; On the remote machine
(ql:quickload :lfarm-server)
(lfarm-server:start-server "127.0.0.1" 33333)

To create a tunnel,

# On the local machine
$ ssh -f -L 33333:127.0.0.1:33333 <remote-address> -N

The remote server should now be accessible locally.

;; On the local machine
(ql:quickload :lfarm-admin)
(lfarm-admin:ping "127.0.0.1" 33333) ;=> T

Of course there is still local security to consider, as local users on both ends have access to the server. If this is a concern then a packet filtering tool such as iptables may be used.

Security with Kerberos/GSSAPI

The lfarm-gss system provides support for GSSAPI authentication. The :auth argument to lfarm-server:start-server and lfarm-client:make-kernel accepts an instance of lfarm-gss:gss-auth-server and lfarm-gss:gss-auth-client respectively.

When creating a server, the class lfarm-gss:gss-auth-server accepts the initialization keyword :service-name. This value is indicats which service type should be used when requesting a ticket for the remote service. The default is lfarm. In other words, if an attempt is done to connect to the server at server.example.com, the service principal will be lfarm/server.example.com.

When creating a kernel (client), the class lfarm-gss:gss-auth-client accepts the initialization keyword :allowed-users which specifies a list of all users that are allowed to connect to the server. Each element should be a string representing the principal name (including realm) of the user that is allowed to connect. For example: user@EXAMPLE.COM.

If a more complex authorization mechanism is needed which is not covered by the simple user list as described above, you can subclass the gss-auth-server class and then implement the method lfarm-gss:name-accepted on your new class. This generic function takes two arguments, the authentication object and the name to be verified, and should return non-NIL if the user is allowed to connect. Note that the name is an instance of cl-gss:name, and you need to call the function cl-gss:name-to-string on it to extract the actual name.

The server needs to have access to the service principal in a keytab file. How to create the keytab file depends on your Kerberos server implementation:

Once you have the keytab file, you have to make sure that it is loaded. The easiest way to do this is to simply call CL-GSS:KRB5-REGISTER-ACCEPTOR-IDENTITY and pass in the name of the keytab file.

The other way is to make sure the environment variable KRB5_KTNAME is set to the path of the keytab file and that it is readable by the lfarm server instance.

If the keytab file has not been loaded, the server will fail to authenticate and you will get a security error when the client attempts to connect to the server.

Details

That covers perhaps all you need to know about lfarm. Those who are curious may read on (or not).

Serialization

Serialization is done with cl-store. It uses a portable serialization format, allowing lfarm clients and servers to run on different Lisp implementations.

Packages

A symbol is deserialized on the remote server with its home package intact. If the server encounters a symbol whose package does not exist, an empty version of the package is automatically generated.

Connection errors

The lfarm client is obstinate with regards to connections: if there is a connection error then it tries to reconnect, and will continue trying. We may therefore restart servers while using the same kernel instance, or call make-kernel before any servers exist (the call will block until they do).

Note it is possible for a task to be executed twice (or more). If a connection error occurs in the time interval after a task has been submitted and before its result has been received, the client will attempt to submit the task again.

submit-task

In lparallel submit-task is a function, but in lfarm it is a macro that provides syntactic sugar for the function submit-task*.

(submit-task channel #'+ 3 4)
;; =macroexpand=> (SUBMIT-TASK* CHANNEL '+ 3 4)

(submit-task channel (lambda (x) (1+ x)) 3)
;; =macroexpand=> (SUBMIT-TASK* CHANNEL '(LAMBDA (X) (1+ X)) 3)

submit-task may alter the task argument before giving it to submit-task*, which expects a symbol or a lambda form. Sharp-quote is replaced with quote, and a lambda form gets quoted. This provides a semblance with lparallel:submit-task and relieves us from having to write '(lambda ...) and 'f in place of (lambda ...) and #'f.

Logging

Verbose logging is enabled by binding lfarm-common:*log-level* to :info (default is :error). The log stream is lfarm-common:*log-stream* (default is *debug-io*).

Tests

The lfarm test suite assumes a working ssh executable is present and that passwordless authorization has been set up for "ssh localhost". To run it load the lfarm-test system and call lfarm-test:execute, which may be given some configuration options. Unrecognized Lisp implementations will require configuration (namely, specifying the lisp executable and the command-line switch to eval a form). Tests also assume that Quicklisp has been installed (but not necessarily loaded), although configuration may remove this assumption.

Implementation

The client has an internal lparallel kernel in which each worker thread manages a connection to an assigned remote server, one worker per server. When a worker connects to a server, the server enters a task execution loop wherein a form is deserialized, maybe compiled, and funcalled; repeat. A server may serve multiple clients.

Though an async backend is possible, this threaded implementation was chosen because it was easy and portable.

Opportunities for optimization in the realm of remote task queues and remote task stealing have been callously ignored. Task queues are local.

Author

James M. Lawrence llmjjmll@gmail.com

Kerberos support by Elias Martenson lokedhs@gmail.com


2 Systems

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


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

2.1 lfarm-gss

GSS-API support for lfarm

Author

Elias Martenson <lokedhs@gmail.com>

License

BSD

Dependencies
  • lfarm-common (system).
  • cl-gss (system).
  • trivial-gray-streams (system).
Source

lfarm-gss.asd.

Child Component

lfarm-gss (module).


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

2.2 lfarm-common

(private) Common components of lfarm, a library for distributing work across machines.

Author

James M. Lawrence <llmjjmll@gmail.com>

License

BSD

Long Description

See http://github.com/lmj/lfarm

Version

0.1.0

Dependencies
  • alexandria (system).
  • bordeaux-threads (system).
  • usocket (system).
  • flexi-streams (system).
  • cl-store (system).
Source

lfarm-common.asd.

Child Component

lfarm-common (module).


3 Modules

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


3.1 lfarm-gss/lfarm-gss

Source

lfarm-gss.asd.

Parent Component

lfarm-gss (system).

Child Components

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

3.2 lfarm-common/lfarm-common

Source

lfarm-common.asd.

Parent Component

lfarm-common (system).

Child Components

4 Files

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


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

4.1 Lisp


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

4.1.1 lfarm-gss/lfarm-gss.asd

Source

lfarm-gss.asd.

Parent Component

lfarm-gss (system).

ASDF Systems

lfarm-gss.


4.1.2 lfarm-common/lfarm-common.asd

Source

lfarm-common.asd.

Parent Component

lfarm-common (system).

ASDF Systems

lfarm-common.


4.1.3 lfarm-gss/lfarm-gss/packages.lisp

Source

lfarm-gss.asd.

Parent Component

lfarm-gss (module).

Packages

lfarm-gss.


4.1.4 lfarm-gss/lfarm-gss/wrapper-stream.lisp

Dependency

packages.lisp (file).

Source

lfarm-gss.asd.

Parent Component

lfarm-gss (module).

Public Interface
Internals

4.1.5 lfarm-gss/lfarm-gss/lfarm-gss.lisp

Dependency

wrapper-stream.lisp (file).

Source

lfarm-gss.asd.

Parent Component

lfarm-gss (module).

Public Interface
Internals

4.1.6 lfarm-common/lfarm-common/package.lisp

Source

lfarm-common.asd.

Parent Component

lfarm-common (module).

Packages

4.1.7 lfarm-common/lfarm-common/error.lisp

Dependency

package.lisp (file).

Source

lfarm-common.asd.

Parent Component

lfarm-common (module).

Public Interface
Internals

4.1.8 lfarm-common/lfarm-common/util.lisp

Dependency

error.lisp (file).

Source

lfarm-common.asd.

Parent Component

lfarm-common (module).

Public Interface
Internals

4.1.9 lfarm-common/lfarm-common/unwind-protect.lisp

Dependency

util.lisp (file).

Source

lfarm-common.asd.

Parent Component

lfarm-common (module).

Public Interface
Internals

4.1.10 lfarm-common/lfarm-common/defwith.lisp

Dependency

unwind-protect.lisp (file).

Source

lfarm-common.asd.

Parent Component

lfarm-common (module).

Public Interface
Internals

4.1.11 lfarm-common/lfarm-common/log.lisp

Dependency

defwith.lisp (file).

Source

lfarm-common.asd.

Parent Component

lfarm-common (module).

Public Interface
Internals

4.1.12 lfarm-common/lfarm-common/address.lisp

Dependency

log.lisp (file).

Source

lfarm-common.asd.

Parent Component

lfarm-common (module).

Public Interface
Internals

4.1.13 lfarm-common/lfarm-common/binary-serializer.lisp

Dependency

address.lisp (file).

Source

lfarm-common.asd.

Parent Component

lfarm-common (module).

Public Interface

*element-type* (special variable).

Internals

4.1.14 lfarm-common/lfarm-common/data-transport.lisp

Dependency

binary-serializer.lisp (file).

Source

lfarm-common.asd.

Parent Component

lfarm-common (module).

Public Interface

4.1.15 lfarm-common/lfarm-common/default-data-transport.lisp

Dependency

data-transport.lisp (file).

Source

lfarm-common.asd.

Parent Component

lfarm-common (module).

Public Interface

4.1.16 lfarm-common/lfarm-common/socket.lisp

Dependency

default-data-transport.lisp (file).

Source

lfarm-common.asd.

Parent Component

lfarm-common (module).

Public Interface
Internals

4.1.17 lfarm-common/lfarm-common/object-transport.lisp

Dependency

socket.lisp (file).

Source

lfarm-common.asd.

Parent Component

lfarm-common (module).

Public Interface

5 Packages

Packages are listed by definition order.


5.1 lfarm-gss

Source

packages.lisp.

Use List

common-lisp.

Public Interface
Internals

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

5.2 lfarm-common.data-transport

Source

package.lisp.

Use List

common-lisp.

Used By List

lfarm-common.

Public Interface

5.3 lfarm-common

(private) Common components for lfarm.

Source

package.lisp.

Use List
Public Interface
Internals

6 Definitions

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


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

6.1 Public Interface


6.1.1 Constants

Constant: +corrupt-stream-flag+
Package

lfarm-common.

Source

socket.lisp.


Next: , Previous: , Up: Public Interface   [Contents][Index]

6.1.2 Special variables

Special Variable: *auth*
Package

lfarm-common.

Source

socket.lisp.

Special Variable: *connect-retry-interval*
Package

lfarm-common.

Source

socket.lisp.

Special Variable: *element-type*
Package

lfarm-common.

Source

binary-serializer.lisp.

Special Variable: *log-level*

Set to :error to log only errors; set to :info for verbosity.

Package

lfarm-common.

Source

log.lisp.

Special Variable: *log-stream*

Stream for logging.

Package

lfarm-common.

Source

log.lisp.


6.1.3 Macros

Macro: alias-function (alias orig)
Package

lfarm-common.

Source

util.lisp.

Macro: alias-macro (alias orig)
Package

lfarm-common.

Source

util.lisp.

Macro: bad (&rest args)
Package

lfarm-common.

Source

log.lisp.

Macro: defwith (macro-name lambda-list &body body)

Define a function along with a macro that expands to a call of that function. Inside ‘defwith’ is an flet named ‘call-body’.

(defwith with-foo (value)
(let ((*foo* value))
(call-body)))

is equivalent to

(defun call-with-foo (body-fn value)
(let ((*foo* value))
(funcall body-fn)))

(defmacro with-foo ((value) &body body)
‘(call-with-foo (lambda () ,@body) ,value))

Placing a ‘:vars’ form at the head of the lambda list will generate a macro that assigns to the given variables.

(defwith with-add-result ((:vars result) x y)
(call-body (+ x y)))

is equivalent to

(defun call-with-add-result (body-fn x y)
(funcall body-fn (+ x y)))

(defmacro with-add-result ((result x y) &body body) ‘(call-with-add-result (lambda (,result) ,@body) ,x ,y))

Package

lfarm-common.

Source

defwith.lisp.

Macro: dosequence ((var sequence &optional return) &body body)
Package

lfarm-common.

Source

util.lisp.

Macro: info (&rest args)
Package

lfarm-common.

Source

log.lisp.

Macro: repeat (n &body body)
Package

lfarm-common.

Source

util.lisp.

Macro: unwind-protect/safe (&key prepare main cleanup abort)

Interrupt-safe ‘unwind-protect’.

‘prepare’ : executed first, outside of ‘unwind-protect’ ‘main’ : protected form
‘cleanup’ : cleanup form
‘abort’ : executed if ‘main’ does not finish

Package

lfarm-common.

Source

unwind-protect.lisp.

Macro: unwind-protect/safe-bind (&key bind main cleanup abort)

Bind a variable inside ‘unwind-protect’ with interrupt safety.

Package

lfarm-common.

Source

unwind-protect.lisp.

Macro: with-connected-socket ((socket-var socket-value) &body body23)
Package

lfarm-common.

Source

socket.lisp.

Macro: with-connected-stream ((stream-var socket-value) &body body23)
Package

lfarm-common.

Source

socket.lisp.

Macro: with-each-address ((host port addresses) &body body25)
Package

lfarm-common.

Source

address.lisp.

Macro: with-each-address/handle-error ((host port addresses fn-name) &body body30)
Package

lfarm-common.

Source

address.lisp.

Macro: with-errors-logged (&body body)
Package

lfarm-common.

Source

log.lisp.

Macro: with-lock-predicate/wait (lock predicate &body body)
Package

lfarm-common.

Source

util.lisp.

Macro: with-tag (retry-tag &body body)

For those of us who forget RETURN-FROM inside TAGBODY.

Package

lfarm-common.

Source

util.lisp.

Macro: with-timeout ((timeout) &body body)
Package

lfarm-common.

Source

util.lisp.


6.1.4 Ordinary functions

Function: deserialize-buffer (buffer)
Package

lfarm-common.

Source

object-transport.lisp.

Function: ensure-addresses (addresses)
Package

lfarm-common.

Source

address.lisp.

Function: lambda-list-parameters (lambda-list &key discard-aux)
Package

lfarm-common.

Source

defwith.lisp.

Function: make-task-error-data (err)
Package

lfarm-common.

Source

error.lisp.

Function: receive-object (stream)
Package

lfarm-common.

Source

object-transport.lisp.

Function: receive-serialized-buffer (stream)
Package

lfarm-common.

Source

object-transport.lisp.

Function: send-object (object stream)
Package

lfarm-common.

Source

object-transport.lisp.

Function: serialize-to-buffer (object)
Package

lfarm-common.

Source

object-transport.lisp.

Function: socket-accept (socket)
Package

lfarm-common.

Source

socket.lisp.

Function: socket-close (socket)
Package

lfarm-common.

Source

socket.lisp.

Function: socket-connect (host port)
Package

lfarm-common.

Source

socket.lisp.

Function: socket-connect/retry (host port &key timeout)
Package

lfarm-common.

Source

socket.lisp.

Function: socket-listen (host port)
Package

lfarm-common.

Source

socket.lisp.

Reader: task-error-data-desc (instance)
Writer: (setf task-error-data-desc) (instance)
Package

lfarm-common.

Source

error.lisp.

Target Slot

desc.

Reader: task-error-data-report (instance)
Writer: (setf task-error-data-report) (instance)
Package

lfarm-common.

Source

error.lisp.

Target Slot

report.

Function: unsplice (form)
Package

lfarm-common.

Source

defwith.lisp.

Function: wait-for-input (socket &key timeout)
Package

lfarm-common.

Source

socket.lisp.


6.1.5 Generic functions

Generic Function: initialize-client-stream (auth stream server-name)

Initialize a client-side stream connected to server named ‘server-name’. Return a new stream or the same stream.

Package

lfarm-common.data-transport.

Source

data-transport.lisp.

Methods
Method: initialize-client-stream ((auth gss-auth-client) stream server-name)
Source

lfarm-gss.lisp.

Method: initialize-client-stream (auth stream server-name)
Generic Function: initialize-server-stream (auth stream)

Initialize a server-side stream. Return a new stream or the same stream.

Package

lfarm-common.data-transport.

Source

data-transport.lisp.

Methods
Method: initialize-server-stream ((auth gss-auth-server) stream)
Source

lfarm-gss.lisp.

Method: initialize-server-stream (auth stream)
Generic Function: receive-buffer (auth stream)

Receive a (unsigned-byte 8) vector from a stream.

Package

lfarm-common.data-transport.

Source

data-transport.lisp.

Methods
Method: receive-buffer ((auth gss-auth-mixin) stream)
Source

lfarm-gss.lisp.

Method: receive-buffer (auth stream)
Source

default-data-transport.lisp.

Generic Function: send-buffer (auth buffer stream)

Send a (unsigned-byte 8) vector over a stream.

Package

lfarm-common.data-transport.

Source

data-transport.lisp.

Methods
Method: send-buffer ((auth gss-auth-mixin) buffer stream)
Source

lfarm-gss.lisp.

Method: send-buffer (auth buffer stream)
Source

default-data-transport.lisp.

Generic Reader: socket-stream (object)
Package

lfarm-common.

Methods
Reader Method: socket-stream ((streaming-socket streaming-socket))

automatically generated reader method

Source

socket.lisp.

Target Slot

stream.

Generic Function: stream-close (auth stream)

Callback for when the stream is closed.

Package

lfarm-common.data-transport.

Source

data-transport.lisp.

Methods
Method: stream-close (auth stream)

6.1.6 Standalone methods

Method: initialize-instance :after ((stream wrapper-stream) &key &allow-other-keys)
Source

lfarm-gss.lisp.

Method: stream-finish-output ((stream wrapper-stream))
Package

sb-gray.

Source

wrapper-stream.lisp.

Method: stream-force-output ((stream wrapper-stream))
Package

sb-gray.

Source

wrapper-stream.lisp.

Method: stream-read-byte ((stream wrapper-stream))
Package

sb-gray.

Source

wrapper-stream.lisp.

Method: stream-read-sequence ((stream wrapper-stream) seq start end &key)
Package

trivial-gray-streams.

Source

wrapper-stream.lisp.

Method: stream-write-byte ((stream wrapper-stream) char)
Package

sb-gray.

Source

wrapper-stream.lisp.

Method: stream-write-sequence ((stream wrapper-stream) seq start end &key)
Package

trivial-gray-streams.

Source

wrapper-stream.lisp.


6.1.7 Conditions

Condition: auth-error

Raise this error or a subclass thereof when auth fails.

Package

lfarm-common.data-transport.

Source

data-transport.lisp.

Direct superclasses

error.

Condition: corrupted-stream-error
Package

lfarm-common.

Source

error.lisp.

Direct superclasses

stream-error.


Next: , Previous: , Up: Public Interface   [Contents][Index]

6.1.8 Structures

Structure: task-error-data
Package

lfarm-common.

Source

error.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: report
Type

string

Readers

task-error-data-report.

Writers

(setf task-error-data-report).

Slot: desc
Type

string

Readers

task-error-data-desc.

Writers

(setf task-error-data-desc).


Previous: , Up: Public Interface   [Contents][Index]

6.1.9 Classes

Class: gss-auth-client
Package

lfarm-gss.

Source

lfarm-gss.lisp.

Direct superclasses

gss-auth-mixin.

Direct methods
Direct slots
Slot: service-name
Type

string

Initform

"lfarm"

Initargs

:service-name

Readers

gss-auth-service-name.

Writers

This slot is read-only.

Class: gss-auth-server
Package

lfarm-gss.

Source

lfarm-gss.lisp.

Direct superclasses

gss-auth-mixin.

Direct methods
Direct slots
Slot: allowed-users
Type

list

Initargs

:allowed-users

Readers

gss-auth-allowed-users.

Writers

(setf gss-auth-allowed-users).

Class: wrapper-stream
Package

lfarm-gss.

Source

wrapper-stream.lisp.

Direct superclasses
  • fundamental-binary-input-stream.
  • fundamental-binary-output-stream.
  • trivial-gray-stream-mixin.
Direct methods
Direct slots
Slot: delegate
Initform

(error "~s is a required argument for class ~s" :delegate (quote lfarm-gss:wrapper-stream))

Initargs

:delegate

Readers

wrapper-stream-delegate.

Writers

This slot is read-only.

Slot: context
Initform

(error "~s is a required argument for class ~s" :context (quote lfarm-gss:wrapper-stream))

Initargs

:context

Readers

wrapper-stream-context.

Writers

This slot is read-only.

Slot: description
Type

string

Initform

""

Initargs

:description

Readers

wrapper-stream-description.

Writers

This slot is read-only.


6.2 Internals


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

6.2.1 Special variables

Special Variable: *log-lock*
Package

lfarm-common.

Source

log.lisp.


6.2.2 Macros

Macro: define-with-fn (macro-name fn-name lambda-list declares body)
Package

lfarm-common.

Source

defwith.lisp.

Macro: define-with-macro (macro-name fn-name lambda-list vars doc)
Package

lfarm-common.

Source

defwith.lisp.

Macro: flet-alias ((name fn) &body body)
Package

lfarm-common.

Source

defwith.lisp.

Macro: with-interrupts (&body body)
Package

lfarm-common.

Source

unwind-protect.lisp.

Macro: without-interrupts (&body body)
Package

lfarm-common.

Source

unwind-protect.lisp.


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

6.2.3 Ordinary functions

Function: %make-task-error-data (&key report desc)
Package

lfarm-common.

Source

error.lisp.

Function: %socket-connect/retry (host port timeout)
Package

lfarm-common.

Source

socket.lisp.

Function: backend-deserialize (stream)
Package

lfarm-common.

Source

binary-serializer.lisp.

Function: backend-serialize (object stream)
Package

lfarm-common.

Source

binary-serializer.lisp.

Function: bad-address (thing)
Package

lfarm-common.

Source

address.lisp.

Function: call-with-connected-socket (body-fn0 socket-value)
Package

lfarm-common.

Source

socket.lisp.

Function: call-with-connected-stream (body-fn0 socket-value)
Package

lfarm-common.

Source

socket.lisp.

Function: call-with-each-address (body-fn0 addresses)
Package

lfarm-common.

Source

address.lisp.

Function: call-with-each-address/handle-error (body-fn0 addresses fn-name)
Package

lfarm-common.

Source

address.lisp.

Function: copy-task-error-data (instance)
Package

lfarm-common.

Source

error.lisp.

Function: ensure-address (address)
Package

lfarm-common.

Source

address.lisp.

Function: expiredp (start timeout)
Package

lfarm-common.

Source

util.lisp.

Function: get-time ()
Package

lfarm-common.

Source

util.lisp.

Function: make-socket (usocket)
Package

lfarm-common.

Source

socket.lisp.

Function: make-streaming-client-socket (usocket server-name)
Package

lfarm-common.

Source

socket.lisp.

Function: make-streaming-server-socket (usocket)
Package

lfarm-common.

Source

socket.lisp.

Function: make-streaming-socket (init-fn usocket &rest args)
Package

lfarm-common.

Source

socket.lisp.

Function: read-with-length (stream &key length)
Package

lfarm-gss.

Source

lfarm-gss.lisp.

Function: strip-aux (lambda-list)
Package

lfarm-common.

Source

defwith.lisp.

Function: task-error-data-p (object)
Package

lfarm-common.

Source

error.lisp.

Function: timestamp ()
Package

lfarm-common.

Source

log.lisp.

Function: translate-error (err)
Package

lfarm-common.

Source

binary-serializer.lisp.

Function: write-log (level package &rest args)
Package

lfarm-common.

Source

log.lisp.

Function: write-with-length (buffer stream &key length)
Package

lfarm-gss.

Source

lfarm-gss.lisp.


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

6.2.4 Generic functions

Generic Reader: gss-auth-allowed-users (object)
Package

lfarm-gss.

Methods
Reader Method: gss-auth-allowed-users ((gss-auth-server gss-auth-server))

automatically generated reader method

Source

lfarm-gss.lisp.

Target Slot

allowed-users.

Generic Writer: (setf gss-auth-allowed-users) (object)
Package

lfarm-gss.

Methods
Writer Method: (setf gss-auth-allowed-users) ((gss-auth-server gss-auth-server))

automatically generated writer method

Source

lfarm-gss.lisp.

Target Slot

allowed-users.

Generic Reader: gss-auth-service-name (object)
Package

lfarm-gss.

Methods
Reader Method: gss-auth-service-name ((gss-auth-client gss-auth-client))

automatically generated reader method

Source

lfarm-gss.lisp.

Target Slot

service-name.

Generic Function: name-accepted (auth name)
Package

lfarm-gss.

Source

lfarm-gss.lisp.

Methods
Method: name-accepted ((auth gss-auth-server) name)
Generic Reader: usocket (object)
Package

lfarm-common.

Methods
Reader Method: usocket ((socket socket))

automatically generated reader method

Source

socket.lisp.

Target Slot

usocket.

Generic Reader: wrapper-stream-context (object)
Package

lfarm-gss.

Methods
Reader Method: wrapper-stream-context ((wrapper-stream wrapper-stream))

automatically generated reader method

Source

wrapper-stream.lisp.

Target Slot

context.

Generic Reader: wrapper-stream-delegate (object)
Package

lfarm-gss.

Methods
Reader Method: wrapper-stream-delegate ((wrapper-stream wrapper-stream))

automatically generated reader method

Source

wrapper-stream.lisp.

Target Slot

delegate.

Generic Reader: wrapper-stream-description (object)
Package

lfarm-gss.

Methods
Reader Method: wrapper-stream-description ((wrapper-stream wrapper-stream))

automatically generated reader method

Source

wrapper-stream.lisp.

Target Slot

description.


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

6.2.5 Classes

Class: gss-auth-mixin
Package

lfarm-gss.

Source

lfarm-gss.lisp.

Direct subclasses
Direct methods
Class: socket
Package

lfarm-common.

Source

socket.lisp.

Direct subclasses

streaming-socket.

Direct methods

usocket.

Direct slots
Slot: usocket
Initargs

:usocket

Readers

usocket.

Writers

This slot is read-only.

Class: streaming-socket
Package

lfarm-common.

Source

socket.lisp.

Direct superclasses

socket.

Direct methods

socket-stream.

Direct slots
Slot: stream
Package

common-lisp.

Initargs

:stream

Readers

socket-stream.

Writers

This slot is read-only.


Appendix A Indexes


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

A.1 Concepts


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

A.2 Functions

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

%
%make-task-error-data: Private ordinary functions
%socket-connect/retry: Private ordinary functions

(
(setf gss-auth-allowed-users): Private generic functions
(setf gss-auth-allowed-users): Private generic functions
(setf task-error-data-desc): Public ordinary functions
(setf task-error-data-report): Public ordinary functions

A
alias-function: Public macros
alias-macro: Public macros

B
backend-deserialize: Private ordinary functions
backend-serialize: Private ordinary functions
bad: Public macros
bad-address: Private ordinary functions

C
call-with-connected-socket: Private ordinary functions
call-with-connected-stream: Private ordinary functions
call-with-each-address: Private ordinary functions
call-with-each-address/handle-error: Private ordinary functions
copy-task-error-data: Private ordinary functions

D
define-with-fn: Private macros
define-with-macro: Private macros
defwith: Public macros
deserialize-buffer: Public ordinary functions
dosequence: Public macros

E
ensure-address: Private ordinary functions
ensure-addresses: Public ordinary functions
expiredp: Private ordinary functions

F
flet-alias: Private macros
Function, %make-task-error-data: Private ordinary functions
Function, %socket-connect/retry: Private ordinary functions
Function, (setf task-error-data-desc): Public ordinary functions
Function, (setf task-error-data-report): Public ordinary functions
Function, backend-deserialize: Private ordinary functions
Function, backend-serialize: Private ordinary functions
Function, bad-address: Private ordinary functions
Function, call-with-connected-socket: Private ordinary functions
Function, call-with-connected-stream: Private ordinary functions
Function, call-with-each-address: Private ordinary functions
Function, call-with-each-address/handle-error: Private ordinary functions
Function, copy-task-error-data: Private ordinary functions
Function, deserialize-buffer: Public ordinary functions
Function, ensure-address: Private ordinary functions
Function, ensure-addresses: Public ordinary functions
Function, expiredp: Private ordinary functions
Function, get-time: Private ordinary functions
Function, lambda-list-parameters: Public ordinary functions
Function, make-socket: Private ordinary functions
Function, make-streaming-client-socket: Private ordinary functions
Function, make-streaming-server-socket: Private ordinary functions
Function, make-streaming-socket: Private ordinary functions
Function, make-task-error-data: Public ordinary functions
Function, read-with-length: Private ordinary functions
Function, receive-object: Public ordinary functions
Function, receive-serialized-buffer: Public ordinary functions
Function, send-object: Public ordinary functions
Function, serialize-to-buffer: Public ordinary functions
Function, socket-accept: Public ordinary functions
Function, socket-close: Public ordinary functions
Function, socket-connect: Public ordinary functions
Function, socket-connect/retry: Public ordinary functions
Function, socket-listen: Public ordinary functions
Function, strip-aux: Private ordinary functions
Function, task-error-data-desc: Public ordinary functions
Function, task-error-data-p: Private ordinary functions
Function, task-error-data-report: Public ordinary functions
Function, timestamp: Private ordinary functions
Function, translate-error: Private ordinary functions
Function, unsplice: Public ordinary functions
Function, wait-for-input: Public ordinary functions
Function, write-log: Private ordinary functions
Function, write-with-length: Private ordinary functions

G
Generic Function, (setf gss-auth-allowed-users): Private generic functions
Generic Function, gss-auth-allowed-users: Private generic functions
Generic Function, gss-auth-service-name: Private generic functions
Generic Function, initialize-client-stream: Public generic functions
Generic Function, initialize-server-stream: Public generic functions
Generic Function, name-accepted: Private generic functions
Generic Function, receive-buffer: Public generic functions
Generic Function, send-buffer: Public generic functions
Generic Function, socket-stream: Public generic functions
Generic Function, stream-close: Public generic functions
Generic Function, usocket: Private generic functions
Generic Function, wrapper-stream-context: Private generic functions
Generic Function, wrapper-stream-delegate: Private generic functions
Generic Function, wrapper-stream-description: Private generic functions
get-time: Private ordinary functions
gss-auth-allowed-users: Private generic functions
gss-auth-allowed-users: Private generic functions
gss-auth-service-name: Private generic functions
gss-auth-service-name: Private generic functions

I
info: Public macros
initialize-client-stream: Public generic functions
initialize-client-stream: Public generic functions
initialize-client-stream: Public generic functions
initialize-instance: Public standalone methods
initialize-server-stream: Public generic functions
initialize-server-stream: Public generic functions
initialize-server-stream: Public generic functions

L
lambda-list-parameters: Public ordinary functions

M
Macro, alias-function: Public macros
Macro, alias-macro: Public macros
Macro, bad: Public macros
Macro, define-with-fn: Private macros
Macro, define-with-macro: Private macros
Macro, defwith: Public macros
Macro, dosequence: Public macros
Macro, flet-alias: Private macros
Macro, info: Public macros
Macro, repeat: Public macros
Macro, unwind-protect/safe: Public macros
Macro, unwind-protect/safe-bind: Public macros
Macro, with-connected-socket: Public macros
Macro, with-connected-stream: Public macros
Macro, with-each-address: Public macros
Macro, with-each-address/handle-error: Public macros
Macro, with-errors-logged: Public macros
Macro, with-interrupts: Private macros
Macro, with-lock-predicate/wait: Public macros
Macro, with-tag: Public macros
Macro, with-timeout: Public macros
Macro, without-interrupts: Private macros
make-socket: Private ordinary functions
make-streaming-client-socket: Private ordinary functions
make-streaming-server-socket: Private ordinary functions
make-streaming-socket: Private ordinary functions
make-task-error-data: Public ordinary functions
Method, (setf gss-auth-allowed-users): Private generic functions
Method, gss-auth-allowed-users: Private generic functions
Method, gss-auth-service-name: Private generic functions
Method, initialize-client-stream: Public generic functions
Method, initialize-client-stream: Public generic functions
Method, initialize-instance: Public standalone methods
Method, initialize-server-stream: Public generic functions
Method, initialize-server-stream: Public generic functions
Method, name-accepted: Private generic functions
Method, receive-buffer: Public generic functions
Method, receive-buffer: Public generic functions
Method, send-buffer: Public generic functions
Method, send-buffer: Public generic functions
Method, socket-stream: Public generic functions
Method, stream-close: Public generic functions
Method, stream-finish-output: Public standalone methods
Method, stream-force-output: Public standalone methods
Method, stream-read-byte: Public standalone methods
Method, stream-read-sequence: Public standalone methods
Method, stream-write-byte: Public standalone methods
Method, stream-write-sequence: Public standalone methods
Method, usocket: Private generic functions
Method, wrapper-stream-context: Private generic functions
Method, wrapper-stream-delegate: Private generic functions
Method, wrapper-stream-description: Private generic functions

N
name-accepted: Private generic functions
name-accepted: Private generic functions

R
read-with-length: Private ordinary functions
receive-buffer: Public generic functions
receive-buffer: Public generic functions
receive-buffer: Public generic functions
receive-object: Public ordinary functions
receive-serialized-buffer: Public ordinary functions
repeat: Public macros

S
send-buffer: Public generic functions
send-buffer: Public generic functions
send-buffer: Public generic functions
send-object: Public ordinary functions
serialize-to-buffer: Public ordinary functions
socket-accept: Public ordinary functions
socket-close: Public ordinary functions
socket-connect: Public ordinary functions
socket-connect/retry: Public ordinary functions
socket-listen: Public ordinary functions
socket-stream: Public generic functions
socket-stream: Public generic functions
stream-close: Public generic functions
stream-close: Public generic functions
stream-finish-output: Public standalone methods
stream-force-output: Public standalone methods
stream-read-byte: Public standalone methods
stream-read-sequence: Public standalone methods
stream-write-byte: Public standalone methods
stream-write-sequence: Public standalone methods
strip-aux: Private ordinary functions

T
task-error-data-desc: Public ordinary functions
task-error-data-p: Private ordinary functions
task-error-data-report: Public ordinary functions
timestamp: Private ordinary functions
translate-error: Private ordinary functions

U
unsplice: Public ordinary functions
unwind-protect/safe: Public macros
unwind-protect/safe-bind: Public macros
usocket: Private generic functions
usocket: Private generic functions

W
wait-for-input: Public ordinary functions
with-connected-socket: Public macros
with-connected-stream: Public macros
with-each-address: Public macros
with-each-address/handle-error: Public macros
with-errors-logged: Public macros
with-interrupts: Private macros
with-lock-predicate/wait: Public macros
with-tag: Public macros
with-timeout: Public macros
without-interrupts: Private macros
wrapper-stream-context: Private generic functions
wrapper-stream-context: Private generic functions
wrapper-stream-delegate: Private generic functions
wrapper-stream-delegate: Private generic functions
wrapper-stream-description: Private generic functions
wrapper-stream-description: Private generic functions
write-log: Private ordinary functions
write-with-length: Private ordinary functions

Jump to:   %   (  
A   B   C   D   E   F   G   I   L   M   N   R   S   T   U   W  

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

A.4 Data types

Jump to:   A   B   C   D   E   F   G   L   M   O   P   S   T   U   W  
Index Entry  Section

A
address.lisp: The lfarm-common/lfarm-common/address․lisp file
auth-error: Public conditions

B
binary-serializer.lisp: The lfarm-common/lfarm-common/binary-serializer․lisp file

C
Class, gss-auth-client: Public classes
Class, gss-auth-mixin: Private classes
Class, gss-auth-server: Public classes
Class, socket: Private classes
Class, streaming-socket: Private classes
Class, wrapper-stream: Public classes
Condition, auth-error: Public conditions
Condition, corrupted-stream-error: Public conditions
corrupted-stream-error: Public conditions

D
data-transport.lisp: The lfarm-common/lfarm-common/data-transport․lisp file
default-data-transport.lisp: The lfarm-common/lfarm-common/default-data-transport․lisp file
defwith.lisp: The lfarm-common/lfarm-common/defwith․lisp file

E
error.lisp: The lfarm-common/lfarm-common/error․lisp file

F
File, address.lisp: The lfarm-common/lfarm-common/address․lisp file
File, binary-serializer.lisp: The lfarm-common/lfarm-common/binary-serializer․lisp file
File, data-transport.lisp: The lfarm-common/lfarm-common/data-transport․lisp file
File, default-data-transport.lisp: The lfarm-common/lfarm-common/default-data-transport․lisp file
File, defwith.lisp: The lfarm-common/lfarm-common/defwith․lisp file
File, error.lisp: The lfarm-common/lfarm-common/error․lisp file
File, lfarm-common.asd: The lfarm-common/lfarm-common․asd file
File, lfarm-gss.asd: The lfarm-gss/lfarm-gss․asd file
File, lfarm-gss.lisp: The lfarm-gss/lfarm-gss/lfarm-gss․lisp file
File, log.lisp: The lfarm-common/lfarm-common/log․lisp file
File, object-transport.lisp: The lfarm-common/lfarm-common/object-transport․lisp file
File, package.lisp: The lfarm-common/lfarm-common/package․lisp file
File, packages.lisp: The lfarm-gss/lfarm-gss/packages․lisp file
File, socket.lisp: The lfarm-common/lfarm-common/socket․lisp file
File, unwind-protect.lisp: The lfarm-common/lfarm-common/unwind-protect․lisp file
File, util.lisp: The lfarm-common/lfarm-common/util․lisp file
File, wrapper-stream.lisp: The lfarm-gss/lfarm-gss/wrapper-stream․lisp file

G
gss-auth-client: Public classes
gss-auth-mixin: Private classes
gss-auth-server: Public classes

L
lfarm-common: The lfarm-common system
lfarm-common: The lfarm-common/lfarm-common module
lfarm-common: The lfarm-common package
lfarm-common.asd: The lfarm-common/lfarm-common․asd file
lfarm-common.data-transport: The lfarm-common․data-transport package
lfarm-gss: The lfarm-gss system
lfarm-gss: The lfarm-gss/lfarm-gss module
lfarm-gss: The lfarm-gss package
lfarm-gss.asd: The lfarm-gss/lfarm-gss․asd file
lfarm-gss.lisp: The lfarm-gss/lfarm-gss/lfarm-gss․lisp file
log.lisp: The lfarm-common/lfarm-common/log․lisp file

M
Module, lfarm-common: The lfarm-common/lfarm-common module
Module, lfarm-gss: The lfarm-gss/lfarm-gss module

O
object-transport.lisp: The lfarm-common/lfarm-common/object-transport․lisp file

P
Package, lfarm-common: The lfarm-common package
Package, lfarm-common.data-transport: The lfarm-common․data-transport package
Package, lfarm-gss: The lfarm-gss package
package.lisp: The lfarm-common/lfarm-common/package․lisp file
packages.lisp: The lfarm-gss/lfarm-gss/packages․lisp file

S
socket: Private classes
socket.lisp: The lfarm-common/lfarm-common/socket․lisp file
streaming-socket: Private classes
Structure, task-error-data: Public structures
System, lfarm-common: The lfarm-common system
System, lfarm-gss: The lfarm-gss system

T
task-error-data: Public structures

U
unwind-protect.lisp: The lfarm-common/lfarm-common/unwind-protect․lisp file
util.lisp: The lfarm-common/lfarm-common/util․lisp file

W
wrapper-stream: Public classes
wrapper-stream.lisp: The lfarm-gss/lfarm-gss/wrapper-stream․lisp file

Jump to:   A   B   C   D   E   F   G   L   M   O   P   S   T   U   W