public ReplicationValve() 
{
   
    // ------------------------------------------------------------- Properties
}

 protected  void createPrimaryIndicator(Request request) throws IOException 
{
        String id = request.getRequestedSessionId();
        if ((id != null) && (id.length()  > 0)) {
            Manager manager = request.getContext().getManager();
            Session session = manager.findSession(id);
            if (session instanceof ClusterSession) {
                ClusterSession cses = (ClusterSession) session;
                if (cses != null) {
                    if (log.isDebugEnabled())
                        log.debug(sm.getString(
                                "ReplicationValve.session.indicator", request.getContext().getName(),id,
                                primaryIndicatorName, cses.isPrimarySession()));
                    request.setAttribute(primaryIndicatorName, cses.isPrimarySession()?Boolean.TRUE:Boolean.FALSE);
                }
            } else {
                if (log.isDebugEnabled()) {
                    if (session != null) {
                        log.debug(sm.getString(
                                "ReplicationValve.session.found", request.getContext().getName(),id));
                    } else {
                        log.debug(sm.getString(
                                "ReplicationValve.session.invalid", request.getContext().getName(),id));
                    }
                }
            }
        }
}

Mark Request that processed at primary node with attribute primaryIndicatorName

 public boolean doStatistics() 
{
        return doProcessingStats;
}

Calc processing stats

 public CatalinaCluster getCluster() 
{
        return cluster;
}

 public String getFilter() 
{
       return filter ;
}

 public String getInfo() 
{
        return (info);
}

Return descriptive information about this Valve implementation.

 public long getLastSendTime() 
{
        return lastSendTime;
}

 public long getNrOfCrossContextSendRequests() 
{
        return nrOfCrossContextSendRequests;
}

 public long getNrOfFilterRequests() 
{
        return nrOfFilterRequests;
}

 public long getNrOfRequests() 
{
        return nrOfRequests;
}

 public long getNrOfSendRequests() 
{
        return nrOfSendRequests;
}

 public String getPrimaryIndicatorName() 
{
        return primaryIndicatorName;
}

 protected Pattern[] getReqFilters() 
{
        return reqFilters;
}

 public long getTotalRequestTime() 
{
        return totalRequestTime;
}

 public long getTotalSendTime() 
{
        return totalSendTime;
}

 public  void invoke(Request request,
    Response response) throws IOException, ServletException 
{
        long totalstart = 0;
        //this happens before the request
        if(doStatistics()) {
            totalstart = System.currentTimeMillis();
        }
        if (primaryIndicator) {
            createPrimaryIndicator(request) ;
        }
        Context context = request.getContext();
        boolean isCrossContext = context != null
                && context instanceof StandardContext
                && ((StandardContext) context).getCrossContext();
        try {
            if(isCrossContext) {
                if(log.isDebugEnabled())
                    log.debug(sm.getString("ReplicationValve.crossContext.add"));
                //FIXME add Pool of Arraylists
                crossContextSessions.set(new ArrayList());
            }
            getNext().invoke(request, response);
            Manager manager = request.getContext().getManager();
            if (manager != null && manager instanceof ClusterManager) {
                ClusterManager clusterManager = (ClusterManager) manager;
                CatalinaCluster containerCluster = (CatalinaCluster) getContainer().getCluster();
                if (containerCluster == null) {
                    if (log.isWarnEnabled())
                        log.warn(sm.getString("ReplicationValve.nocluster"));
                    return;
                }
                // valve cluster can access manager - other cluster handle replication 
                // at host level - hopefully!
                if(containerCluster.getManager(clusterManager.getName()) == null)
                    return ;
                if(containerCluster.hasMembers()) {
                    sendReplicationMessage(request, totalstart, isCrossContext, clusterManager, containerCluster);
                } else {
                    resetReplicationRequest(request,isCrossContext);
                }        
            }
        } finally {
            // Array must be remove: Current master request send endAccess at recycle. 
            // Don't register this request session again!
            if(isCrossContext) {
                if(log.isDebugEnabled())
                    log.debug(sm.getString("ReplicationValve.crossContext.remove"));
                // crossContextSessions.remove() only exist at Java 5
                // register ArrayList at a pool
                crossContextSessions.set(null);
            }
        }
}

