Immutant 1.x.incremental.1214 API documentation

immutant.cache

Infinispan-backed implementations of core.cache and core.memoize
protocols supporting multiple replication options and more.

immutant.cache.core

immutant.codecs

Common codecs used when [de]serializing data structures.

immutant.daemons

Asynchronous, highly-available services that share the lifecycle of
your application

immutant.dev

Functions useful for repl based development inside an Immutant container. They
shouldn't be used in production.

immutant.jobs

Associate recurring jobs with an application using cron-like and at-style specifications

immutant.messaging

Easily publish and receive messages containing any type of nested
data structure to dynamically-created topics and queues. Message
distribution is automatically load-balanced when clustered.

immutant.messaging.hornetq

HornetQ specific messaging functionality.

immutant.pipeline

Provides functions for creating and managing pipelines. A pipeline
is a composition of functions ("steps"), where each function is
passed the result of the previous function, dereferenced if needed.
It is built on top of Immutant's messaging subsystem, allowing each
step to have multiple processing threads, and to be automatically
load balanced across a cluster.

The `pipeline` function takes a unique (within the scope of the
application) name, one or more single-arity functions, and optional
kwarg options, returning a function that places its argument onto
the pipeline when called. The resulting pipeline-fn optionally
returns a delay that can be used to retrieve the result of the
pipeline execution.

Each function can be optionally be wrapped with metadata that
provides options for how that particular function is handled (see
the 'step' fn below).

Example:

(require '[immutant.pipeline :as pl])

(defn calculate-foo [m]
  ...
  (assoc m :foo value))

(defn save-data [m]
  ...)

;; create a pipeline
(defonce foo-pipeline
  (pl/pipeline "foo" ;; pipelines must be named
    (pl/step calculate-foo :concurrency 5) ;; run this step with 5 threads
    (pl/step #(update-in % [:bar] + (:foo %)) :name :update-bar) ;; give this step a name
    save-data ;; a 'vanilla' step
    :concurrency 2 ;; run all steps with 2 threads (unless overridden)
    :error-handler (fn [ex m] ;; do something special with errors, and retry
                     ...
                     (pl/*pipeline* m :step *current-step*))))

;; put data onto the front pipeline
(foo-pipeline {:bar 1 :ham "biscuit"})

;; put data onto the pipeline at a given step
(foo-pipeline {:bar 1 :foo 42 :ham "gravy"} :step :update-bar)

;; get the result
(deref (foo-pipeline {:bar 1 :ham "biscuit"}) 1000 ::timeout!)

;; optional - it will automatically be stopped on undeploy
(pl/stop foo-pipeline)

immutant.registry

Functions for working with Immutant's internal per-app registry.

immutant.repl

Provides tools for starting nrepl servers.

immutant.util

Various utility functions.

immutant.web

Associate one or more Ring handlers with your application, mounted
at unique context paths

immutant.web.session

Functions for using the cluster-wide servlet store for sessions.

immutant.xa

Distributed XA transactional support

immutant.xa.transaction

Fine-grained XA transactional control