org.jboss.cache.interceptors
Class ReplicationInterceptor

java.lang.Object
  org.jboss.cache.interceptors.Interceptor (src) 
      org.jboss.cache.interceptors.ReplicationInterceptor

All Implemented Interfaces:

Replicatable (src)

public class ReplicationInterceptor

extends Interceptor (src)

implements Replicatable (src)

Takes care of replicating modifications to other nodes in a cluster. Also listens for prepare(), commit() and rollback() messages which are received 'side-ways' (see docs/design/Refactoring.txt).

ReplicationInterceptor

public ReplicationInterceptor()

Map>. Mapping between local transactions and their modifications, populated on reception of PREPARE. Elements are removed on TX commit or rollback

setCache

public void setCache(TreeCache (src)  cache)

Overrides:

setCache in class Interceptor (src)

invoke

public java.lang.Object invoke(MethodCall m)
                        throws java.lang.Throwable

Overrides:

invoke in class Interceptor (src)

Throws:

java.lang.Throwable

replicate

public java.lang.Object replicate(MethodCall method_call)
                           throws java.lang.Throwable

Received as result of replication sent from another node to this node

Specified by:

replicate in interface Replicatable (src)

Parameters:

method_call -

Returns:

Throws:

java.lang.Throwable

runPreparePhase

protected void runPreparePhase(GlobalTransaction (src)  tx,
                               MethodCall prepare_method,
                               Address coordinator,
                               java.util.List modifications,
                               boolean async)
                        throws java.lang.Exception

Calls #prepare(GlobalTransaction,List,org.jgroups.Address,boolean)) in all members except self. Waits for all responses. If one of the members failed to prepare, its return value will be an exception. If there is one exception we rethrow it. This will mark the current transaction as rolled back, which will cause the #afterCompletion(int) callback to have a status of MARKED_ROLLBACK. When we get that call, we simply roll back the transaction.
If everything runs okay, the #afterCompletion(int) callback will trigger the #runCommitPhase(GlobalTransaction)).

Parameters:

tx -

coordinator -

prepare_method - The MethodCall representing the prepare() method

async - Run this asynchronously

Throws:

java.lang.Exception

runCommitPhase

protected void runCommitPhase(GlobalTransaction (src)  gtx)

Asynchronously calls #commit(GlobalTransaction) in all members

runRollbackPhase

protected void runRollbackPhase(GlobalTransaction (src)  gtx)

Asynchronously calls #rollback(GlobalTransaction) in all members