The cl-disque Reference Manual

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

The cl-disque Reference Manual

This is the cl-disque Reference Manual, version 0.0.1, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Aug 15 03:36:08 2022 GMT+0.

Table of Contents


1 Introduction

#+TITLE: CL-DISQUE
#+AUTHOR: Cody Reichert
#+EMAIL: codyreichert@gmail.com

A [[https://github.com/antirez/disque][Disque]] client for Common Lisp.

Disque is an in-memory job queue and message broker. It's distributed
and fault-tolerant so it works as a middle layer among processes that
want to exchange messages.

Learn more about message queues [[https://github.com/antirez/disque#what-is-a-message-queue][here]], and more about the Disque
implementation [[https://github.com/antirez/disque#give-me-the-details][here]].

cl-disque provides a client for working with Disque through sending
and receiving jobs and commands.

* Usage
** Quickstart
   First, make sure a Disque server is running.

   Load cl-disque and connect to the Disque server on the given host and port:

   #+BEGIN_SRC lisp
     (ql:quickload 'cl-disque)

     ; host defaults to 127.0.0.1, port defaults to 7711
     (cl-disque:connect :host  :port )
   #+END_SRC

   You can interact with the server using commands from the =disque= package.

   #+BEGIN_SRC lisp
   (disque:hello)
   ;=> (1 "node-id"
   ;    ("node-ids" "host" "7711" "1"))
   #+END_SRC

   Disconnect from the Disque server with:

   #+BEGIN_SRC lisp
   (cl-disque:disconnect)
   #+END_SRC

   Alternatively, you can wrap all interactions in the
   =with-connection= macro, which creates a new connection to
   execute the given body, and assures a disconnect afterwards:

   #+BEGIN_SRC lisp
   (cl-disque:with-connection ()
     (disque:addjob "queue" "job" 0)
     (disque:getjob "queue" 1))
   ;=> (("queue" "job-hash" "job"))
   #+END_SRC

   The Makefile offers a couple of commands for running the test-suite
   and loading cl-disque into an SBCL repl:

   #+BEGIN_SRC sh
   # To run the test suite
   $ make test
   #+END_SRC

   #+BEGIN_SRC sh
   # To load an SBCL repl
   $ make sbcl-repl
   #+END_SRC

** Available commands
   Cl-Disque supports all of the Disque client commands and their
   arguments. See [[https://github.com/antirez/disque][The Disque Documentation]] for more specifics on each
   command

*** INFO
    - Args: ()
    - Response-type: :bulk

*** HELLO
    - Args: ()
    - Response-type: :multi

*** QLEN
    - Args: (queue)
    - Response-type: :integer

*** QPEEK
    - Args: (queue count)
    - Response-type: :multi

*** QSCAN
    - Args: (&rest args &key count busyloop minlen maxlen importrate)
    - Response-type: :multi

*** GETJOB
    - Args: (queues &rest args &key nohang timeout count withcounters)
    - Reponse-type: :multi

    /Note: queues can either be a single queue or a list of queues:/

    #+BEGIN_SRC lisp
    (disque:getjob "queue1")
    ;; or
    (disque:getjob '("queue1" "queue2" "queue3")
    #+END_SRC

*** ADDJOB
    - Args: (queue job timeout &rest args &key replicate delay retry ttl
    maxlen async)
    - Response-type: :status

*** ACKJOB
    - Args: (job &rest jobs)
    - Response-type: :integer

*** FASTACK
    - Args: (job &rest jobs)
    - Response-type: :integer

*** WORKING
    - Args: (job)
    - Response-type: :integer

*** NACK
    - Args: (job &rest jobs)
    - Response-type: :integer

*** ENQUEUE
    - Args: (job &rest jobs)
    - Reponse-type: :integer

*** DEQUEUE
    - Args: (job &rest jobs)
    - Response-type :integer

*** DELJOB
    - Args: (job &rest jobs)
    - Response-type: :integer

*** SHOW
    - Args: (job)
    - Response-type: :multi

*** JSCAN
    - Args: (cursor &rest args &key count blocking queue state reply)
    - Response-type: :multi

** Code organization
   The system provides two packages: =CL-DISQUE= and =DISQUE=.

   Everything is available in the =CL-DISQUE= package.

   The =DISQUE= package contains all of the commands for interacting
   with a Disque server. This is simply syntactic sugar, as all of the
   commands are /also/ available in the =CL-DISQUE= package with a
   command prefix. For Example:

   #+BEGIN_SRC lisp
   (disque:info)
   ; is the same as
   (cl-disque:disque-info)
   #+END_SRC

** Installation

Git clone this repo into your =~/quicklisp/local-projects/= directory,
and =(ql:quickload :cl-disque)=.

** Dependencies

- [[http://common-lisp.net/project/usocket/][usocket]]
- [[http://common-lisp.net/project/flexi-streams/][flexi-streams]]
- [[http://github.com/vseloved/rutils][rutils]]
- [[http://github.com/fukamachi/prove][prove]] (only for tests)

** Debugging and error recovery

If =*echo-p*= is =T=, all client-server communications will be
echoed to the stream =*echo-stream*=, which defaults to =*standard-output*=.

Error handling is mimicked after [[http://common-lisp.net/project/postmodern/][Postmodern]]. In particular, whenever
an error occurs that breaks the communication stream, a condition of
type =disque-connection-error= is signalled offering a =:reconnect=
restart.  If it is selected the whole Disque command will be resent, if
the reconnection attempt succeeds.  Furthermore, =connect= checks if a
connection to Disque is already established, and offers two restarts
(=:leave= and =:replace=) if this is the case.

When the server respondes with an error reply a condition of type
=disque-error-reply= is signalled.

There's also a high-level =with-persistent-connection= macro, that
tries to do the right thing™ (i.e. automatically reopen the connection
once, if it is broken).

** Advanced usage
*** Pipelining

For better performance Disque allows to pipeline commands and delay
receiving results until the end, and process them all in oine batch
afterwards.  To support that there's =with-pipelining= macro.

Note, that =with-pipelining= calls theoretically may nest, but the
results will only be available to the highest-level pipeline, all the
nested pipelines will return :PIPELINED.  So a warining is signalled
in this situation.

*Note: Pipelining has not been tested since being ported form cl-redis.*

** Credits

Cody Reichert  is the maintainer of =CL-DISQUE=.

=CL-DISQUE= is a ported of the [[http://github.com/vseloved/cl-redis][CL-REDIS]] client, which is developed and
maintained by Vsevolod Dyomkin . Many thanks to
him for implementing the protocol and providing most of the internals.

Alexandr Manzyuk  also contributed to
=CL-REDIS= client and developed the connection handling code following
the implementation in [[http://common-lisp.net/project/postmodern/][Postmodern]]. It was since partially rewritten to
accommodate more advanced connection handling strategies, like
persistent connection.

** License

MIT (See LICENSE file for details).


2 Systems

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


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

2.1 cl-disque

A Disque client for Common Lisp

Maintainer

Cody Reichert <codyreichert@gmail.com>

Author

Cody Reichert <codyreichert@gmail.com>

License

MIT

Version

0.0.1

Dependencies
  • rutils (system).
  • cl-ppcre (system).
  • usocket (system).
  • flexi-streams (system).
  • babel (system).
Source

cl-disque.asd.

Child Component

src (module).


3 Modules

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


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

3.1 cl-disque/src

Source

cl-disque.asd.

Parent Component

cl-disque (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 cl-disque/cl-disque.asd

Source

cl-disque.asd.

Parent Component

cl-disque (system).

ASDF Systems

cl-disque.


4.1.2 cl-disque/src/package.lisp

Source

cl-disque.asd.

Parent Component

src (module).

Packages

4.1.3 cl-disque/src/float.lisp

Source

cl-disque.asd.

Parent Component

src (module).

Internals

4.1.4 cl-disque/src/connection.lisp

Source

cl-disque.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.5 cl-disque/src/cl-disque.lisp

Source

cl-disque.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.6 cl-disque/src/commands.lisp

Source

cl-disque.asd.

Parent Component

src (module).

Public Interface
Internals

5 Packages

Packages are listed by definition order.


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

5.1 cl-disque

Source

package.lisp.

Use List
  • common-lisp.
  • rtl.
Public Interface
Internals

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

5.2 disque

Source

package.lisp.


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


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

6.1.1 Special variables

Special Variable: *cmd-prefix*

Prefix for functions names that implement Disque commands.

Package

cl-disque.

Source

cl-disque.lisp.

Special Variable: *connection*

The current Disque connection.

Package

cl-disque.

Source

connection.lisp.

Special Variable: *echo-p*

Whether the server-client communication should be echoed to the stream specified by *ECHO-STREAM*. The default is NIL, meaning no echoing.

Package

cl-disque.

Source

connection.lisp.

Special Variable: *echo-stream*

A stream to which the server-client communication will be echoed for debugging purposes. The default is *STANDARD-OUTPUT*.

Package

cl-disque.

Source

connection.lisp.


6.1.2 Macros

Macro: def-cmd (cmd (&rest args) reply-type docstring)

Define and export a function with the name <*CMD-REDIX*>-<CMD> for processing a Disque command CMD. Here REPLY-TYPE is the expected reply format.

Package

cl-disque.

Source

cl-disque.lisp.

Macro: def-expect-method (type &body body)

Define a specialized EXPECT method. BODY may refer to the ~ variable REPLY, which is bound to the reply received from Disque ~ server with the first character removed.

Package

cl-disque.

Source

cl-disque.lisp.

Macro: with-connection ((&key host port auth) &body body)

Evaluate BODY with the current connection bound to a new connection specified by the given HOST and PORT

Package

cl-disque.

Source

connection.lisp.

Macro: with-persistent-connection ((&key host port auth) &body body)

Execute BODY inside WITH-CONNECTION. But if connection is broken due to DISQUE-CONNECTION-ERROR (a network error or timeout), transparently reopen it.

Package

cl-disque.

Source

connection.lisp.

Macro: with-pipelining (&body body)

Delay execution of EXPECT’s inside BODY to the end, so that all commands are first sent to the server and then their output is received and collected into a list. So commands return :PIPELINED instead of the expected results.

Package

cl-disque.

Source

cl-disque.lisp.

Macro: with-recursive-connection ((&key host port auth) &body body)

Execute BODY with *CONNECTION* bound to the default Disque connection. If connection is already established, reuse it.

Package

cl-disque.

Source

connection.lisp.


6.1.3 Ordinary functions

Function: close-connection (conn)

Close the socket of CONN.

Package

cl-disque.

Source

connection.lisp.

Function: connect (&key host port auth)

Connect to Disque server.

Package

cl-disque.

Source

connection.lisp.

Function: connected-p ()

Is there a current connection?

Package

cl-disque.

Source

connection.lisp.

Function: disconnect ()

Disconnect from Disque server.

Package

cl-disque.

Source

connection.lisp.

Function: disque-ackjob (job &rest jobs)

Acknowledges the execution of one or more jobs via jobs IDs. The node receiving the ACK will replicate it to multiple nodes and will try to garbage collect both the job and the ACKs from the cluster so that memory can be freed.

Package

cl-disque.

Alias for

ackjob.

Function: disque-addjob (queue job timeout &rest args &key replicate delay retry ttl maxlen async)

Adds a job to the specified queue.

Package

cl-disque.

Alias for

addjob.

Function: disque-deljob (job &rest jobs)

Completely delete a job from a node. Note that this is similar to FASTACK, but limited to a single node since no DELJOB cluster bus message is sent to other nodes.

Package

cl-disque.

Alias for

deljob.

Function: disque-dequeue (job &rest jobs)

Remove jobs from the queue.

Package

cl-disque.

Alias for

dequeue.

Function: disque-enqueue (job &rest jobs)

Queue jobs if not already queued.

Package

cl-disque.

Alias for

enqueue.

Function: disque-fastack (job &rest jobs)

Acknowledges the execution of one or more jobs via jobs IDs. The node receiving the ACK will replicate it to multiple nodes and will try to garbage collect both the job and the ACKs from the cluster so that memory can be freed.

Package

cl-disque.

Alias for

fastack.

Function: disque-getjob (queues &rest args &key nohang timeout count withcounters)

Gets a job from the specific queue.

Package

cl-disque.

Alias for

getjob.

Function: disque-hello ()

Returns hello format version, this node ID, all the nodes IDs, IP addresses, ports, and priority (lower is better, means node more available). Clients should use this as an handshake command when connecting with a Disque node.

Package

cl-disque.

Alias for

hello.

Function: disque-info ()

Generic server information / stats.

Package

cl-disque.

Alias for

info.

Function: disque-jscan (cursor &rest args &key count blocking queue state reply)

JSCAN provides an interface to iterate all the existing jobs in the local node, providing a cursor in the form of an integer that is passed to the next command invocation. During the first call the cursor must be 0, in the next calls the cursor returned in the previous call is used next. The iterator guarantees to return all elements but may return duplicates.

Package

cl-disque.

Alias for

jscan.

Function: disque-nack (job &rest jobs)

The NACK command tells Disque to put back the job in the queue ASAP. It is very similar to ENQUEUE but it increments the job nacks counter instead of the additional-deliveries counter. The command should be used when the worker was not able to process a message and wants the message to be put back into the queue in order to be processed again.

Package

cl-disque.

Alias for

nack.

Function: disque-qlen (queue)

Returns the length of the queue.

Package

cl-disque.

Alias for

qlen.

Function: disque-qpeek (queue count)

Return, without consuming from queue, count jobs. If count is positive the specified number of jobs are returned from the oldest to the newest (in the same best-effort FIFO order as GETJOB). If count is negative the commands changes behavior and shows the count newest jobs, from the newest from the oldest.

Package

cl-disque.

Alias for

qpeek.

Function: disque-qscan (&rest args &key count busyloop minlen maxlen importrate)

The command provides an interface to iterate all the existing queues in the local node, providing a cursor in the form of an integer that is passed to the next command invocation. During the first call cursor must be 0, in the next calls the cursor returned in the previous call is used in the next. The iterator guarantees to return all the elements but may return duplicated elements.

Package

cl-disque.

Alias for

qscan.

Function: disque-show (job)

Describe the job.

Package

cl-disque.

Alias for

show.

Function: disque-working (job)

Claims to be still working with the specified job, and asks Disque to postpone the next time it will deliver again the job. The next delivery is postponed for the job retry time, however the command works in a best effort way since there is no way to guarantee during failures that another node in a different network partition is performing a delivery of the same job.

Package

cl-disque.

Alias for

working.

Function: open-connection (conn)

Create a socket connection to the host and port of CONNECTION and set the socket of CONN to the associated socket.

Package

cl-disque.

Source

connection.lisp.

Function: reconnect ()

Close and reopen the connection to Disque server.

Package

cl-disque.

Source

connection.lisp.


6.1.4 Generic functions

Generic Reader: disque-error-message (condition)
Package

cl-disque.

Methods
Reader Method: disque-error-message ((condition disque-error))
Source

cl-disque.lisp.

Target Slot

message.

Generic Function: expect (type)

Receive and process the reply of the given type from Disque server.

Package

cl-disque.

Source

cl-disque.lisp.

Methods
Method: expect ((type (eql :bytes)))

Receive and process the reply of type BYTES.

Method: expect ((type (eql :float)))

Receive and process the reply of type FLOAT.

Method: expect ((type (eql :list)))
Method: expect ((type (eql :end)))
Method: expect ((type (eql :pubsub)))
Method: expect ((type (eql :queued)))

Receive and process the reply of type QUEUED.

Method: expect ((type (eql :multi)))

Receive and process the reply of type MULTI.

Method: expect ((type (eql :bulk)))

Receive and process the reply of type BULK.

Method: expect ((type (eql :integer)))

Receive and process the reply of type INTEGER.

Method: expect ((type (eql :boolean)))

Receive and process the reply of type BOOLEAN.

Method: expect ((type (eql :inline)))

Receive and process the reply of type INLINE.

Method: expect ((type (eql :status)))

Receive and process status reply, which is just a string, preceeded with +.

Method: expect ((type (eql :anything)))

Receive and process status reply, which is just a string, preceeded with +.

Method: expect :around (type)
Generic Function: tell (cmd &rest args)

Send a command to Disque server over a socket connection.
CMD is the command name (a string or a symbol), and ARGS are its arguments (keyword arguments are also supported).

Package

cl-disque.

Source

cl-disque.lisp.

Methods
Method: tell ((cursor (eql cl-disque::jscan)) &rest args)
Source

commands.lisp.

Method: tell ((cmd (eql cl-disque::addjob)) &rest args)
Source

commands.lisp.

Method: tell ((cmd (eql cl-disque::getjob)) &rest args)
Source

commands.lisp.

Method: tell ((cmd (eql cl-disque::qscan)) &rest args)
Source

commands.lisp.

Method: tell (cmd &rest args)
Method: tell :after (cmd &rest args)

6.1.5 Standalone methods

Method: initialize-instance :after ((conn cl-disque-connection) &key)
Source

connection.lisp.


6.1.6 Conditions

Condition: disque-bad-reply

Disque protocol error is detected.

Package

cl-disque.

Source

cl-disque.lisp.

Direct superclasses

disque-error.

Condition: disque-connection-error

Conditions of this type are signaled when errors occur
that break the connection stream. They offer a :RECONNECT restart.

Package

cl-disque.

Source

cl-disque.lisp.

Direct superclasses

disque-error.

Condition: disque-error

Any Disque-related error.

Package

cl-disque.

Source

cl-disque.lisp.

Direct superclasses

error.

Direct subclasses
Direct methods
Direct slots
Slot: error
Package

common-lisp.

Initform

(quote nil)

Initargs

:error

Readers

disque-error-error.

Writers

This slot is read-only.

Slot: message
Initform

(quote nil)

Initargs

:message

Readers

disque-error-message.

Writers

This slot is read-only.

Condition: disque-error-reply

Error reply is received from Disque server.

Package

cl-disque.

Source

cl-disque.lisp.

Direct superclasses

disque-error.


6.2 Internals


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

6.2.1 Special variables

Special Variable: *pipeline*

A list of expected results from the current pipeline.

Package

cl-disque.

Source

cl-disque.lisp.

Special Variable: *pipelined*

Indicates, that commands are sent in pipelined mode.

Package

cl-disque.

Source

cl-disque.lisp.

Special Variable: +utf8+
Package

cl-disque.

Source

connection.lisp.


6.2.2 Macros

Macro: read-bulk-reply (&key post-processing decode)
Package

cl-disque.

Source

cl-disque.lisp.

Macro: reconnect-restart-case ((&key error comment) &body body)

Signal the condition of type DISQUE-CONNECTION-ERROR denoted by
the given ERROR and COMMENT offering a :RECONNECT restart to re-evaluate BODY.

Package

cl-disque.

Source

connection.lisp.

Macro: with-disque-in ((line char) &body body)
Package

cl-disque.

Source

cl-disque.lisp.

Macro: with-reconnect-restart (&body body)

When, during the execution of BODY, an error occurs that breaks the connection, a DISQUE-CONNECTION-ERROR is signalled, offering a :RECONNECT restart that will re-evaluate body after the conenction is re-established.

Package

cl-disque.

Source

connection.lisp.


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

6.2.3 Ordinary functions

Function: ackjob (job &rest jobs)

Acknowledges the execution of one or more jobs via jobs IDs. The node receiving the ACK will replicate it to multiple nodes and will try to garbage collect both the job and the ACKs from the cluster so that memory can be freed.

Package

cl-disque.

Source

commands.lisp.

Function: addjob (queue job timeout &rest args &key replicate delay retry ttl maxlen async)

Adds a job to the specified queue.

Package

cl-disque.

Source

commands.lisp.

Function: connection-open-p (conn)

Is the socket of CONNECTION open?

Package

cl-disque.

Source

connection.lisp.

Function: deljob (job &rest jobs)

Completely delete a job from a node. Note that this is similar to FASTACK, but limited to a single node since no DELJOB cluster bus message is sent to other nodes.

Package

cl-disque.

Source

commands.lisp.

Function: dequeue (job &rest jobs)

Remove jobs from the queue.

Package

cl-disque.

Source

commands.lisp.

Function: enqueue (job &rest jobs)

Queue jobs if not already queued.

Package

cl-disque.

Source

commands.lisp.

Function: ensure-string (obj)
Package

cl-disque.

Source

cl-disque.lisp.

Function: fastack (job &rest jobs)

Acknowledges the execution of one or more jobs via jobs IDs. The node receiving the ACK will replicate it to multiple nodes and will try to garbage collect both the job and the ACKs from the cluster so that memory can be freed.

Package

cl-disque.

Source

commands.lisp.

Function: format-disque-number (char number)

Write a prefix char and a number to the stream of the current connection. If *ECHOP-P* is not NIL, write that string to *ECHO-STREAM*, too.

Package

cl-disque.

Source

cl-disque.lisp.

Function: format-disque-string (string)

Write a string and CRLF-terminator to the stream of the current connection. If *ECHOP-P* is not NIL, write that string to *ECHO-STREAM*, too.

Package

cl-disque.

Source

cl-disque.lisp.

Function: getjob (queues &rest args &key nohang timeout count withcounters)

Gets a job from the specific queue.

Package

cl-disque.

Source

commands.lisp.

Function: hello ()

Returns hello format version, this node ID, all the nodes IDs, IP addresses, ports, and priority (lower is better, means node more available). Clients should use this as an handshake command when connecting with a Disque node.

Package

cl-disque.

Source

commands.lisp.

Function: info ()

Generic server information / stats.

Package

cl-disque.

Source

commands.lisp.

Function: jscan (cursor &rest args &key count blocking queue state reply)

JSCAN provides an interface to iterate all the existing jobs in the local node, providing a cursor in the form of an integer that is passed to the next command invocation. During the first call the cursor must be 0, in the next calls the cursor returned in the previous call is used next. The iterator guarantees to return all elements but may return duplicates.

Package

cl-disque.

Source

commands.lisp.

Function: nack (job &rest jobs)

The NACK command tells Disque to put back the job in the queue ASAP. It is very similar to ENQUEUE but it increments the job nacks counter instead of the additional-deliveries counter. The command should be used when the worker was not able to process a message and wants the message to be put back into the queue in order to be processed again.

Package

cl-disque.

Source

commands.lisp.

Function: parse-float (float-string &key start end radix junk-allowed type decimal-character)
Package

cl-disque.

Source

float.lisp.

Function: qlen (queue)

Returns the length of the queue.

Package

cl-disque.

Source

commands.lisp.

Function: qpeek (queue count)

Return, without consuming from queue, count jobs. If count is positive the specified number of jobs are returned from the oldest to the newest (in the same best-effort FIFO order as GETJOB). If count is negative the commands changes behavior and shows the count newest jobs, from the newest from the oldest.

Package

cl-disque.

Source

commands.lisp.

Function: qscan (&rest args &key count busyloop minlen maxlen importrate)

The command provides an interface to iterate all the existing queues in the local node, providing a cursor in the form of an integer that is passed to the next command invocation. During the first call cursor must be 0, in the next calls the cursor returned in the previous call is used in the next. The iterator guarantees to return all the elements but may return duplicated elements.

Package

cl-disque.

Source

commands.lisp.

Function: radix-values (radix)
Package

cl-disque.

Source

float.lisp.

Function: reopen-connection (conn)

Close and reopen CONN.

Package

cl-disque.

Source

connection.lisp.

Function: show (job)

Describe the job.

Package

cl-disque.

Source

commands.lisp.

Function: working (job)

Claims to be still working with the specified job, and asks Disque to postpone the next time it will deliver again the job. The next delivery is postponed for the job retry time, however the command works in a best effort way since there is no way to guarantee during failures that another node in a different network partition is performing a delivery of the same job.

Package

cl-disque.

Source

commands.lisp.


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

6.2.4 Generic functions

Generic Reader: conn-auth (object)
Package

cl-disque.

Methods
Reader Method: conn-auth ((cl-disque-connection cl-disque-connection))

automatically generated reader method

Source

connection.lisp.

Target Slot

auth.

Generic Reader: conn-host (object)
Package

cl-disque.

Methods
Reader Method: conn-host ((cl-disque-connection cl-disque-connection))

automatically generated reader method

Source

connection.lisp.

Target Slot

host.

Generic Reader: conn-port (object)
Package

cl-disque.

Methods
Reader Method: conn-port ((cl-disque-connection cl-disque-connection))

automatically generated reader method

Source

connection.lisp.

Target Slot

port.

Generic Reader: conn-socket (object)
Package

cl-disque.

Methods
Reader Method: conn-socket ((cl-disque-connection cl-disque-connection))

automatically generated reader method

Source

connection.lisp.

Target Slot

socket.

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

cl-disque.

Methods
Writer Method: (setf conn-socket) ((cl-disque-connection cl-disque-connection))

automatically generated writer method

Source

connection.lisp.

Target Slot

socket.

Generic Reader: conn-stream (object)
Package

cl-disque.

Methods
Reader Method: conn-stream ((cl-disque-connection cl-disque-connection))

automatically generated reader method

Source

connection.lisp.

Target Slot

stream.

Generic Writer: (setf conn-stream) (object)
Package

cl-disque.

Methods
Writer Method: (setf conn-stream) ((cl-disque-connection cl-disque-connection))

automatically generated writer method

Source

connection.lisp.

Target Slot

stream.

Generic Reader: disque-error-error (condition)
Package

cl-disque.

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

cl-disque.lisp.

Target Slot

error.


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

6.2.5 Classes

Class: cl-disque-connection

Representation of a Disque connection.

Package

cl-disque.

Source

connection.lisp.

Direct methods
Direct slots
Slot: host
Initform

#(127 0 0 1)

Initargs

:host

Readers

conn-host.

Writers

This slot is read-only.

Slot: port
Initform

7711

Initargs

:port

Readers

conn-port.

Writers

This slot is read-only.

Slot: auth
Initargs

:auth

Readers

conn-auth.

Writers

This slot is read-only.

Slot: socket
Readers

conn-socket.

Writers

(setf conn-socket).

Slot: stream
Package

common-lisp.

Readers

conn-stream.

Writers

(setf conn-stream).


Appendix A Indexes


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

A.1 Concepts


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

A.2 Functions

Jump to:   (  
A   C   D   E   F   G   H   I   J   M   N   O   P   Q   R   S   T   W  
Index Entry  Section

(
(setf conn-socket): Private generic functions
(setf conn-socket): Private generic functions
(setf conn-stream): Private generic functions
(setf conn-stream): Private generic functions

A
ackjob: Private ordinary functions
addjob: Private ordinary functions

C
close-connection: Public ordinary functions
conn-auth: Private generic functions
conn-auth: Private generic functions
conn-host: Private generic functions
conn-host: Private generic functions
conn-port: Private generic functions
conn-port: Private generic functions
conn-socket: Private generic functions
conn-socket: Private generic functions
conn-stream: Private generic functions
conn-stream: Private generic functions
connect: Public ordinary functions
connected-p: Public ordinary functions
connection-open-p: Private ordinary functions

D
def-cmd: Public macros
def-expect-method: Public macros
deljob: Private ordinary functions
dequeue: Private ordinary functions
disconnect: Public ordinary functions
disque-ackjob: Public ordinary functions
disque-addjob: Public ordinary functions
disque-deljob: Public ordinary functions
disque-dequeue: Public ordinary functions
disque-enqueue: Public ordinary functions
disque-error-error: Private generic functions
disque-error-error: Private generic functions
disque-error-message: Public generic functions
disque-error-message: Public generic functions
disque-fastack: Public ordinary functions
disque-getjob: Public ordinary functions
disque-hello: Public ordinary functions
disque-info: Public ordinary functions
disque-jscan: Public ordinary functions
disque-nack: Public ordinary functions
disque-qlen: Public ordinary functions
disque-qpeek: Public ordinary functions
disque-qscan: Public ordinary functions
disque-show: Public ordinary functions
disque-working: Public ordinary functions

E
enqueue: Private ordinary functions
ensure-string: Private ordinary functions
expect: Public generic functions
expect: Public generic functions
expect: Public generic functions
expect: Public generic functions
expect: Public generic functions
expect: Public generic functions
expect: Public generic functions
expect: Public generic functions
expect: Public generic functions
expect: Public generic functions
expect: Public generic functions
expect: Public generic functions
expect: Public generic functions
expect: Public generic functions
expect: Public generic functions

F
fastack: Private ordinary functions
format-disque-number: Private ordinary functions
format-disque-string: Private ordinary functions
Function, ackjob: Private ordinary functions
Function, addjob: Private ordinary functions
Function, close-connection: Public ordinary functions
Function, connect: Public ordinary functions
Function, connected-p: Public ordinary functions
Function, connection-open-p: Private ordinary functions
Function, deljob: Private ordinary functions
Function, dequeue: Private ordinary functions
Function, disconnect: Public ordinary functions
Function, disque-ackjob: Public ordinary functions
Function, disque-addjob: Public ordinary functions
Function, disque-deljob: Public ordinary functions
Function, disque-dequeue: Public ordinary functions
Function, disque-enqueue: Public ordinary functions
Function, disque-fastack: Public ordinary functions
Function, disque-getjob: Public ordinary functions
Function, disque-hello: Public ordinary functions
Function, disque-info: Public ordinary functions
Function, disque-jscan: Public ordinary functions
Function, disque-nack: Public ordinary functions
Function, disque-qlen: Public ordinary functions
Function, disque-qpeek: Public ordinary functions
Function, disque-qscan: Public ordinary functions
Function, disque-show: Public ordinary functions
Function, disque-working: Public ordinary functions
Function, enqueue: Private ordinary functions
Function, ensure-string: Private ordinary functions
Function, fastack: Private ordinary functions
Function, format-disque-number: Private ordinary functions
Function, format-disque-string: Private ordinary functions
Function, getjob: Private ordinary functions
Function, hello: Private ordinary functions
Function, info: Private ordinary functions
Function, jscan: Private ordinary functions
Function, nack: Private ordinary functions
Function, open-connection: Public ordinary functions
Function, parse-float: Private ordinary functions
Function, qlen: Private ordinary functions
Function, qpeek: Private ordinary functions
Function, qscan: Private ordinary functions
Function, radix-values: Private ordinary functions
Function, reconnect: Public ordinary functions
Function, reopen-connection: Private ordinary functions
Function, show: Private ordinary functions
Function, working: Private ordinary functions

G
Generic Function, (setf conn-socket): Private generic functions
Generic Function, (setf conn-stream): Private generic functions
Generic Function, conn-auth: Private generic functions
Generic Function, conn-host: Private generic functions
Generic Function, conn-port: Private generic functions
Generic Function, conn-socket: Private generic functions
Generic Function, conn-stream: Private generic functions
Generic Function, disque-error-error: Private generic functions
Generic Function, disque-error-message: Public generic functions
Generic Function, expect: Public generic functions
Generic Function, tell: Public generic functions
getjob: Private ordinary functions

H
hello: Private ordinary functions

I
info: Private ordinary functions
initialize-instance: Public standalone methods

J
jscan: Private ordinary functions

M
Macro, def-cmd: Public macros
Macro, def-expect-method: Public macros
Macro, read-bulk-reply: Private macros
Macro, reconnect-restart-case: Private macros
Macro, with-connection: Public macros
Macro, with-disque-in: Private macros
Macro, with-persistent-connection: Public macros
Macro, with-pipelining: Public macros
Macro, with-reconnect-restart: Private macros
Macro, with-recursive-connection: Public macros
Method, (setf conn-socket): Private generic functions
Method, (setf conn-stream): Private generic functions
Method, conn-auth: Private generic functions
Method, conn-host: Private generic functions
Method, conn-port: Private generic functions
Method, conn-socket: Private generic functions
Method, conn-stream: Private generic functions
Method, disque-error-error: Private generic functions
Method, disque-error-message: Public generic functions
Method, expect: Public generic functions
Method, expect: Public generic functions
Method, expect: Public generic functions
Method, expect: Public generic functions
Method, expect: Public generic functions
Method, expect: Public generic functions
Method, expect: Public generic functions
Method, expect: Public generic functions
Method, expect: Public generic functions
Method, expect: Public generic functions
Method, expect: Public generic functions
Method, expect: Public generic functions
Method, expect: Public generic functions
Method, expect: Public generic functions
Method, initialize-instance: Public standalone methods
Method, tell: Public generic functions
Method, tell: Public generic functions
Method, tell: Public generic functions
Method, tell: Public generic functions
Method, tell: Public generic functions
Method, tell: Public generic functions

N
nack: Private ordinary functions

O
open-connection: Public ordinary functions

P
parse-float: Private ordinary functions

Q
qlen: Private ordinary functions
qpeek: Private ordinary functions
qscan: Private ordinary functions

R
radix-values: Private ordinary functions
read-bulk-reply: Private macros
reconnect: Public ordinary functions
reconnect-restart-case: Private macros
reopen-connection: Private ordinary functions

S
show: Private ordinary functions

T
tell: Public generic functions
tell: Public generic functions
tell: Public generic functions
tell: Public generic functions
tell: Public generic functions
tell: Public generic functions
tell: Public generic functions

W
with-connection: Public macros
with-disque-in: Private macros
with-persistent-connection: Public macros
with-pipelining: Public macros
with-reconnect-restart: Private macros
with-recursive-connection: Public macros
working: Private ordinary functions

Jump to:   (  
A   C   D   E   F   G   H   I   J   M   N   O   P   Q   R   S   T   W  

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

A.4 Data types

Jump to:   C   D   F   M   P   S  
Index Entry  Section

C
cl-disque: The cl-disque system
cl-disque: The cl-disque package
cl-disque-connection: Private classes
cl-disque.asd: The cl-disque/cl-disque․asd file
cl-disque.lisp: The cl-disque/src/cl-disque․lisp file
Class, cl-disque-connection: Private classes
commands.lisp: The cl-disque/src/commands․lisp file
Condition, disque-bad-reply: Public conditions
Condition, disque-connection-error: Public conditions
Condition, disque-error: Public conditions
Condition, disque-error-reply: Public conditions
connection.lisp: The cl-disque/src/connection․lisp file

D
disque: The disque package
disque-bad-reply: Public conditions
disque-connection-error: Public conditions
disque-error: Public conditions
disque-error-reply: Public conditions

F
File, cl-disque.asd: The cl-disque/cl-disque․asd file
File, cl-disque.lisp: The cl-disque/src/cl-disque․lisp file
File, commands.lisp: The cl-disque/src/commands․lisp file
File, connection.lisp: The cl-disque/src/connection․lisp file
File, float.lisp: The cl-disque/src/float․lisp file
File, package.lisp: The cl-disque/src/package․lisp file
float.lisp: The cl-disque/src/float․lisp file

M
Module, src: The cl-disque/src module

P
Package, cl-disque: The cl-disque package
Package, disque: The disque package
package.lisp: The cl-disque/src/package․lisp file

S
src: The cl-disque/src module
System, cl-disque: The cl-disque system

Jump to:   C   D   F   M   P   S