Log the interesting request parameters, invoke the next Valve in the sequence, and log the interesting response parameters.

 public boolean isPrimaryIndicator() 
{
        return primaryIndicator;
}

 protected boolean isRequestWithoutSessionChange(String uri) 
{
        boolean filterfound = false;
        for (int i = 0; (i <  reqFilters.length) && (!filterfound); i++) {
            java.util.regex.Matcher matcher = reqFilters[i].matcher(uri);
            filterfound = matcher.matches();
        }
        return filterfound;
}

is request without possible session change

 public  void registerReplicationSession(DeltaSession session) 
{
        List sessions = (List)crossContextSessions.get();
        if(sessions != null) {
            if(!sessions.contains(session)) {
                if(log.isDebugEnabled())
                    log.debug(sm.getString("ReplicationValve.crossContext.registerSession",
                        session.getIdInternal(),
                        session.getManager().getContainer().getName()));
                sessions.add(session);
            }
        }
}

Register all cross context sessions inside endAccess. Use a list with contains check, that the Portlet API can include a lot of fragments from same or different applications with session changes.

 protected  void resetDeltaRequest(Session session) 
{
        if(log.isDebugEnabled()) {
            log.debug(sm.getString("ReplicationValve.resetDeltaRequest" , 
                session.getManager().getContainer().getName() ));
        }
        ((DeltaSession)session).resetDeltaRequest();
}

Reset DeltaRequest from session

 protected  void resetReplicationRequest(Request request,
    boolean isCrossContext) 
{
        Session contextSession = request.getSessionInternal(false);
        if(contextSession != null && contextSession instanceof DeltaSession){
            resetDeltaRequest(contextSession);
            ((DeltaSession)contextSession).setPrimarySession(true);
        }
        if(isCrossContext) {
            Object sessions = crossContextSessions.get();
            if(sessions != null && sessions instanceof List
               && ((List)sessions).size()  >0) {
                Iterator iter = ((List)sessions).iterator();
                for(; iter.hasNext() ;) {          
                    Session session = (Session)iter.next();
                    resetDeltaRequest(session);
                    if(session instanceof DeltaSession)
                        ((DeltaSession)contextSession).setPrimarySession(true);
                }
            }
        }
}

Fix memory leak for long sessions with many changes, when no backup member exists!

 public  void resetStatistics() 
{
        totalRequestTime = 0 ;
        totalSendTime = 0 ;
        lastSendTime = 0 ;
        nrOfFilterRequests = 0 ;
        nrOfRequests = 0 ;
        nrOfSendRequests = 0;
        nrOfCrossContextSendRequests = 0;
}

reset the active statitics

 protected  void send(ClusterManager manager,
    CatalinaCluster cluster,
    String sessionId) 
{
        ClusterMessage msg = manager.requestCompleted(sessionId);
        if (msg != null) {
            if(manager.doDomainReplication()) {
                cluster.sendClusterDomain(msg);
            } else {
                cluster.send(msg);
            }
            if(doStatistics())
                nrOfSendRequests++;
        }
}

send manager requestCompleted message to cluster

 protected  void sendCrossContextSession(CatalinaCluster containerCluster) 
{
        Object sessions = crossContextSessions.get();
        if(sessions != null && sessions instanceof List
                && ((List)sessions).size()  >0) {
            for(Iterator iter = ((List)sessions).iterator(); iter.hasNext() ;) {          
                Session session = (Session)iter.next();
                if(log.isDebugEnabled())
                    log.debug(sm.getString("ReplicationValve.crossContext.sendDelta",  
                            session.getManager().getContainer().getName() ));
                sendMessage(session,(ClusterManager)session.getManager(),containerCluster);
                if(doStatistics()) {
                    nrOfCrossContextSendRequests++;
                }
            }
        }
}

Send all changed cross context sessions to backups

 protected  void sendInvalidSessions(ClusterManager manager,
    CatalinaCluster cluster) 
{
        String[] invalidIds=manager.getInvalidatedSessions();
        if ( invalidIds.length  > 0 ) {
            for ( int i=0;i< invalidIds.length; i++ ) {
                try {
                    send(manager,cluster,invalidIds[i]);
                } catch ( Exception x ) {
                    log.error(sm.getString("ReplicationValve.send.invalid.failure",invalidIds[i]),x);
                }
            }
        }
}

