/** * Exception thrown when we get a request for a snapshot we don't recognize. */ @SuppressWarnings("serial") @InterfaceAudience.Public @InterfaceStability.Evolving public class UnknownSnapshotException extends HBaseSnapshotException { /** * @param msg full information about the failure */ public UnknownSnapshotException(String msg) { super(msg); } public UnknownSnapshotException(String msg, Exception e) { super(msg, e); } }
/** * Implementers are Stoppable. */ @InterfaceAudience.LimitedPrivate(HBaseInterfaceAudience.COPROC) @InterfaceStability.Evolving public interface Stoppable { /** * Stop this service. * @param why Why we're stopping. */ void stop(String why); /** * @return True if {@link #stop(String)} has been closed. */ boolean isStopped(); }
/** * Thrown when the client believes that we are trying to communicate to has * been repeatedly unresponsive for a while. * * On receiving such an exception. The HConnectionManager will skip all * retries and fast fail the operation. */ @InterfaceAudience.Public @InterfaceStability.Evolving public class ConnectionClosingException extends IOException { public ConnectionClosingException(String string) { super(string); } private static final long serialVersionUID = -8980028569652624236L; }
/** * During the read (ie. get/Scan) the VisibilityController calls this interface for each of the * Cell. Depending on the evaluate() result, a cell can be either included or filtered out from the * read results. */ @InterfaceAudience.Public @InterfaceStability.Evolving public interface VisibilityExpEvaluator { /** * Evaluates whether the passed cell passes Scan/Get Authorization. * @param cell Cell under evaluation * @return true if this cell can be included in the Result. Else false. */ boolean evaluate(Cell cell) throws IOException; }
/** Thrown when the file system needs to be upgraded */ @InterfaceAudience.Public @InterfaceStability.Evolving public class FileSystemVersionException extends IOException { private static final long serialVersionUID = 1004053363L; /** default constructor */ public FileSystemVersionException() { super(); } /** @param s message */ public FileSystemVersionException(String s) { super(s); } }
/** * Makes the decision regarding proper sizing of the heap memory. Decides what percentage of heap * memory should be allocated for global memstore and BlockCache. */ @InterfaceAudience.Private @InterfaceStability.Evolving public interface HeapMemoryTuner extends Configurable { /** * Perform the heap memory tuning operation. * * @param context * @return <code>TunerResult</code> including the heap percentage for memstore and block cache */ TunerResult tune(TunerContext context); }
/** * Indicates that we're trying to connect to a already known as dead server. We will want to * retry: we're getting this because the region location was wrong, or because * the server just died, in which case the retry loop will help us to wait for the * regions to recover. */ @SuppressWarnings("serial") @InterfaceAudience.Public @InterfaceStability.Evolving public class FailedServerException extends HBaseIOException { public FailedServerException(String s) { super(s); } }
/** * Every class that wants to observe changes in Configuration properties, * must implement interface (and also, register itself with the * <code>ConfigurationManager</code> object. */ @InterfaceAudience.Private @InterfaceStability.Evolving public interface ConfigurationObserver { /** * This method would be called by the {@link ConfigurationManager} * object when the {@link Configuration} object is reloaded from disk. */ void onConfigurationChange(Configuration conf); }
/** Thrown when a table can not be located */ @InterfaceAudience.Public @InterfaceStability.Evolving public class RegionOfflineException extends RegionException { private static final long serialVersionUID = 466008402L; /** default constructor */ public RegionOfflineException() { super(); } /** @param s message */ public RegionOfflineException(String s) { super(s); } }
@InterfaceAudience.Public @InterfaceStability.Evolving public class UnsupportedCellCodecException extends FatalConnectionException { public UnsupportedCellCodecException() { super(); } public UnsupportedCellCodecException(String msg) { super(msg); } public UnsupportedCellCodecException(String msg, Throwable t) { super(msg, t); } }
/** * A factory class that constructs an {@link org.apache.hadoop.hbase.ipc.RpcScheduler}. */ @InterfaceAudience.LimitedPrivate({HBaseInterfaceAudience.COPROC, HBaseInterfaceAudience.PHOENIX}) @InterfaceStability.Evolving public interface RpcSchedulerFactory { /** * Constructs a {@link org.apache.hadoop.hbase.ipc.RpcScheduler}. */ RpcScheduler create(Configuration conf, PriorityFunction priority, Abortable server); @Deprecated RpcScheduler create(Configuration conf, PriorityFunction priority); }
@InterfaceAudience.Public @InterfaceStability.Evolving public class BadAuthException extends FatalConnectionException { public BadAuthException() { super(); } public BadAuthException(String msg) { super(msg); } public BadAuthException(String msg, Throwable t) { super(msg, t); } }
@InterfaceAudience.Public @InterfaceStability.Evolving public class UnsupportedCompressionCodecException extends FatalConnectionException { public UnsupportedCompressionCodecException() { super(); } public UnsupportedCompressionCodecException(String msg) { super(msg); } public UnsupportedCompressionCodecException(String msg, Throwable t) { super(msg, t); } }
/** * Subclass if the server knows the region is now on another server. * This allows the client to call the new region server without calling the master. */ @InterfaceAudience.Private @InterfaceStability.Evolving public class RegionOpeningException extends NotServingRegionException { private static final Log LOG = LogFactory.getLog(RegionOpeningException.class); private static final long serialVersionUID = -7232903522310558395L; public RegionOpeningException(String message) { super(message); } }
@InterfaceAudience.Public @InterfaceStability.Evolving public class WrongVersionException extends FatalConnectionException { public WrongVersionException() { super(); } public WrongVersionException(String msg) { super(msg); } public WrongVersionException(String msg, Throwable t) { super(msg, t); } }
/** * Exception indicating that the remote host making this IPC lost its * IPC connection. This will never be returned back to a client, * but is only used for logging on the server side, etc. */ @InterfaceAudience.Public @InterfaceStability.Evolving public class CallerDisconnectedException extends IOException { private static final long serialVersionUID = 1L; public CallerDisconnectedException(String msg) { super(msg); } }
/** * Exception thrown when the result needs to be chunked on the server side. * It signals that retries should happen right away and not count against the number of * retries because some of the multi was a success. */ @InterfaceAudience.Public @InterfaceStability.Evolving public class MultiActionResultTooLarge extends RetryImmediatelyException { public MultiActionResultTooLarge(String s) { super(s); } }
@InterfaceAudience.Public @InterfaceStability.Evolving public class LabelAlreadyExistsException extends DoNotRetryIOException { private static final long serialVersionUID = 1L; public LabelAlreadyExistsException(String msg) { super(msg); } }
@InterfaceAudience.Public @InterfaceStability.Evolving public class StoppedRpcClientException extends HBaseIOException { public StoppedRpcClientException() { super(); } public StoppedRpcClientException(String msg) { super(msg); } }
/** * Exception thrown when a read only byte range is modified */ @InterfaceAudience.Public @InterfaceStability.Evolving public class ReadOnlyByteRangeException extends UnsupportedOperationException { public ReadOnlyByteRangeException() { } }