org.apache.hadoop.hbase.master.procedure.ProcedureSyncWait Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of hbase-server Show documentation
Show all versions of hbase-server Show documentation
Server functionality for HBase
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.apache.hadoop.hbase.master.procedure;
import java.io.IOException;
import java.io.InterruptedIOException;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HConstants;
import org.apache.hadoop.hbase.NotAllMetaRegionsOnlineException;
import org.apache.hadoop.hbase.client.RegionInfo;
import org.apache.hadoop.hbase.client.RegionInfoBuilder;
import org.apache.hadoop.hbase.exceptions.TimeoutIOException;
import org.apache.hadoop.hbase.master.RegionState;
import org.apache.hadoop.hbase.master.assignment.RegionStateNode;
import org.apache.hadoop.hbase.master.assignment.RegionStates;
import org.apache.hadoop.hbase.procedure2.Procedure;
import org.apache.hadoop.hbase.procedure2.ProcedureExecutor;
import org.apache.hadoop.hbase.quotas.MasterQuotaManager;
import org.apache.hadoop.hbase.util.EnvironmentEdgeManager;
import org.apache.yetus.audience.InterfaceAudience;
import org.apache.yetus.audience.InterfaceStability;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.ProcedureState;
/**
* Helper to synchronously wait on conditions. This will be removed in the future (mainly when the
* AssignmentManager will be replaced with a Procedure version) by using ProcedureYieldException,
* and the queue will handle waiting and scheduling based on events.
*/
@InterfaceAudience.Private
@InterfaceStability.Evolving
public final class ProcedureSyncWait {
private static final Logger LOG = LoggerFactory.getLogger(ProcedureSyncWait.class);
private ProcedureSyncWait() {
}
@InterfaceAudience.Private
public interface Predicate {
T evaluate() throws IOException;
}
private static class ProcedureFuture implements Future {
private final ProcedureExecutor procExec;
private final Procedure proc;
private boolean hasResult = false;
private byte[] result = null;
public ProcedureFuture(ProcedureExecutor procExec, Procedure proc) {
this.procExec = procExec;
this.proc = proc;
}
@Override
public boolean cancel(boolean mayInterruptIfRunning) {
return false;
}
@Override
public boolean isCancelled() {
return false;
}
@Override
public boolean isDone() {
return hasResult;
}
@Override
public byte[] get() throws InterruptedException, ExecutionException {
if (hasResult) {
return result;
}
try {
return waitForProcedureToComplete(procExec, proc, Long.MAX_VALUE);
} catch (Exception e) {
throw new ExecutionException(e);
}
}
@Override
public byte[] get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
if (hasResult) {
return result;
}
try {
result = waitForProcedureToComplete(procExec, proc, unit.toMillis(timeout));
hasResult = true;
return result;
} catch (TimeoutIOException e) {
throw new TimeoutException(e.getMessage());
} catch (Exception e) {
throw new ExecutionException(e);
}
}
}
public static Future submitProcedure(final ProcedureExecutor procExec,
final Procedure proc) {
if (proc.isInitializing()) {
procExec.submitProcedure(proc);
}
return new ProcedureFuture(procExec, proc);
}
public static byte[] submitAndWaitProcedure(ProcedureExecutor procExec,
final Procedure proc) throws IOException {
if (proc.isInitializing()) {
procExec.submitProcedure(proc);
}
return waitForProcedureToCompleteIOE(procExec, proc, Long.MAX_VALUE);
}
public static byte[] waitForProcedureToCompleteIOE(
final ProcedureExecutor procExec, final Procedure proc,
final long timeout) throws IOException {
try {
return waitForProcedureToComplete(procExec, proc, timeout);
} catch (IOException e) {
throw e;
} catch (Exception e) {
throw new IOException(e);
}
}
public static byte[] waitForProcedureToComplete(
final ProcedureExecutor procExec, final Procedure proc,
final long timeout) throws IOException {
waitFor(procExec.getEnvironment(), timeout, "pid=" + proc.getProcId(),
new ProcedureSyncWait.Predicate() {
@Override
public Boolean evaluate() throws IOException {
if (!procExec.isRunning()) {
return true;
}
ProcedureState state = proc.getState();
if (state == ProcedureState.INITIALIZING || state == ProcedureState.RUNNABLE) {
// under these states the procedure may have not been added to procExec yet, so do not
// use isFinished to test whether it is finished, as this method will just check if the
// procedure is in the running procedure list
return false;
}
return procExec.isFinished(proc.getProcId());
}
});
if (!procExec.isRunning()) {
throw new IOException("The Master is Aborting");
}
// If the procedure fails, we should always have an exception captured. Throw it.
// Needs to be an IOE to get out of here.
if (proc.hasException()) {
throw MasterProcedureUtil.unwrapRemoteIOException(proc);
} else {
return proc.getResult();
}
}
public static T waitFor(MasterProcedureEnv env, String purpose, Predicate predicate)
throws IOException {
Configuration conf = env.getMasterConfiguration();
long waitTime = conf.getLong("hbase.master.wait.on.region", 5 * 60 * 1000);
return waitFor(env, waitTime, purpose, predicate);
}
public static T waitFor(MasterProcedureEnv env, long waitTime, String purpose,
Predicate predicate) throws IOException {
Configuration conf = env.getMasterConfiguration();
long waitingTimeForEvents = conf.getInt("hbase.master.event.waiting.time", 1000);
return waitFor(env, waitTime, waitingTimeForEvents, purpose, predicate);
}
public static T waitFor(MasterProcedureEnv env, long waitTime, long waitingTimeForEvents,
String purpose, Predicate predicate) throws IOException {
long done = EnvironmentEdgeManager.currentTime() + waitTime;
if (done <= 0) {
// long overflow, usually this means we pass Long.MAX_VALUE as waitTime
done = Long.MAX_VALUE;
}
boolean logged = false;
do {
T result = predicate.evaluate();
if (result != null && !result.equals(Boolean.FALSE)) {
return result;
}
try {
Thread.sleep(waitingTimeForEvents);
} catch (InterruptedException e) {
LOG.warn("Interrupted while sleeping, waiting on " + purpose);
throw (InterruptedIOException) new InterruptedIOException().initCause(e);
}
if (LOG.isTraceEnabled()) {
LOG.trace("waitFor " + purpose);
} else {
if (!logged) LOG.debug("waitFor " + purpose);
}
logged = true;
} while (EnvironmentEdgeManager.currentTime() < done && env.isRunning());
throw new TimeoutIOException("Timed out while waiting on " + purpose);
}
protected static void waitMetaRegions(final MasterProcedureEnv env) throws IOException {
int timeout = env.getMasterConfiguration().getInt("hbase.client.catalog.timeout", 10000);
try {
long start = EnvironmentEdgeManager.currentTime();
for (;;) {
RegionStateNode rsn = env.getAssignmentManager().getRegionStates()
.getRegionStateNode(RegionInfoBuilder.FIRST_META_REGIONINFO);
if (rsn != null && rsn.isInState(RegionState.State.OPEN)) {
return;
}
if (EnvironmentEdgeManager.currentTime() - start >= timeout) {
throw new NotAllMetaRegionsOnlineException();
}
Thread.sleep(HConstants.SOCKET_RETRY_WAIT_MS);
}
} catch (InterruptedException e) {
throw (InterruptedIOException) new InterruptedIOException().initCause(e);
}
}
protected static void waitRegionInTransition(final MasterProcedureEnv env,
final List regions) throws IOException {
final RegionStates states = env.getAssignmentManager().getRegionStates();
for (final RegionInfo region : regions) {
ProcedureSyncWait.waitFor(env, "regions " + region.getRegionNameAsString() + " in transition",
new ProcedureSyncWait.Predicate() {
@Override
public Boolean evaluate() throws IOException {
return !states.isRegionInTransition(region);
}
});
}
}
protected static MasterQuotaManager getMasterQuotaManager(final MasterProcedureEnv env)
throws IOException {
return ProcedureSyncWait.waitFor(env, "quota manager to be available",
new ProcedureSyncWait.Predicate() {
@Override
public MasterQuotaManager evaluate() throws IOException {
return env.getMasterServices().getMasterQuotaManager();
}
});
}
}