check for session invalidations

 protected  void sendMessage(Session session,
    ClusterManager manager,
    CatalinaCluster cluster) 
{
        String id = session.getIdInternal();
        if (id != null) {
            send(manager, cluster, id);
        }
}

Send message delta message from request session

 protected  void sendReplicationMessage(Request request,
    long totalstart,
    boolean isCrossContext,
    ClusterManager clusterManager,
    CatalinaCluster containerCluster) 
{
        //this happens after the request
        long start = 0;
        if(doStatistics()) {
            start = System.currentTimeMillis();
        }
        try {
            // send invalid sessions
            // DeltaManager returns String[0]
            if (!(clusterManager instanceof DeltaManager))
                sendInvalidSessions(clusterManager, containerCluster);
            // send replication
            sendSessionReplicationMessage(request, clusterManager, containerCluster);
            if(isCrossContext)
                sendCrossContextSession(containerCluster);
        } catch (Exception x) {
            // FIXME we have a lot of sends, but the trouble with one node stops the correct replication to other nodes!
            log.error(sm.getString("ReplicationValve.send.failure"), x);
        } finally {
            // FIXME this stats update are not cheap!!
            if(doStatistics()) {
                updateStats(totalstart,start);
            }
        }
}

 protected  void sendSessionReplicationMessage(Request request,
    ClusterManager manager,
    CatalinaCluster cluster) 
{
        Session session = request.getSessionInternal(false);
        if (session != null) {
            String uri = request.getDecodedRequestURI();
            // request without session change
            if (!isRequestWithoutSessionChange(uri)) {
                if (log.isDebugEnabled())
                    log.debug(sm.getString("ReplicationValve.invoke.uri", uri));
                sendMessage(session,manager,cluster);
            } else
                if(doStatistics())
                    nrOfFilterRequests++;
        }
}

Send Cluster Replication Request

 public  void setCluster(CatalinaCluster cluster) 
{
        this.cluster = cluster;
}

 public  void setFilter(String filter) 
{
        if (log.isDebugEnabled())
            log.debug(sm.getString("ReplicationValve.filter.loading", filter));
        this.filter = filter;
        StringTokenizer t = new StringTokenizer(filter, ";");
        this.reqFilters = new Pattern[t.countTokens()];
        int i = 0;
        while (t.hasMoreTokens()) {
            String s = t.nextToken();
            if (log.isTraceEnabled())
                log.trace(sm.getString("ReplicationValve.filter.token", s));
            try {
                reqFilters[i++] = Pattern.compile(s);
            } catch (Exception x) {
                log.error(sm.getString("ReplicationValve.filter.token.failure",
                        s), x);
            }
        }
}

compile filter string to regular expressions

 public  void setPrimaryIndicator(boolean primaryIndicator) 
{
        this.primaryIndicator = primaryIndicator;
}

 public  void setPrimaryIndicatorName(String primaryIndicatorName) 
{
        this.primaryIndicatorName = primaryIndicatorName;
}

 protected  void setReqFilters(Pattern[] reqFilters) 
{
        this.reqFilters = reqFilters;
}

 public  void setStatistics(boolean doProcessingStats) 
{
        this.doProcessingStats = doProcessingStats;
}

Set Calc processing stats

 public String toString() 
{
        StringBuffer sb = new StringBuffer("ReplicationValve[");
        if (container != null)
            sb.append(container.getName());
        sb.append("]");
        return (sb.toString());
}

Return a String rendering of this object.

 protected  void updateStats(long requestTime,
    long clusterTime) 
{
        synchronized(this) {
            lastSendTime=System.currentTimeMillis();
            totalSendTime+=lastSendTime - clusterTime;
            totalRequestTime+=lastSendTime - requestTime;
            nrOfRequests++;
        }
        if(log.isInfoEnabled()) {
            if ( (nrOfRequests % 100) == 0 ) {
                 log.info(sm.getString("ReplicationValve.stats",
                     new Object[]{
                         new Long(totalRequestTime/nrOfRequests),
                         new Long(totalSendTime/nrOfRequests),
                         new Long(nrOfRequests),
                         new Long(nrOfSendRequests),
                         new Long(nrOfCrossContextSendRequests),
                         new Long(nrOfFilterRequests),
                         new Long(totalRequestTime),
                         new Long(totalSendTime)}));
             }
        }
}

protocol cluster replications stats