176 lines
5.9 KiB
Java
176 lines
5.9 KiB
Java
/*-
|
||
* Copyright (C) 2002, 2017, Oracle and/or its affiliates. All rights reserved.
|
||
*
|
||
* This file was distributed by Oracle as part of a version of Oracle Berkeley
|
||
* DB Java Edition made available at:
|
||
*
|
||
* http://www.oracle.com/technetwork/database/database-technologies/berkeleydb/downloads/index.html
|
||
*
|
||
* Please see the LICENSE file included in the top-level directory of the
|
||
* appropriate version of Oracle Berkeley DB Java Edition for a copy of the
|
||
* license and additional information.
|
||
*/
|
||
|
||
package com.sleepycat.je.rep;
|
||
|
||
import java.util.concurrent.TimeUnit;
|
||
|
||
import com.sleepycat.je.ReplicaConsistencyPolicy;
|
||
import com.sleepycat.je.dbi.EnvironmentImpl;
|
||
import com.sleepycat.je.rep.impl.RepImpl;
|
||
import com.sleepycat.je.rep.impl.node.Replica;
|
||
import com.sleepycat.je.utilint.PropUtil;
|
||
|
||
/**
|
||
* A consistency policy which describes the amount of time the Replica is
|
||
* allowed to lag the Master. The application can use this policy to ensure
|
||
* that this node sees all transactions that were committed on the Master
|
||
* before the lag interval.
|
||
* <p>
|
||
* Effective use of this policy requires that the clocks on the Master and
|
||
* Replica are synchronized by using a protocol like NTP
|
||
* <p>
|
||
* Consistency policies are specified at either a per-transaction level through
|
||
* {@link com.sleepycat.je.TransactionConfig#setConsistencyPolicy} or as an replication node
|
||
* wide default through {@link
|
||
* com.sleepycat.je.rep.ReplicationConfig#setConsistencyPolicy}
|
||
*
|
||
* @see <a href="{@docRoot}/../ReplicationGuide/consistency.html"
|
||
* target="_top">Managing Consistency</a>
|
||
*/
|
||
public class TimeConsistencyPolicy implements ReplicaConsistencyPolicy {
|
||
|
||
/**
|
||
* The name:{@value} associated with this policy. The name can be used when
|
||
* constructing policy property values for use in je.properties files.
|
||
*/
|
||
public static final String NAME = "TimeConsistencyPolicy";
|
||
|
||
private final int permissibleLag;
|
||
|
||
/* Amount of time to wait (in ms) for the consistency to be reached. */
|
||
private final int timeout;
|
||
|
||
/**
|
||
* Specifies the amount of time by which the Replica is allowed to lag the
|
||
* master when initiating a transaction. The Replica ensures that all
|
||
* transactions that were committed on the Master before this lag interval
|
||
* are available at the Replica before allowing a transaction to proceed
|
||
* with Environment.beginTransaction.
|
||
*
|
||
* Effective use of this policy requires that the clocks on the Master and
|
||
* Replica are synchronized by using a protocol like NTP.
|
||
*
|
||
* @param permissibleLag the time interval by which the Replica may be out
|
||
* of date with respect to the Master when a transaction is initiated on
|
||
* the Replica.
|
||
*
|
||
* @param permissibleLagUnit the {@code TimeUnit} for the permissibleLag
|
||
* parameter.
|
||
*
|
||
* @param timeout the amount of time to wait for the consistency to be
|
||
* reached.
|
||
*
|
||
* @param timeoutUnit the {@code TimeUnit} for the timeout parameter.
|
||
*
|
||
* @throws IllegalArgumentException if the permissibleLagUnit or
|
||
* timeoutUnit is null.
|
||
*/
|
||
public TimeConsistencyPolicy(long permissibleLag,
|
||
TimeUnit permissibleLagUnit,
|
||
long timeout,
|
||
TimeUnit timeoutUnit) {
|
||
this.permissibleLag = PropUtil.durationToMillis(permissibleLag,
|
||
permissibleLagUnit);
|
||
this.timeout = PropUtil.durationToMillis(timeout, timeoutUnit);
|
||
}
|
||
|
||
/**
|
||
* Returns the name:{@value #NAME}, associated with this policy.
|
||
* @see #NAME
|
||
*/
|
||
@Override
|
||
public String getName() {
|
||
return NAME;
|
||
}
|
||
|
||
/**
|
||
* Returns the allowed time lag associated with this policy.
|
||
*
|
||
* @param unit the {@code TimeUnit} of the returned value.
|
||
*
|
||
* @return the permissible lag time in the specified unit.
|
||
*/
|
||
public long getPermissibleLag(TimeUnit unit) {
|
||
return PropUtil.millisToDuration(permissibleLag, unit);
|
||
}
|
||
|
||
/**
|
||
* Returns the consistency timeout associated with this policy.
|
||
*
|
||
* @param unit the {@code TimeUnit} of the returned value.
|
||
*
|
||
* @return the consistency timeout in the specified unit.
|
||
*/
|
||
@Override
|
||
public long getTimeout(TimeUnit unit) {
|
||
return PropUtil.millisToDuration(timeout, unit);
|
||
}
|
||
|
||
/**
|
||
* @hidden
|
||
* For internal use only.
|
||
* Ensures that the replica has replayed the replication stream to the
|
||
* point identified by the lag period. If it isn't the method waits until
|
||
* the constraint is satisfied by the replica.
|
||
*/
|
||
@Override
|
||
public void ensureConsistency(EnvironmentImpl replicatorImpl)
|
||
throws InterruptedException,
|
||
ReplicaConsistencyException{
|
||
|
||
/*
|
||
* Cast is done to preserve replication/non replication code
|
||
* boundaries.
|
||
*/
|
||
RepImpl repImpl = (RepImpl) replicatorImpl;
|
||
Replica replica = repImpl.getRepNode().replica();
|
||
replica.getConsistencyTracker().lagAwait(this);
|
||
}
|
||
|
||
@Override
|
||
public int hashCode() {
|
||
final int prime = 31;
|
||
int result = 1;
|
||
result = prime * result + permissibleLag;
|
||
result = prime * result + timeout;
|
||
return result;
|
||
}
|
||
|
||
@Override
|
||
public boolean equals(Object obj) {
|
||
if (this == obj) {
|
||
return true;
|
||
}
|
||
if (obj == null) {
|
||
return false;
|
||
}
|
||
if (getClass() != obj.getClass()) {
|
||
return false;
|
||
}
|
||
TimeConsistencyPolicy other =
|
||
(TimeConsistencyPolicy) obj;
|
||
if (permissibleLag != other.permissibleLag) {
|
||
return false;
|
||
}
|
||
if (timeout != other.timeout) {
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
@Override
|
||
public String toString(){
|
||
return getName() + " permissibleLag=" + permissibleLag;
|
||
}
|
||
}
|