com.bigdata.mdi.IndexPartitionCause Maven / Gradle / Ivy

Go to download
package com.bigdata.mdi;

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

import com.bigdata.resources.ResourceManager;

/**
 * Encapsulate the reason why an index partition was created and the
 * synchronous overflow counter of the data service on which the index
 * partition was created as of that action. This information may be used to
 * support heuristics which refuse to move an index partition which was
 * recently moved or to join an index partition which was recently split,
 * etc.
 * 
 * @author Bryan Thompson
 * @version $Id$
 */
public class IndexPartitionCause implements Externalizable {

    /**
     * 
     */
    private static final long serialVersionUID = 4643434468430418713L;

    /**
     * Typesafe enumeration of reasons why an index partition was created.
     * 
     * @author Bryan
     *         Thompson
     * @version $Id$
     */
    static public enum CauseEnum {

        /**
         * The initial registration of a scale-out index.
         */
        Register((byte) 0),

        /** An index partition was split. */
        Split((byte) 1),

        /** Two or more index partitions were joined. */
        Join((byte) 2),

        /** An index partition was moved to another data service. */
        Move((byte) 3);

        private CauseEnum(final byte code) {
            this.code = code;
        }

        private final byte code;

        static IndexPartitionCause.CauseEnum valueOf(final byte code) {
            switch (code) {
            case 0:
                return Register;
            case 1:
                return Split;
            case 2:
                return Join;
            case 3:
                return Move;
            default:
                throw new IllegalArgumentException("code=" + code);
            }
        }

    }

    private IndexPartitionCause.CauseEnum cause;

    private long synchronousOverflowCounter;

    private long lastCommitTime;

    /**
     * The underlying cause.
     */
    public IndexPartitionCause.CauseEnum getCause() {
        return cause;
    }

    /**
     * The value of the synchronous overflow counter at the time that the
     * index partition was created.
     */
    public long getSynchronousOverflowCounter() {
        return synchronousOverflowCounter;
    }

    /**
     * The lastCommitTime for the live journal. Note that this will be 0L if no
     * commits have been performed on the journal. This makes the "time" less
     * robust than the overflow counter.
     */
    public long getLastCommitTime() {
        return lastCommitTime;
    }

    /**
     * Factory for {@link CauseEnum#Register}.
     */
    static public IndexPartitionCause register(ResourceManager resourceManager) {

        return new IndexPartitionCause(
                IndexPartitionCause.CauseEnum.Register,
                resourceManager.getSynchronousOverflowCount(),
                resourceManager.getLiveJournal()
                        .getLastCommitTime());

    }
    
    /**
     * Factory for {@link CauseEnum#Split}.
     */
    static public IndexPartitionCause split(ResourceManager resourceManager) {

        return new IndexPartitionCause(
                IndexPartitionCause.CauseEnum.Split,
                resourceManager.getSynchronousOverflowCount(),
                resourceManager.getLiveJournal()
                        .getLastCommitTime());

    }

    /**
     * Factory for {@link CauseEnum#Join}.
     */
    static public IndexPartitionCause join(ResourceManager resourceManager) {

        return new IndexPartitionCause(
                IndexPartitionCause.CauseEnum.Join,
                resourceManager.getSynchronousOverflowCount(),
                resourceManager.getLiveJournal()
                        .getLastCommitTime());

    }

    /**
     * Factory for {@link CauseEnum#Move}.
     */
    static public IndexPartitionCause move(ResourceManager resourceManager) {

        return new IndexPartitionCause(
                IndexPartitionCause.CauseEnum.Move,
                resourceManager.getSynchronousOverflowCount(),
                resourceManager.getLiveJournal()
                        .getLastCommitTime());

    }
    
    /**
     * De-serialization ctor.
     */
    public IndexPartitionCause() {
        
    }
    
    /**
     * 
     * @param cause
     *            The reason why the index partition was created.
     * @param synchronousOverflowCounter
     *            The value of the counter at the time that the index partition
     *            was created.
     * @param lastCommitTime
     *            The lastCommitTime for the live journal. Note that this will
     *            be 0L if no commits have been performed on the journal. This
     *            makes the "time" less robust than the overflow counter.
     */
    public IndexPartitionCause(final IndexPartitionCause.CauseEnum cause,
            final long synchronousOverflowCounter, final long lastCommitTime) {

        if (cause == null)
            throw new IllegalArgumentException();

        if (synchronousOverflowCounter < 0)
            throw new IllegalArgumentException();

        this.cause = cause;

        this.synchronousOverflowCounter = synchronousOverflowCounter;

        this.lastCommitTime = lastCommitTime;

    }

    /**
     * The initial version.
     */
    private static final transient byte VERSION0 = 0;

    /**
     * The current version.
     */
    private static final transient byte VERSION = VERSION0;

    public void readExternal(ObjectInput in) throws IOException,
            ClassNotFoundException {

        final byte version = in.readByte();
        
        if (version != VERSION0)
            throw new UnsupportedOperationException("version=" + version);

        cause = CauseEnum.valueOf(in.readByte());

        synchronousOverflowCounter = in.readLong();

        lastCommitTime = in.readLong();

    }

    public void writeExternal(ObjectOutput out) throws IOException {

        out.writeByte(VERSION);
        out.writeByte(cause.code);
        out.writeLong(synchronousOverflowCounter);
        out.writeLong(lastCommitTime);

    }

    public String toString() {
        
        return getClass().getName() + "{" + cause + ",overflowCounter="
                + synchronousOverflowCounter + ",timestamp=" + lastCommitTime
                + "}";

    }

}