org.ibatis.jgroups.ehcache.BootstrapRequest Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jbatis Show documentation
The jBATIS persistence framework will help you to significantly reduce the amount of Java code that you normally need to access a relational database. iBATIS simply maps JavaBeans to SQL statements using a very simple XML descriptor.
The newest version!
/**
 *  Copyright 2003-2010 Terracotta, Inc.
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package org.ibatis.jgroups.ehcache;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;

import net.sf.ehcache.Ehcache;

/**
 * Tracks the status of a bootstrap request
 * 
 * @author Eric Dalquist
 * @version $Revision$
 */
public class BootstrapRequest {
    /**
     * Possible states of a BootstrapRequest
     */
    public enum BootstrapStatus {
        /**
         * There is no pending request to a peer for bootstrap
         */
        UNSENT,
        /**
         * There is a pending request to a peer for bootstrap
         */
        REQUESTED,
        /**
         * The peer responded that it could not fulfill the bootstrap request
         */
        INCOMPLETE,
        /**
         * The peer responded that it fulfilled the bootstrap request
         */
        COMPLETE;
    }
    
    private volatile CountDownLatch boostrapCompleteLatch = new CountDownLatch(1);
    private final AtomicLong replicated = new AtomicLong();
    private final Ehcache cache;
    private final boolean asynchronous;
    private final int chunkSize;
    private volatile BootstrapStatus bootstrapStatus = BootstrapStatus.UNSENT;

    /**
     * Create a new bootstrap request for the specified cache
     */
    public BootstrapRequest(Ehcache cache, boolean asynchronous, int chunkSize) {
        this.cache = cache;
        this.asynchronous = asynchronous;
        this.chunkSize = chunkSize;
    }
    
    /**
     * @return The current status of the bootstrap request
     */
    public BootstrapStatus getBootstrapStatus() {
        return this.bootstrapStatus;
    }

    /**
     * @param bootstrapStatus The current status of the bootstrap request 
     */
    public void setBootstrapStatus(BootstrapStatus bootstrapStatus) {
        if (bootstrapStatus == null) {
            throw new IllegalArgumentException("BootstrapStatus cannot be null");
        }
        this.bootstrapStatus = bootstrapStatus;
    }

    /**
     * @return If the bootstrap request should be handled asynchronously
     */
    public boolean isAsynchronous() {
        return this.asynchronous;
    }

    /**
     * @return The maximum serialized size of the elements to request from a remote cache peer during bootstrap.
     */
    public int getChunkSize() {
        return this.chunkSize;
    }

    /**
     * Reset the replicationCount and waitForBootstrap latch to their initial states
     */
    public void reset() {
        this.boostrapCompleteLatch = new CountDownLatch(1);
        this.replicated.set(0);
        this.bootstrapStatus = BootstrapStatus.UNSENT;
    }
    
    /**
     * Signal that bootstrapping is complete
     */
    public void boostrapComplete(BootstrapStatus status) {
        this.bootstrapStatus = status;
        this.boostrapCompleteLatch.countDown();
    }
    
    /**
     * Waits for the receiver to signal that the current bootstrap request is complete
     */
    public boolean waitForBoostrap(long timeout, TimeUnit unit) throws InterruptedException {
        return this.boostrapCompleteLatch.await(timeout, unit);
    }
    
    /**
     * Count a received bootstrap replication 
     */
    public void countReplication() {
        this.replicated.incrementAndGet();
    }
    
    /**
     * @return The number of bootstrap replication responses received
     */
    public long getReplicationCount() {
        return this.replicated.get();
    }
    
    /**
     * @return The cache that is being bootstrapped
     */
    public Ehcache getCache() {
        return this.cache;
    }

    
    /**
     * {@inheritDoc}
     */
    @Override
    public String toString() {
        return "BootstrapRequest [cache=" + this.cache.getName() + 
            ", bootstrapStatus=" + this.bootstrapStatus + 
            ", boostrapCompleteLatch=" + this.boostrapCompleteLatch.getCount() + 
            ", replicated=" + this.replicated + 
            ", asynchronous=" + this.asynchronous + 
            ", chunkSize=" + this.chunkSize + "]";
    }

    
}