name stringlengths 12 178 | code_snippet stringlengths 8 36.5k | score float64 3.26 3.68 |
|---|---|---|
hbase_HFileContextAttributesBuilderConsumer_setReadType_rdh | /**
* Specify the {@link ReadType} involced in this IO operation.
*/
public HFileContextAttributesBuilderConsumer setReadType(final ReadType readType) {
// TODO: this is not a part of the HFileBlock, its context of the operation. Should track this
// detail elsewhere.
this.readType = readType;
return ... | 3.26 |
hbase_HFileContextAttributesBuilderConsumer_setSkipChecksum_rdh | /**
* Specify that the {@link ChecksumType} should not be included in the attributes.
*/
public HFileContextAttributesBuilderConsumer setSkipChecksum(final boolean skipChecksum) {
this.skipChecksum = skipChecksum;
return this;
} | 3.26 |
hbase_MetricsAssignmentManager_getOpenProcMetrics_rdh | /**
* Returns Set of common metrics for OpenRegionProcedure
*/
public ProcedureMetrics getOpenProcMetrics() {
return openProcMetrics;
} | 3.26 |
hbase_MetricsAssignmentManager_updateRITOldestAge_rdh | /**
* update the timestamp for oldest region in transition metrics.
*/
public void updateRITOldestAge(final long timestamp) {
assignmentManagerSource.setRITOldestAge(timestamp);
} | 3.26 |
hbase_MetricsAssignmentManager_updateRitDuration_rdh | /**
* update the duration metrics of region is transition
*/
public void updateRitDuration(long duration) {
assignmentManagerSource.updateRitDuration(duration);
} | 3.26 |
hbase_MetricsAssignmentManager_m1_rdh | /**
* Returns Set of common metrics for unassign procedure
*/
public ProcedureMetrics m1() {
return unassignProcMetrics;
} | 3.26 |
hbase_MetricsAssignmentManager_getMergeProcMetrics_rdh | /**
* Returns Set of common metrics for merge procedure
*/
public ProcedureMetrics getMergeProcMetrics() {
return mergeProcMetrics;
} | 3.26 |
hbase_MetricsAssignmentManager_updateRITCount_rdh | /**
* set new value for number of regions in transition.
*/
public void updateRITCount(final int ritCount) {
assignmentManagerSource.setRIT(ritCount);
} | 3.26 |
hbase_MetricsAssignmentManager_m0_rdh | /**
* update RIT count that are in this state for more than the threshold as defined by the property
* rit.metrics.threshold.time.
*/
public void m0(final int ritCountOverThreshold) {
assignmentManagerSource.setRITCountOverThreshold(ritCountOverThreshold);
} | 3.26 |
hbase_MetricsAssignmentManager_getAssignProcMetrics_rdh | /**
* Returns Set of common metrics for assign procedure
*/
public ProcedureMetrics getAssignProcMetrics() {
return f0;
} | 3.26 |
hbase_MetricsAssignmentManager_getSplitProcMetrics_rdh | /**
* Returns Set of common metrics for split procedure
*/
public ProcedureMetrics getSplitProcMetrics() {
return splitProcMetrics;
} | 3.26 |
hbase_MetricsAssignmentManager_getMoveProcMetrics_rdh | /**
* Returns Set of common metrics for move procedure
*/
public ProcedureMetrics getMoveProcMetrics() {
return moveProcMetrics;
} | 3.26 |
hbase_MetricsAssignmentManager_getCloseProcMetrics_rdh | /**
* Returns Set of common metrics for CloseRegionProcedure
*/
public ProcedureMetrics getCloseProcMetrics() {
return closeProcMetrics;
} | 3.26 |
hbase_MetricsAssignmentManager_getReopenProcMetrics_rdh | /**
* Returns Set of common metrics for reopen procedure
*/
public ProcedureMetrics getReopenProcMetrics() {
return reopenProcMetrics;
} | 3.26 |
hbase_RegionServerAccounting_getGlobalMemStoreHeapSize_rdh | /**
* Returns the global memstore on-heap size in the RegionServer
*/
public long getGlobalMemStoreHeapSize() {
return this.globalMemStoreHeapSize.sum();
} | 3.26 |
hbase_RegionServerAccounting_getGlobalMemStoreOffHeapSize_rdh | /**
* Returns the global memstore off-heap size in the RegionServer
*/
public long getGlobalMemStoreOffHeapSize() {
return this.globalMemStoreOffHeapSize.sum();
} | 3.26 |
hbase_RegionServerAccounting_setGlobalMemStoreLimits_rdh | // Called by the tuners.
void setGlobalMemStoreLimits(long newGlobalMemstoreLimit) {
if (this.memType == MemoryType.HEAP) {
this.globalMemStoreLimit = newGlobalMemstoreLimit;
this.f0 = ((long) (this.globalMemStoreLimit * this.globalMemStoreLimitLowMarkPercent));
} else {
this.globalOn... | 3.26 |
hbase_RegionServerAccounting_isAboveHighWaterMark_rdh | /**
* Return the FlushType if we are above the memstore high water mark
*
* @return the FlushType
*/
public FlushType isAboveHighWaterMark() {
// for onheap memstore we check if the global memstore size and the
// global heap overhead is greater than the global memstore limi... | 3.26 |
hbase_RegionServerAccounting_getGlobalMemStoreDataSize_rdh | /**
* Returns the global Memstore data size in the RegionServer
*/
public long getGlobalMemStoreDataSize() {
return globalMemStoreDataSize.sum();} | 3.26 |
hbase_RegionServerAccounting_isAboveLowWaterMark_rdh | /**
* Return the FlushType if we're above the low watermark
*
* @return the FlushType
*/
public FlushType isAboveLowWaterMark() {
// for onheap memstore we check if the global memstore size and the
// global heap overhead is greater than the global memstore lower mark limit
if (memType == MemoryType.HEA... | 3.26 |
hbase_AbstractRpcBasedConnectionRegistry_transformMetaRegionLocations_rdh | /**
* Simple helper to transform the result of getMetaRegionLocations() rpc.
*/
private static RegionLocations transformMetaRegionLocations(GetMetaRegionLocationsResponse resp) {
List<HRegionLocation> regionLocations = new
ArrayList<>();
resp.getMetaLocationsList().forEach(location -> regionLocations.add(... | 3.26 |
hbase_AbstractRpcBasedConnectionRegistry_groupCall_rdh | /**
* send requests concurrently to hedgedReadsFanout end points. If any of the request is succeeded,
* we will complete the future and quit. If all the requests in one round are failed, we will
* start another round to send requests concurrently tohedgedReadsFanout end points. If all end
* points have been tried a... | 3.26 |
hbase_ScheduledChore_toString_rdh | /**
* A summation of this chore in human readable format. Downstream users should not presume parsing
* of this string can relaibly be done between versions. Instead, they should rely on the public
* accessor methods to get the information they desire.
*/
@InterfaceAudience.Private
@Override
public String toString(... | 3.26 |
hbase_ScheduledChore_onChoreMissedStartTime_rdh | /**
* Notify the ChoreService that this chore has missed its start time. Allows the ChoreService to
* make the decision as to whether or not it would be worthwhile to increase the number of core
* pool threads
*/
private synchronized void onChoreMissedStartTime() {
if (choreService != null) {
choreServ... | 3.26 |
hbase_ScheduledChore_getInitialDelay_rdh | /**
* Returns initial delay before executing chore in getTimeUnit() units
*/
public long getInitialDelay() {
return initialDelay;
} | 3.26 |
hbase_ScheduledChore_getPeriod_rdh | /**
* Returns period to execute chore in getTimeUnit() units
*/
public int getPeriod() {
return period;
} | 3.26 |
hbase_ScheduledChore_updateTimeTrackingBeforeRun_rdh | /**
* Update our time tracking members. Called at the start of an execution of this chore's run()
* method so that a correct decision can be made as to whether or not we missed the start time
*/
private synchronized void updateTimeTrackingBeforeRun() {
timeOfLastRun =
timeOfThisRun;
timeOfThisRun = Env... | 3.26 |
hbase_ScheduledChore_getTimeBetweenRuns_rdh | /**
* Return how long in millis has it been since this chore last run. Useful for checking if the
* chore has missed its scheduled start time by too large of a margin
*/
synchronized long getTimeBetweenRuns() {
return timeOfThisRun - timeOfLastRun;
} | 3.26 |
hbase_ScheduledChore_isScheduled_rdh | /**
* Returns true when this Chore is scheduled with a ChoreService
*/
public synchronized boolean isScheduled() {
return (choreService != null) && choreService.isChoreScheduled(this);
} | 3.26 |
hbase_ScheduledChore_cleanup_rdh | /**
* Override to run cleanup tasks when the Chore encounters an error and must stop running
*/
protected void cleanup() {} | 3.26 |
hbase_ScheduledChore_isValidTime_rdh | /**
* Return true if time is earlier or equal to current time
*/
private synchronized boolean isValidTime(final long time) {
return (time > 0) && (time <= EnvironmentEdgeManager.currentTime());
} | 3.26 |
hbase_ScheduledChore_missedStartTime_rdh | /**
* Returns true when the time between runs exceeds the acceptable threshold
*/
private synchronized boolean missedStartTime() {
return (isValidTime(timeOfLastRun) && isValidTime(timeOfThisRun)) && (getTimeBetweenRuns() > getMaximumAllowedTimeBetweenRuns());} | 3.26 |
hbase_ScheduledChore_getMaximumAllowedTimeBetweenRuns_rdh | /**
* Returns max allowed time in millis between runs.
*/
private double getMaximumAllowedTimeBetweenRuns() {
// Threshold used to determine if the Chore's current run started too late
return 1.5 *
timeUnit.toMillis(period);
} | 3.26 |
hbase_ScheduledChore_shutdown_rdh | /**
* Completely shutdown the ScheduleChore, which means we will call cleanup and you should not
* schedule it again.
* <p/>
* This is another path to cleanup the chore, comparing to stop the stopper instance passed in.
*/
public synchronized void shutdown(boolean mayInterruptIfRunning) {
cancel(mayInterruptIfRunn... | 3.26 |
hbase_ScheduledChore_m0_rdh | /**
* Override to run a task before we start looping.
*
* @return true if initial chore was successful
*/
protected boolean m0() {
// Default does nothing
return true;
} | 3.26 |
hbase_ScheduledChore_triggerNow_rdh | /**
* Returns false when the Chore is not currently scheduled with a ChoreService
*/
public synchronized boolean triggerNow() {
if (choreService == null) {
return false;
}
choreService.triggerNow(this);
return true;
} | 3.26 |
hbase_WAL_m0_rdh | /**
* Used to initialize the WAL. Usually this is for creating the first writer.
*/
default void m0() throws IOException {
} | 3.26 |
hbase_WAL_getKey_rdh | /**
* Gets the key
*/
public WALKeyImpl getKey() {
return key;
} | 3.26 |
hbase_WAL_sync_rdh | /**
*
* @param txid
* Transaction id to sync to.
* @param forceSync
* Flag to force sync rather than flushing to the buffer. Example - Hadoop hflush
* vs hsync.
* @throws when
* timeout, it would throw {@link WALSyncTimeoutIOException}.
*/
default void sync(long txid, boolean forceSync) throws IOExcept... | 3.26 |
hbase_WAL_getEdit_rdh | /**
* Gets the edit
*/
public WALEdit getEdit() {return edit;
} | 3.26 |
hbase_ServerCrashProcedure_zkCoordinatedSplitMetaLogs_rdh | /**
* Split hbase:meta logs using 'classic' zk-based coordination. Superceded by procedure-based WAL
* splitting.
*
* @see #createSplittingWalProcedures(MasterProcedureEnv, boolean)
*/
private void zkCoordinatedSplitMetaLogs(MasterProcedureEnv env) throws IOException {
LOG.debug("Splitting meta WALs {}", this)... | 3.26 |
hbase_ServerCrashProcedure_getRegionsOnCrashedServer_rdh | /**
* Returns List of Regions on crashed server.
*/
List<RegionInfo> getRegionsOnCrashedServer(MasterProcedureEnv env) {
return env.getMasterServices().getAssignmentManager().getRegionsOnServer(serverName);
} | 3.26 |
hbase_ServerCrashProcedure_isMatchingRegionLocation_rdh | /**
* Moved out here so can be overridden by the HBCK fix-up SCP to be less strict about what it will
* tolerate as a 'match'.
*
* @return True if the region location in <code>rsn</code> matches that of this crashed server.
*/
protected boolean isMatchingRegionLocation(RegionStateNode rsn) {
return this.server... | 3.26 |
hbase_ServerCrashProcedure_zkCoordinatedSplitLogs_rdh | /**
* Split logs using 'classic' zk-based coordination. Superceded by procedure-based WAL splitting.
*
* @see #createSplittingWalProcedures(MasterProcedureEnv, boolean)
*/
private void zkCoordinatedSplitLogs(final MasterProcedureEnv env) throws IOException {
LOG.debug("Splitting WALs {}", this);
MasterWalMa... | 3.26 |
hbase_ServerCrashProcedure_assignRegions_rdh | /**
* Assign the regions on the crashed RS to other Rses.
* <p/>
* In this method we will go through all the RegionStateNodes of the give regions to find out
* whether there is already an TRSP for the region, if so we interrupt it and let it retry on
... | 3.26 |
hbase_Abortable_abort_rdh | /**
* It just call another abort method and the Throwable parameter is null.
*
* @param why
* Why we're aborting.
* @see Abortable#abort(String, Throwable)
*/
default void abort(String why) {
abort(why, null);
} | 3.26 |
hbase_AbstractHBaseTool_doStaticMain_rdh | /**
* Call this from the concrete tool class's main function.
*/
protected void doStaticMain(String[] args) {
int ret;
try {
ret = ToolRunner.run(HBaseConfiguration.create(), this, args);
} catch (Exception ex) {
LOG.error("Error running command-line tool", ex);
ret = EXIT_FAILURE;
}
System.exit(ret);
} | 3.26 |
hbase_AbstractHBaseTool_parseLong_rdh | /**
* Parse a number and enforce a range.
*/
public static long parseLong(String s, long minValue, long maxValue) {
long v11 = Long.parseLong(s);
if ((v11 < minValue) || (v11 > maxValue)) {
throw new IllegalArgumentException(((((("The value " + v11) + " is out of range [") + minValue) + ", ") + maxValue) + "]");}
r... | 3.26 |
hbase_AbstractHBaseTool_newParser_rdh | /**
* Create the parser to use for parsing and validating the command line. Since commons-cli lacks
* the capability to validate arbitrary combination of options, it may be helpful to bake custom
* logic into a specialized parser implementation. See LoadTestTool for examples.
*
* @return a new parser specific to t... | 3.26 |
hbase_AbstractPositionedByteRange_setOffset_rdh | /**
* Update the beginning of this range. {@code offset + length} may not be greater than
* {@code bytes.length}. Resets {@code position} to 0. the new start of this range.
*
* @return this.
*/
@Override
public PositionedByteRange setOffset(int offset) {
this.position = 0;
super.setOffset(offset);
re... | 3.26 |
hbase_AbstractPositionedByteRange_get_rdh | // java boilerplate
@Override
public PositionedByteRange get(int index, byte[] dst) {
super.get(index, dst);
return this;
} | 3.26 |
hbase_AbstractPositionedByteRange_setLength_rdh | /**
* Update the length of this range. {@code offset + length} should not be greater than
* {@code bytes.length}. If {@code position} is greater than the new {@code length}, sets
* {@code position} to {@code length}. The new length of this range.
*
* @return this.
*/
@Override
public PositionedByteRange setLength... | 3.26 |
hbase_StoreScanner_selectScannersFrom_rdh | /**
* Filters the given list of scanners using Bloom filter, time range, and TTL.
* <p>
* Will be overridden by testcase so declared as protected.
*/
protected List<KeyValueScanner> selectScannersFrom(HStore store, List<? extends KeyValueScanner> allScanners) {
boolean memOnly;
boolean filesOnly;
if (scan instanceo... | 3.26 |
hbase_StoreScanner_updateReaders_rdh | // Implementation of ChangedReadersObserver
@Override
public void updateReaders(List<HStoreFile> sfs, List<KeyValueScanner> memStoreScanners) throws IOException {
if (C... | 3.26 |
hbase_StoreScanner_seekAsDirection_rdh | /**
* Do a reseek in a normal StoreScanner(scan forward)
*
* @return true if scanner has values left, false if end of scanner
*/
protected boolean seekAsDirection(Cell kv) throws IOException {
... | 3.26 |
hbase_StoreScanner_parallelSeek_rdh | /**
* Seek storefiles in parallel to optimize IO latency as much as possible
*
* @param scanners
* the list {@link KeyValueScanner}s to be read from
* @param kv
* the KeyValue on which the operation is being requested
*/
private void parallelSeek(final List<? extends KeyValueScanner> scanners, final Cell kv)... | 3.26 |
hbase_StoreScanner_getAllScannersForTesting_rdh | /**
* Used in testing.
*
* @return all scanners in no particular order
*/
List<KeyValueScanner> getAllScannersForTesting() {
List<KeyValueScanner> allScanners = new ArrayList<>();
KeyValueScanner current = heap.getCurrentForTesting();
if (current != null)
allScanners.add(current);
for (KeyV... | 3.26 |
hbase_StoreScanner_getEstimatedNumberOfKvsScanned_rdh | /**
* Returns The estimated number of KVs seen by this scanner (includes some skipped KVs).
*/
public long getEstimatedNumberOfKvsScanned() {return this.kvsScanned;
} | 3.26 |
hbase_StoreScanner_m0_rdh | /**
* Returns if top of heap has changed (and KeyValueHeap has to try the next KV)
*/
protected final boolean m0() throws IOException {
// here we can make sure that we have a Store instance so no null check on store.
Cell lastTop = heap.peek();
// When we have the scan object, should we not pass it to g... | 3.26 |
hbase_StoreScanner_next_rdh | /**
* Get the next row of values from this Store.
*
* @return true if there are more rows, false if scanner is done
*/
@Override
public boolean next(List<Cell> outResult, ScannerContext scannerContext) throws IOException {
if (scannerContext == null) {
throw new IllegalArgumentException("Scanner contex... | 3.26 |
hbase_StoreScanner_trySkipToNextColumn_rdh | /**
* See {@link org.apache.hadoop.hbase.regionserver.StoreScanner#trySkipToNextRow(Cell)}
*
* @param cell
* current cell
* @return true means skip to next column, false means not
*/
protected boolean trySkipToNextColumn(Cell cell) throws IOException {
Cell nextCell = null;
// used to guard against a ch... | 3.26 |
hbase_StoreScanner_needToReturn_rdh | /**
* If the top cell won't be flushed into disk, the new top cell may be changed after
* #reopenAfterFlush. Because the older top cell only exist in the memstore scanner but the
* memstore scanner is replaced by hfile scanner after #reopenAfterFlush. If the row of top cell
* is changed, we should return the curren... | 3.26 |
hbase_StoreScanner_checkScanOrder_rdh | /**
* Check whether scan as expected order
*/
protected void checkScanOrder(Cell prevKV, Cell kv, CellComparator comparator) throws IOException {
// Check that the heap gives us KVs in an increasing order.
assert ((prevKV == null) || (comparator == null)) || (comparator.compare(prevKV, kv) <= 0) : (((("Key " ... | 3.26 |
hbase_StoreScanner_trySkipToNextRow_rdh | /**
* See if we should actually SEEK or rather just SKIP to the next Cell (see HBASE-13109).
* ScanQueryMatcher may issue SEEK hints, such as seek to next column, next row, or seek to an
* arbitrary seek key. This method decides whether a seek is the most efficient _actual_ way to
* get us to the requested cell (SE... | 3.26 |
hbase_ModifyNamespaceProcedure_prepareModify_rdh | /**
* Action before any real action of adding namespace.
*/
private boolean prepareModify(final MasterProcedureEnv env) throws IOException {
if (!getTableNamespaceManager(env).doesNamespaceExist(newNsDescriptor.getName())) {
setFailure("master-modify-namespace", new NamespaceNotFoundException(newNsDescrip... | 3.26 |
hbase_BinaryComparator_toByteArray_rdh | /**
* Returns The comparator serialized using pb
*/
@Override
public byte[] toByteArray() {
ComparatorProtos.BinaryComparator.Builder v0 = ComparatorProtos.BinaryComparator.newBuilder();
v0.setComparable(ProtobufUtil.toByteArrayComparable(this.value));
return v0.build().toByteArray();
}
/**
* Parse a s... | 3.26 |
hbase_BinaryComparator_areSerializedFieldsEqual_rdh | /**
* Returns true if and only if the fields of the comparator that are serialized are equal to the
* corresponding fields in other. Used for testing.
*/
@Override
boolean areSerializedFieldsEqual(ByteArrayComparable other) {
if (other == this) {
return true;
}if (!(other instanceof BinaryComparator)... | 3.26 |
hbase_ServerRpcController_setFailedOn_rdh | /**
* Sets an exception to be communicated back to the
* {@link org.apache.hbase.thirdparty.com.google.protobuf.Service} client.
*
* @param ioe
* the exception encountered during execution of the service method
*/
public void setFailedOn(IOException ioe) {
serviceException = ioe;
setFailed(StringUtils.s... | 3.26 |
hbase_ServerRpcController_failedOnException_rdh | /**
* Returns whether or not a server exception was generated in the prior RPC invocation.
*/
public boolean failedOnException() {
return serviceException != null;
} | 3.26 |
hbase_ServerRpcController_checkFailed_rdh | /**
* Throws an IOException back out if one is currently stored.
*/
public void checkFailed() throws IOException {
if (failedOnException()) {
throw getFailedOn();
}
} | 3.26 |
hbase_ServerRpcController_getFailedOn_rdh | /**
* Returns any exception thrown during service method invocation, or {@code null} if no exception
* was thrown. This can be used by clients to receive exceptions generated by RPC calls, even when
* {@link RpcCallback}s are used and no
* {@link org.apache.hbase.thirdparty.com.google.protobuf.ServiceException} is ... | 3.26 |
hbase_AsyncAdminBuilder_setMaxRetries_rdh | /**
* Set the max retry times for an admin operation. Usually it is the max attempt times minus 1.
* Operation timeout and max attempt times(or max retry times) are both limitations for retrying,
* we will stop retrying when we reach any of the limitations.
*
* @return this for invocation chaining
*/
default Asyn... | 3.26 |
hbase_ZKSplitLogManagerCoordination_setIgnoreDeleteForTesting_rdh | /**
* Temporary function that is used by unit tests only
*/
public void setIgnoreDeleteForTesting(boolean b) {
ignoreZKDeleteForTesting = b;
} | 3.26 |
hbase_ZKSplitLogManagerCoordination_handleUnassignedTask_rdh | /**
* It is possible for a task to stay in UNASSIGNED state indefinitely - say SplitLogManager wants
* to resubmit a task. It forces the task to UNASSIGNED state but it dies before it could create
* the RESCAN task node to signal the SplitLogWorkers to pick up the task. To prevent this
* scenario the SplitLogManage... | 3.26 |
hbase_ZKSplitLogManagerCoordination_rescan_rdh | /**
* signal the workers that a task was resubmitted by creating the RESCAN node.
*/
private void rescan(long retries) {
// The RESCAN node will be deleted almost immediately by the
// SplitLogManager as soon as it is created because it is being
// created in the DONE state. This behavior prevents a bui... | 3.26 |
hbase_AsyncAdmin_modifyTable_rdh | /**
* Modify an existing table, more IRB friendly version.
*
* @param desc
* modified description of the table
*/
default CompletableFuture<Void> modifyTable(TableDescriptor desc) {
return modifyTable(desc, true);
} | 3.26 |
hbase_AsyncAdmin_splitSwitch_rdh | /**
* Turn the Split switch on or off.
*
* @param enabled
* enabled or not
* @return Previous switch value wrapped by a {@link CompletableFuture}
*/
default CompletableFuture<Boolean> splitSwitch(boolean enabled) {
return splitSwitch(enabled, false);
} | 3.26 |
hbase_AsyncAdmin_restoreSnapshot_rdh | /**
* Restore the specified snapshot on the original table. (The table must be disabled) If
* 'takeFailSafeSnapshot' is set to true, a snapshot of the current table is taken before
* executing the restore operation. In case of restore failure, the failsafe snapshot will be
* restored. If the restore completes witho... | 3.26 |
hbase_AsyncAdmin_balancerSwitch_rdh | /**
* Turn the load balancer on or off.
*
* @param on
* Set to <code>true</code> to enable, <code>false</code> to disable.
* @return Previous balancer value wrapped by a {@link CompletableFuture}.
*/
default CompletableFuture<Boolean> balancerSwitch(boolean on) {
return balancerSwitch(on, false);
} | 3.26 |
hbase_AsyncAdmin_compact_rdh | /**
* Compact a table. When the returned CompletableFuture is done, it only means the compact request
* was sent to HBase and may need some time to finish the compact operation. Throws
* {@link org.apache.hadoop.hbase.TableNotFoundException} if table not found.
*
* @param tableName
* table to compact
*/
defaul... | 3.26 |
hbase_AsyncAdmin_getMasterCoprocessorNames_rdh | /**
* Returns a list of master coprocessors wrapped by {@link CompletableFuture}
*/
default CompletableFuture<List<String>> getMasterCoprocessorNames() {
return getClusterMetrics(EnumSet.of(Option.MASTER_COPROCESSORS)).thenApply(ClusterMetrics::getMasterCoprocessorNames);
} | 3.26 |
hbase_AsyncAdmin_cloneSnapshot_rdh | /**
* Create a new table by cloning the snapshot content.
*
* @param snapshotName
* name of the snapshot to be cloned
* @param tableName
* name of the table where the snapshot will be restored
* @param restoreAcl
* <code>true</code> to restore acl of snapshot
*/
default CompletableFuture<Void> cloneSnaps... | 3.26 |
hbase_AsyncAdmin_m2_rdh | /**
* Compact a column family within a table. When the returned CompletableFuture is done, it only
* means the compact request was sent to HBase and may need some time to finish the compact
* operation. Throws {@link org.apache.hadoop.hbase.TableNotFoundException} if table not found.
*
* @param tableName
* tabl... | 3.26 |
hbase_AsyncAdmin_snapshot_rdh | /**
* Create typed snapshot of the table. Snapshots are considered unique based on <b>the name of the
* snapshot</b>. Snapshots are taken sequentially even when requested concurrently, across all
* tables. Attempts to take a snapshot with the same name (even a different type or with different
* parameters) will fai... | 3.26 |
hbase_AsyncAdmin_getCompactionState_rdh | /**
* Get the current compaction state of a table. It could be in a major compaction, a minor
* compaction, both, or none.
*
* @param tableName
* table to examine
* @return the current compaction state wrapped by a {@link CompletableFuture}
*/
default CompletableFuture<CompactionState> getCompactionState(Table... | 3.26 |
hbase_AsyncAdmin_getRegionServers_rdh | /**
* Returns current live region servers list wrapped by {@link CompletableFuture}
*/
default CompletableFuture<Collection<ServerName>> getRegionServers() {
return getClusterMetrics(EnumSet.of(Option.SERVERS_NAME)).thenApply(ClusterMetrics::getServersName);
} | 3.26 |
hbase_AsyncAdmin_unassign_rdh | /**
* Unassign a region from current hosting regionserver. Region will then be assigned to a
* regionserver chosen at random. Region could be reassigned back to the same server. Use
* {@link #move(byte[], ServerName)} if you want to control the region movement.
*
* @param regionName
* Encoded or full name of re... | 3.26 |
hbase_AsyncAdmin_hasUserPermissions_rdh | /**
* Check if call user has specific permissions
*
* @param permissions
* the specific permission list
* @return True if user has the specific permissions
*/
default CompletableFuture<List<Boolean>> hasUserPermissions(List<Permission> permissions) {
return hasUserPermissions(null, permissions);
} | 3.26 |
hbase_AsyncAdmin_m3_rdh | /**
* Major compact a column family within a table. When the returned CompletableFuture is done, it
* only means the compact request was sent to HBase and may need some time to finish the compact
* operation. Throws {@link org.apache.hadoop.hbase.TableNotFoundException} if table not found for
* normal compaction. t... | 3.26 |
hbase_AsyncAdmin_getReplicationPeerSyncReplicationState_rdh | /**
* Get the current cluster state in a synchronous replication peer.
*
* @param peerId
* a short name that identifies the peer
* @return the current cluster state wrapped by a {@link CompletableFuture}.
*/
default CompletableFuture<SyncReplicationState> getReplicationPeerSyncReplicationState(String peerId) {
... | 3.26 |
hbase_AsyncAdmin_getMaster_rdh | /**
* Returns current master server name wrapped by {@link CompletableFuture}
*/
default CompletableFuture<ServerName> getMaster() {
return getClusterMetrics(EnumSet.of(Option.MASTER)).thenApply(ClusterMetrics::getMasterName);
} | 3.26 |
hbase_AsyncAdmin_listTableNames_rdh | /**
* List all of the names of userspace tables.
*
* @return a list of table names wrapped by a {@link CompletableFuture}.
* @see #listTableNames(Pattern, boolean)
*/
default CompletableFuture<List<TableName>> listTableNames() {
return listTableNames(false);
} | 3.26 |
hbase_AsyncAdmin_getBackupMasters_rdh | /**
* Returns current backup master list wrapped by {@link CompletableFuture}
*/
default CompletableFuture<Collection<ServerName>> getBackupMasters() {
return getClusterMetrics(EnumSet.of(Option.BACKUP_MASTERS)).thenApply(ClusterMetrics::getBackupMasterNames);
} | 3.26 |
hbase_AsyncAdmin_m5_rdh | /**
* Add a new replication peer for replicating data to slave cluster
*
* @param peerId
* a short name that identifies the peer
* @param peerConfig
* configuration for the replication slave cluster
*/default CompletableFuture<Void> m5(String peerId, ReplicationPeerConfig peerConfig) {
return addReplica... | 3.26 |
hbase_AsyncAdmin_getMasterInfoPort_rdh | /**
* Get the info port of the current master if one is available.
*
* @return master info port
*/
default CompletableFuture<Integer>
getMasterInfoPort() {
return getClusterMetrics(EnumSet.of(Option.MASTER_INFO_PORT)).thenApply(ClusterMetrics::getMasterInfoPort);
} | 3.26 |
hbase_AsyncAdmin_listDeadServers_rdh | /**
* List all the dead region servers.
*/default CompletableFuture<List<ServerName>> listDeadServers() {
return this.getClusterMetrics(EnumSet.of(Option.DEAD_SERVERS)).thenApply(ClusterMetrics::getDeadServerNames);
} | 3.26 |
hbase_AsyncAdmin_balanceRSGroup_rdh | /**
* Balance regions in the given RegionServer group
*
* @param groupName
* the group name
* @return BalanceResponse details about the balancer run
*/default CompletableFuture<BalanceResponse> balanceRSGroup(String groupName) {
return balanceRSGroup(groupName, BalanceRequest.defaultInstance());
} | 3.26 |
hbase_AsyncAdmin_replicationPeerModificationSwitch_rdh | /**
* Enable or disable replication peer modification.
* <p/>
* This is especially useful when you want to change the replication peer storage.
*
* @param on
* {@code true} means enable, otherwise disable
* @return the previous enable/disable state wrapped by a {@link CompletableFuture}
*/
default Completable... | 3.26 |
hbase_AsyncAdmin_majorCompact_rdh | /**
* Major compact a table. When the returned CompletableFuture is done, it only means the compact
* request was sent to HBase and may need some time to finish the compact operation. Throws
* {@link org.apache.hadoop.hbase.TableNotFoundException} if table not found.
*
* @param tableName
* table to major compac... | 3.26 |
hbase_AsyncAdmin_listUnknownServers_rdh | /**
* List all the unknown region servers.
*/
default CompletableFuture<List<ServerName>> listUnknownServers() {
return this.getClusterMetrics(EnumSet.of(Option.UNKNOWN_SERVERS)).thenApply(ClusterMetrics::getUnknownServerNames);
} | 3.26 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.