name
stringlengths 12
178
| code_snippet
stringlengths 8
36.5k
| score
float64 3.26
3.68
|
|---|---|---|
hbase_MasterObserver_postClearDeadServers_rdh | /**
* Called after clear dead region servers.
*/
default void postClearDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx, List<ServerName> servers, List<ServerName> notClearedServers) throws IOException
{} | 3.26 |
hbase_MasterObserver_postDisableReplicationPeer_rdh | /**
* Called after disable a replication peer
*
* @param peerId
* a short name that identifies the peer
*/
default void postDisableReplicationPeer(final ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId) throws IOException {
} | 3.26 |
hbase_MasterObserver_postGetConfiguredNamespacesAndTablesInRSGroup_rdh | /**
* Called after getting the configured namespaces and tables in the region server group.
*
* @param ctx
* the environment to interact with the framework and master
* @param groupName
* name of the region server group
*/
default void postGetConfiguredNamespacesAndTablesInRSGroup(final ObserverContext<MasterCoprocessorEnvironment> ctx, final String groupName) throws IOException {
} | 3.26 |
hbase_MasterObserver_postCreateTable_rdh | /**
* Called after the createTable operation has been requested. Called as part of create table RPC
* call.
*
* @param ctx
* the environment to interact with the framework and master
* @param desc
* the TableDescriptor for the table
* @param regions
* the initial regions created for the table
*/
default void postCreateTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, TableDescriptor desc, RegionInfo[] regions) throws IOException {
} | 3.26 |
hbase_MasterObserver_postLockHeartbeat_rdh | /**
* Called after heartbeat to a lock.
*
* @param ctx
* the environment to interact with the framework and master
*/
default void postLockHeartbeat(ObserverContext<MasterCoprocessorEnvironment> ctx) throws IOException {
} | 3.26 |
hbase_MasterObserver_postGetNamespaceDescriptor_rdh | /**
* Called after a getNamespaceDescriptor request has been processed.
*
* @param ctx
* the environment to interact with the framework and master
* @param ns
* the NamespaceDescriptor
*/
default void postGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns) throws IOException {
} | 3.26 |
hbase_MasterObserver_preMove_rdh | /**
* Called prior to moving a given region from one region server to another.
*
* @param ctx
* the environment to interact with the framework and master
* @param region
* the RegionInfo
* @param srcServer
* the source ServerName
* @param destServer
* the destination ServerName
*/
default void preMove(final ObserverContext<MasterCoprocessorEnvironment> ctx, final RegionInfo region, final ServerName srcServer, final ServerName destServer) throws IOException {
} | 3.26 |
hbase_MasterObserver_postRegionOffline_rdh | /**
* Called after the region has been marked offline.
*
* @param ctx
* the environment to interact with the framework and master
*/
default void postRegionOffline(final ObserverContext<MasterCoprocessorEnvironment> ctx, final RegionInfo regionInfo) throws IOException {
} | 3.26 |
hbase_MasterObserver_postRenameRSGroup_rdh | /**
* Called after rename rsgroup.
*
* @param ctx
* the environment to interact with the framework and master
* @param oldName
* old rsgroup name
* @param newName
* new rsgroup name
*/default void postRenameRSGroup(final ObserverContext<MasterCoprocessorEnvironment> ctx, final String oldName, final String newName) throws IOException
{
} | 3.26 |
hbase_MasterObserver_postRecommissionRegionServer_rdh | /**
* Called after recommission region server.
*/
default void postRecommissionRegionServer(ObserverContext<MasterCoprocessorEnvironment> ctx, ServerName server, List<byte[]> encodedRegionNames) throws IOException {
} | 3.26 |
hbase_MasterObserver_postMoveTables_rdh | /**
* Called after servers are moved to target region server group
*
* @param ctx
* the environment to interact with the framework and master
* @param tables
* set of tables to move
* @param targetGroup
* name of group
*/
default void postMoveTables(final ObserverContext<MasterCoprocessorEnvironment> ctx, Set<TableName> tables, String targetGroup) throws IOException {} | 3.26 |
hbase_MasterObserver_preDecommissionRegionServers_rdh | /**
* Called before decommission region servers.
*/
default void preDecommissionRegionServers(ObserverContext<MasterCoprocessorEnvironment> ctx, List<ServerName> servers, boolean offload) throws IOException {
} | 3.26 |
hbase_MasterObserver_preCreateNamespace_rdh | /**
* Called before a new namespace is created by {@link org.apache.hadoop.hbase.master.HMaster}.
*
* @param ctx
* the environment to interact with the framework and master
* @param ns
* the NamespaceDescriptor for the table
*/
default void preCreateNamespace(final ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)
throws IOException {
} | 3.26 |
hbase_MasterObserver_m9_rdh | /**
* Called before a getTableDescriptors request has been processed.
*
* @param ctx
* the environment to interact with the framework and master
* @param tableNamesList
* the list of table names, or null if querying for all
* @param descriptors
* an empty list, can be filled with what to return in coprocessor
* @param regex
* regular expression used for filtering the table names
*/
default void m9(ObserverContext<MasterCoprocessorEnvironment> ctx, List<TableName> tableNamesList, List<TableDescriptor> descriptors, String regex) throws IOException {
} | 3.26 |
hbase_MasterObserver_postIsRpcThrottleEnabled_rdh | /**
* Called after getting if is rpc throttle enabled.
*
* @param ctx
* the coprocessor instance's environment
* @param rpcThrottleEnabled
* the rpc throttle enabled value
*/
default void postIsRpcThrottleEnabled(final ObserverContext<MasterCoprocessorEnvironment> ctx, final boolean rpcThrottleEnabled) throws IOException {
} | 3.26 |
hbase_MasterObserver_preRequestLock_rdh | /**
* Called before new LockProcedure is queued.
*
* @param ctx
* the environment to interact with the framework and master
*/
default void preRequestLock(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace, TableName tableName, RegionInfo[] regionInfos, String description) throws IOException {
} | 3.26 |
hbase_MasterObserver_postGetReplicationPeerConfig_rdh | /**
* Called after get the configured ReplicationPeerConfig for the specified peer
*
* @param peerId
* a short name that identifies the peer
*/
default void postGetReplicationPeerConfig(final ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId) throws IOException {
} | 3.26 |
hbase_MasterObserver_preGetTableNames_rdh | /**
* Called before a getTableNames request has been processed.
*
* @param ctx
* the environment to interact with the framework and master
* @param descriptors
* an empty list, can be filled with what to return by coprocessor
* @param regex
* regular expression used for filtering the table names
*/default void preGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx, List<TableDescriptor> descriptors, String regex) throws IOException {
} | 3.26 |
hbase_MasterObserver_postTruncateRegion_rdh | /**
* Called after the truncate region procedure is called.
*
* @param c
* The environment to interact with the framework and master
* @param regionInfo
* The Region being truncated
*/
@SuppressWarnings("unused")
default void postTruncateRegion(final ObserverContext<MasterCoprocessorEnvironment> c, RegionInfo regionInfo) {
} | 3.26 |
hbase_MasterObserver_postCompletedMergeRegionsAction_rdh | /**
* called after the regions merge.
*
* @param ctx
* the environment to interact with the framework and master
*/
default void postCompletedMergeRegionsAction(final ObserverContext<MasterCoprocessorEnvironment> ctx, final RegionInfo[] regionsToMerge, final RegionInfo mergedRegion) throws IOException {
} | 3.26 |
hbase_MasterObserver_postModifyTable_rdh | /**
* Called after the modifyTable operation has been requested. Called as part of modify table RPC
* call.
*
* @param ctx
* the environment to interact with the framework and master
* @param tableName
* the name of the table
* @param oldDescriptor
* descriptor of table before modify operation happened
* @param currentDescriptor
* current TableDescriptor of the table
*/
default void postModifyTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableName tableName, TableDescriptor oldDescriptor, TableDescriptor currentDescriptor) throws IOException {
} | 3.26 |
hbase_MasterObserver_postMasterStoreFlush_rdh | /**
* Called after the master local region memstore is flushed to disk.
*
* @param ctx
* the environment to interact with the framework and master
*/
default void postMasterStoreFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx) throws IOException {
} | 3.26 |
hbase_MasterObserver_postMove_rdh | /**
* Called after the region move has been requested.
*
* @param ctx
* the environment to interact with the framework and master
* @param region
* the RegionInfo
* @param srcServer
* the source ServerName
* @param destServer
* the destination ServerName
*/
default void postMove(final ObserverContext<MasterCoprocessorEnvironment> ctx, final RegionInfo region, final
ServerName srcServer, final ServerName
destServer)
throws IOException {
} | 3.26 |
hbase_MasterObserver_m5_rdh | /**
* Called prior to requesting rebalancing of the cluster regions, though after the initial checks
* for regions in transition and the balance switch flag.
*
* @param ctx
* the environment to interact with the framework and master
* @param request
* the request used to trigger the balancer
*/
default void m5(final ObserverContext<MasterCoprocessorEnvironment> ctx, BalanceRequest request) throws IOException {
} | 3.26 |
hbase_MasterObserver_postHasUserPermissions_rdh | /**
* Called after checking if user has permissions.
*
* @param ctx
* the coprocessor instance's environment
* @param userName
* the user name
* @param permissions
* the permission list
*/
default void postHasUserPermissions(ObserverContext<MasterCoprocessorEnvironment> ctx, String
userName, List<Permission> permissions) throws IOException {
} | 3.26 |
hbase_MasterObserver_postListNamespaces_rdh | /**
* Called after a listNamespaces request has been processed.
*
* @param ctx
* the environment to interact with the framework and master
* @param namespaces
* the list of namespaces about to be returned
* @throws IOException
* if something went wrong
*/
default void postListNamespaces(ObserverContext<MasterCoprocessorEnvironment> ctx, List<String> namespaces) throws IOException {
} | 3.26 |
hbase_MasterObserver_preMergeRegionsCommitAction_rdh | /**
* This will be called before update META step as part of regions merge transaction.
*
* @param ctx
* the environment to interact with the framework and master
* @param metaEntries
* mutations to execute on hbase:meta atomically with regions merge updates.
* Any puts or deletes to execute on hbase:meta can be added to the mutations.
*/
default void preMergeRegionsCommitAction(final ObserverContext<MasterCoprocessorEnvironment> ctx, final RegionInfo[] regionsToMerge, @MetaMutationAnnotation
List<Mutation> metaEntries) throws IOException {
} | 3.26 |
hbase_MasterObserver_preTruncateRegionAction_rdh | /**
* Called before the region is truncated.
*
* @param c
* The environment to interact with the framework and master
* @param regionInfo
* The Region being truncated
*/
@SuppressWarnings("unused")
default void preTruncateRegionAction(final ObserverContext<MasterCoprocessorEnvironment> c, final RegionInfo regionInfo) {
} | 3.26 |
hbase_MasterObserver_m11_rdh | /**
* Called before revoking user permissions.
*
* @param ctx
* the coprocessor instance's environment
* @param userPermission
* the user and permissions
*/
default void m11(ObserverContext<MasterCoprocessorEnvironment> ctx, UserPermission userPermission) throws IOException {
} | 3.26 |
hbase_MasterObserver_preListTablesInRSGroup_rdh | /**
* Called before listing all tables in the region server group.
*
* @param ctx
* the environment to interact with the framework and master
* @param groupName
* name of the region server group
*/
default void preListTablesInRSGroup(final ObserverContext<MasterCoprocessorEnvironment> ctx, final String groupName) throws IOException {
} | 3.26 |
hbase_MasterObserver_preGetProcedures_rdh | /**
* Called before a getProcedures request has been processed.
*
* @param ctx
* the environment to interact with the framework and master
*/
default void preGetProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx) throws IOException {
} | 3.26 |
hbase_MasterObserver_postCompletedTruncateTableAction_rdh | /**
* Called after {@link org.apache.hadoop.hbase.master.HMaster} truncates a table. Called as part
* of truncate table procedure and it is async to the truncate RPC call.
*
* @param ctx
* the environment to interact with the framework and master
* @param tableName
* the name of the table
*/
default void postCompletedTruncateTableAction(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableName tableName) throws IOException {
} | 3.26 |
hbase_MasterObserver_m1_rdh | /**
* Called before {@link org.apache.hadoop.hbase.master.HMaster} truncates a table. Called as part
* of truncate table procedure and it is async to the truncate RPC call.
*
* @param ctx
* the environment to interact with the framework and master
* @param tableName
* the name of the table
*/
default void m1(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableName tableName) throws IOException {
} | 3.26 |
hbase_MasterObserver_postTruncateTable_rdh | /**
* Called after the truncateTable operation has been requested. Called as part of truncate table
* RPC call. The truncate is synchronous, so this method will be called when the truncate
* operation is terminated.
*
* @param ctx
* the environment to interact with the framework and master
* @param tableName
* the name of the table
*/
default void postTruncateTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName) throws IOException {
} | 3.26 |
hbase_MasterObserver_preModifyTableStoreFileTracker_rdh | /**
* Called prior to modifying a table's store file tracker. Called as part of modify table store
* file tracker RPC call.
*
* @param ctx
* the environment to interact with the framework and master
* @param tableName
* the name of the table
* @param dstSFT
* the store file tracker
* @return the store file tracker
*/
default String preModifyTableStoreFileTracker(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableName tableName, String dstSFT) throws IOException {
return dstSFT;
} | 3.26 |
hbase_MasterObserver_preCreateTableAction_rdh | /**
* Called before a new table is created by {@link org.apache.hadoop.hbase.master.HMaster}. Called
* as part of create table procedure and it is async to the create RPC call.
*
* @param ctx
* the environment to interact with the framework and master
* @param desc
* the TableDescriptor for the table
* @param regions
* the initial regions created for the table
*/
default void preCreateTableAction(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableDescriptor desc, final RegionInfo[] regions) throws IOException {
} | 3.26 |
hbase_MasterObserver_preRemoveServers_rdh | /**
* Called before servers are removed from rsgroup
*
* @param ctx
* the environment to interact with the framework and master
* @param servers
* set of decommissioned servers to remove
*/
default void preRemoveServers(final ObserverContext<MasterCoprocessorEnvironment> ctx, Set<Address>
servers) throws IOException {
} | 3.26 |
hbase_MasterObserver_preAddReplicationPeer_rdh | /**
* Called before add a replication peer
*
* @param ctx
* the environment to interact with the framework and master
* @param peerId
* a short name that identifies the peer
* @param peerConfig
* configuration for the replication peer
*/
default void preAddReplicationPeer(final ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId, ReplicationPeerConfig peerConfig) throws IOException {
} | 3.26 |
hbase_MasterObserver_preBalanceRSGroup_rdh | /**
* Called before a region server group is removed
*
* @param ctx
* the environment to interact with the framework and master
* @param groupName
* group name
*/
default void preBalanceRSGroup(final ObserverContext<MasterCoprocessorEnvironment> ctx, String groupName, BalanceRequest request) throws IOException {
} | 3.26 |
hbase_MasterObserver_preMoveServers_rdh | /**
* Called before servers are moved to target region server group
*
* @param ctx
* the environment to interact with the framework and master
* @param servers
* set of servers to move
* @param targetGroup
* destination group
*/
default void preMoveServers(final ObserverContext<MasterCoprocessorEnvironment> ctx, Set<Address> servers, String targetGroup) throws IOException {
} | 3.26 |
hbase_MasterObserver_postUpdateRSGroupConfig_rdh | /**
* Called after update rsgroup config.
*
* @param ctx
* the environment to interact with the framework and master
* @param groupName
* the group name
* @param configuration
* new configuration of the group name to be set
*/
default void postUpdateRSGroupConfig(final ObserverContext<MasterCoprocessorEnvironment> ctx, final String groupName, final Map<String, String> configuration) throws IOException {} | 3.26 |
hbase_MasterObserver_preDeleteSnapshot_rdh | /**
* Called before a snapshot is deleted. Called as part of deleteSnapshot RPC call.
*
* @param ctx
* the environment to interact with the framework and master
* @param snapshot
* the SnapshotDescriptor of the snapshot to delete
*/
default void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot) throws IOException {
} | 3.26 |
hbase_MasterObserver_preSplitRegionBeforeMETAAction_rdh | /**
* This will be called before update META step as part of split transaction.
*
* @param ctx
* the environment to interact with the framework and master
*/default void preSplitRegionBeforeMETAAction(final ObserverContext<MasterCoprocessorEnvironment> ctx, final byte[] splitKey, final List<Mutation> metaEntries) throws IOException {
} | 3.26 |
hbase_MasterObserver_preCloneSnapshot_rdh | /**
* Called before a snapshot is cloned. Called as part of restoreSnapshot RPC call.
*
* @param ctx
* the environment to interact with the framework and master
* @param snapshot
* the SnapshotDescriptor for the snapshot
* @param tableDescriptor
* the TableDescriptor of the table to create
*/
default void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final TableDescriptor tableDescriptor) throws IOException {
} | 3.26 |
hbase_MasterObserver_preDeleteTableAction_rdh | /**
* Called before {@link org.apache.hadoop.hbase.master.HMaster} deletes a table. Called as part of
* delete table procedure and it is async to the delete RPC call.
*
* @param ctx
* the environment to interact with the framework and master
* @param tableName
* the name of the table
*/
default void preDeleteTableAction(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName) throws IOException {
} | 3.26 |
hbase_MasterObserver_postCompletedSplitRegionAction_rdh | /**
* Called after the region is split.
*
* @param c
* the environment to interact with the framework and master
* @param regionInfoA
* the left daughter region
* @param regionInfoB
* the right daughter region
*/
default void postCompletedSplitRegionAction(final ObserverContext<MasterCoprocessorEnvironment> c, final RegionInfo regionInfoA, final RegionInfo regionInfoB) throws IOException {
} | 3.26 |
hbase_MasterObserver_m4_rdh | /**
* Called after the region unassignment has been requested.
*
* @param ctx
* the environment to interact with the framework and master
*/
default void m4(final ObserverContext<MasterCoprocessorEnvironment> ctx, final RegionInfo regionInfo) throws IOException {
} | 3.26 |
hbase_MasterObserver_preListNamespaceDescriptors_rdh | /**
* Called before a listNamespaceDescriptors request has been processed.
*
* @param ctx
* the environment to interact with the framework and master
* @param descriptors
* an empty list, can be filled with what to return by coprocessor
*/
default void preListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<NamespaceDescriptor> descriptors) throws IOException
{
} | 3.26 |
hbase_MasterObserver_postSetTableQuota_rdh | /**
* Called after the quota for the table is stored.
*
* @param ctx
* the environment to interact with the framework and master
* @param tableName
* the name of the table
* @param quotas
* the resulting quota for the table
*/
default void postSetTableQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableName tableName,
final GlobalQuotaSettings quotas) throws IOException {
} | 3.26 |
hbase_MasterObserver_preSetNamespaceQuota_rdh | /**
* Called before the quota for the namespace is stored.
*
* @param ctx
* the environment to interact with the framework and master
* @param namespace
* the name of the namespace
* @param quotas
* the current quota for the namespace
*/
default void preSetNamespaceQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx, final String namespace, final GlobalQuotaSettings quotas) throws IOException {
} | 3.26 |
hbase_MasterObserver_postListReplicationPeers_rdh | /**
* Called after list replication peers.
*
* @param ctx
* the environment to interact with the framework and master
* @param regex
* The regular expression to match peer id
*/
default void postListReplicationPeers(final ObserverContext<MasterCoprocessorEnvironment> ctx, String regex) throws IOException {
} | 3.26 |
hbase_MasterObserver_preTableFlush_rdh | /**
* Called before the table memstore is flushed to disk.
*
* @param ctx
* the environment to interact with the framework and master
* @param tableName
* the name of the table
*/
default void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment>
ctx, final TableName tableName) throws IOException {
} | 3.26 |
hbase_MasterObserver_preMasterInitialization_rdh | /**
* Call before the master initialization is set to true.
* {@link org.apache.hadoop.hbase.master.HMaster} process.
*/
default void preMasterInitialization(final ObserverContext<MasterCoprocessorEnvironment> ctx) throws
IOException {
} | 3.26 |
hbase_MasterObserver_preSwitchRpcThrottle_rdh | /**
* Called before switching rpc throttle enabled state.
*
* @param ctx
* the coprocessor instance's environment
* @param enable
* the rpc throttle value
*/
default void preSwitchRpcThrottle(final ObserverContext<MasterCoprocessorEnvironment> ctx, final boolean
enable) throws IOException {
} | 3.26 |
hbase_MasterObserver_m10_rdh | /**
* Called after the deleteNamespace operation has been requested.
*
* @param ctx
* the environment to interact with the framework and master
* @param namespace
* the name of the namespace
*/
default void m10(final ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace) throws IOException {
} | 3.26 |
hbase_MasterObserver_m0_rdh | /**
* Called after {@link org.apache.hadoop.hbase.master.HMaster} deletes a table. Called as part of
* delete table procedure and it is async to the delete RPC call.
*
* @param ctx
* the environment to interact with the framework and master
* @param tableName
* the name of the table
*/
default void m0(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableName tableName) throws IOException {
} | 3.26 |
hbase_MasterObserver_postGetUserPermissions_rdh | /**
* Called after getting user permissions.
*
* @param ctx
* the coprocessor instance's environment
* @param userName
* the user name, null if get all user permissions
* @param namespace
* the namespace, null if don't get namespace permission
* @param tableName
* the table name, null if don't get table permission
* @param family
* the table column family, null if don't get table family permission
* @param qualifier
* the table column qualifier, null if don't get table qualifier permission
* @throws IOException
* if something went wrong
*/
default void postGetUserPermissions(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, String namespace, TableName tableName, byte[] family, byte[] qualifier) throws IOException {
} | 3.26 |
hbase_MasterObserver_postCompletedDisableTableAction_rdh | /**
* Called after the disableTable operation has been requested. Called as part of disable table
* procedure and it is asyn to the disable table RPC call.
*
* @param ctx
* the environment to interact with the framework and master
* @param tableName
* the name of the table
*/
default void postCompletedDisableTableAction(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableName tableName) throws IOException {
} | 3.26 |
hbase_MasterObserver_preSetRegionServerQuota_rdh | /**
* Called before the quota for the region server is stored.
*
* @param ctx
* the environment to interact with the framework and master
* @param regionServer
* the name of the region server
* @param quotas
* the current quota for the region server
*/
default void preSetRegionServerQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx, final String regionServer, final GlobalQuotaSettings quotas) throws IOException {
} | 3.26 |
hbase_MasterObserver_preRemoveRSGroup_rdh | /**
* Called before a region server group is removed
*
* @param ctx
* the environment to interact with the framework and master
* @param name
* group name
*/
default void preRemoveRSGroup(final ObserverContext<MasterCoprocessorEnvironment> ctx, String name) throws IOException {
} | 3.26 |
hbase_MasterObserver_postGetRSGroupInfo_rdh | /**
* Called after getting region server group info of the passed groupName.
*
* @param ctx
* the environment to interact with the framework and master
* @param groupName
* name of the group to get RSGroupInfo for
*/
default void postGetRSGroupInfo(final ObserverContext<MasterCoprocessorEnvironment> ctx, final String groupName) throws IOException {} | 3.26 |
hbase_MasterObserver_preAddRSGroup_rdh | /**
* Called before a new region server group is added
*
* @param ctx
* the environment to interact with the framework and master
* @param name
* group name
*/
default void preAddRSGroup(final ObserverContext<MasterCoprocessorEnvironment> ctx, String name) throws IOException {
} | 3.26 |
hbase_MasterObserver_preSetSplitOrMergeEnabled_rdh | /**
* Called prior to setting split / merge switch Supports Coprocessor 'bypass'.
*
* @param ctx
* the coprocessor instance's environment
* @param newValue
* the new value submitted in the call
* @param switchType
* type of switch
*/
default void preSetSplitOrMergeEnabled(final ObserverContext<MasterCoprocessorEnvironment> ctx, final boolean newValue, final MasterSwitchType switchType) throws IOException {
} | 3.26 |
hbase_MasterObserver_postCompletedModifyTableAction_rdh | /**
* Called after to modifying a table's properties. Called as part of modify table procedure and it
* is async to the modify table RPC call.
*
* @param ctx
* the environment to interact with the framework and master
* @param tableName
* the name of the table
* @param oldDescriptor
* descriptor of table before modify operation happened
* @param currentDescriptor
* current TableDescriptor of the table
*/
default void postCompletedModifyTableAction(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableName tableName, final TableDescriptor oldDescriptor, final TableDescriptor currentDescriptor) throws IOException {
} | 3.26 |
hbase_MasterObserver_preMoveServersAndTables_rdh | /**
* Called before servers are moved to target region server group
*
* @param ctx
* the environment to interact with the framework and master
* @param servers
* set of servers to move
* @param targetGroup
* destination group
*/
default void preMoveServersAndTables(final ObserverContext<MasterCoprocessorEnvironment> ctx, Set<Address> servers, Set<TableName> tables, String targetGroup) throws IOException {
} | 3.26 |
hbase_MasterObserver_preAbortProcedure_rdh | /**
* Called before a abortProcedure request has been processed.
*
* @param ctx
* the environment to interact with the framework and master
* @param procId
* the Id of the procedure
*/
default void preAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx, final long procId) throws IOException {
} | 3.26 |
hbase_MasterObserver_postEnableTable_rdh | /**
* Called after the enableTable operation has been requested. Called as part of enable table RPC
* call.
*
* @param ctx
* the environment to interact with the framework and master
* @param tableName
* the name of the table
*/
default void postEnableTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableName tableName) throws IOException {
} | 3.26 |
hbase_MasterObserver_postMergeRegions_rdh | /**
* called after merge regions request.
*
* @param c
* coprocessor environment
* @param regionsToMerge
* regions to be merged
*/
default void postMergeRegions(final ObserverContext<MasterCoprocessorEnvironment> c, final RegionInfo[] regionsToMerge) throws IOException {
} | 3.26 |
hbase_MasterObserver_preModifyColumnFamilyStoreFileTracker_rdh | /**
* Called prior to modifying a family's store file tracker. Called as part of modify family store
* file tracker RPC call.
*
* @param ctx
* the environment to interact with the framework and master
* @param tableName
* the name of the table
* @param family
* the column family
* @param dstSFT
* the store file tracker
* @return the store file tracker
*/default String preModifyColumnFamilyStoreFileTracker(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableName tableName, final byte[] family, String dstSFT) throws IOException {
return dstSFT;
} | 3.26 |
hbase_MasterObserver_postGetTableDescriptors_rdh | /**
* Called after a getTableDescriptors request has been processed.
*
* @param ctx
* the environment to interact with the framework and master
* @param tableNamesList
* the list of table names, or null if querying for all
* @param descriptors
* the list of descriptors about to be returned
* @param regex
* regular expression used for filtering the table names
*/
default void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<TableName> tableNamesList, List<TableDescriptor> descriptors, String regex) throws IOException {
} | 3.26 |
hbase_MasterObserver_postBalanceSwitch_rdh | /**
* Called after the flag to enable/disable balancing has changed.
*
* @param ctx
* the coprocessor instance's environment
* @param oldValue
* the previously set balanceSwitch value
* @param newValue
* the newly set balanceSwitch value
*/
default void postBalanceSwitch(final ObserverContext<MasterCoprocessorEnvironment> ctx, final boolean oldValue, final boolean newValue) throws IOException {
} | 3.26 |
hbase_MasterObserver_preAssign_rdh | /**
* Called prior to assigning a specific region.
*
* @param ctx
* the environment to interact with the framework and master
* @param regionInfo
* the regionInfo of the region
*/
default void preAssign(final ObserverContext<MasterCoprocessorEnvironment> ctx, final RegionInfo regionInfo) throws IOException {
} | 3.26 |
hbase_MasterObserver_preTransitReplicationPeerSyncReplicationState_rdh | /**
* Called before transit current cluster state for the specified synchronous replication peer
*
* @param ctx
* the environment to interact with the framework and master
* @param peerId
* a short name that identifies the peer
* @param state
* the new state
*/
default void preTransitReplicationPeerSyncReplicationState(final
ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId, SyncReplicationState state) throws IOException {
} | 3.26 |
hbase_MasterObserver_postGetRSGroupInfoOfServer_rdh | /**
* Called after getting region server group info of the passed server.
*
* @param ctx
* the environment to interact with the framework and master
* @param server
* server to get RSGroupInfo for
*/
default void postGetRSGroupInfoOfServer(final ObserverContext<MasterCoprocessorEnvironment> ctx, final Address server) throws IOException {
} | 3.26 |
hbase_MasterObserver_preEnableReplicationPeer_rdh | /**
* Called before enable a replication peer
*
* @param peerId
* a short name that identifies the peer
*/
default void preEnableReplicationPeer(final ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId) throws IOException {
} | 3.26 |
hbase_MasterObserver_preDeleteNamespace_rdh | /**
* Called before {@link org.apache.hadoop.hbase.master.HMaster} deletes a namespace
*
* @param ctx
* the environment to interact with the framework and master
* @param namespace
* the name of the namespace
*/default void preDeleteNamespace(final ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace) throws IOException {
} | 3.26 |
hbase_MasterObserver_postGetClusterMetrics_rdh | /**
* Called after get cluster status.
*/
default void postGetClusterMetrics(ObserverContext<MasterCoprocessorEnvironment> ctx, ClusterMetrics status) throws IOException {
} | 3.26 |
hbase_MasterObserver_postSwitchExceedThrottleQuota_rdh | /**
* Called after switching exceed throttle quota state.
*
* @param ctx
* the coprocessor instance's environment
* @param oldValue
* the previously exceed throttle quota value
* @param newValue
* the newly exceed throttle quota value
*/
default void postSwitchExceedThrottleQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx, final boolean oldValue, final boolean newValue) throws IOException {
} | 3.26 |
hbase_MasterObserver_postModifyTableStoreFileTracker_rdh | /**
* Called after modifying a table's store file tracker. Called as part of modify table store file
* tracker RPC call.
*
* @param ctx
* the environment to interact with the framework and master
* @param tableName
* the name of the table
* @param dstSFT
* the store file tracker
*/
default void postModifyTableStoreFileTracker(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableName tableName, String dstSFT) throws IOException {
} | 3.26 |
hbase_MasterObserver_preMergeRegions_rdh | /**
* Called before merge regions request.
*
* @param ctx
* coprocessor environment
* @param regionsToMerge
* regions to be merged
*/
default void preMergeRegions(final ObserverContext<MasterCoprocessorEnvironment> ctx, final RegionInfo[]
regionsToMerge) throws IOException {
} | 3.26 |
hbase_MasterObserver_preDeleteTable_rdh | /**
* Called before {@link org.apache.hadoop.hbase.master.HMaster} deletes a table. Called as part of
* delete table RPC call.
*
* @param ctx
* the environment to interact with the framework and master
* @param tableName
* the name of the table
*/
default void preDeleteTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName) throws IOException {
} | 3.26 |
hbase_MasterObserver_postGrant_rdh | /**
* Called after granting user permissions.
*
* @param ctx
* the coprocessor instance's environment
* @param userPermission
* the user and permissions
* @param mergeExistingPermissions
* True if merge with previous granted permissions
*/
default void postGrant(ObserverContext<MasterCoprocessorEnvironment> ctx, UserPermission userPermission, boolean mergeExistingPermissions) throws IOException {
} | 3.26 |
hbase_MasterObserver_preGetRSGroupInfoOfTable_rdh | /**
* Called before getting region server group info of the passed tableName.
*
* @param ctx
* the environment to interact with the framework and master
* @param tableName
* name of the table to get RSGroupInfo for
*/
default void preGetRSGroupInfoOfTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableName tableName) throws IOException {
} | 3.26 |
hbase_MasterObserver_m8_rdh | /**
* Called after the snapshot operation has been requested. Called as part of snapshot RPC call.
*
* @param ctx
* the environment to interact with the framework and master
* @param snapshot
* the SnapshotDescriptor for the snapshot
* @param tableDescriptor
* the TableDescriptor of the table to snapshot
*/
default void m8(final
ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final TableDescriptor tableDescriptor) throws IOException {
} | 3.26 |
hbase_MasterObserver_postBalance_rdh | /**
* Called after the balancing plan has been submitted.
*
* @param ctx
* the environment to interact with the framework and master
* @param request
* the request used to trigger the balance
* @param plans
* the RegionPlans which master has executed. RegionPlan serves as hint as for the
* final destination for the underlying region but may not represent the final
* state of assignment
*/
default void postBalance(final ObserverContext<MasterCoprocessorEnvironment> ctx, BalanceRequest request, List<RegionPlan> plans) throws IOException {
} | 3.26 |
hbase_MasterObserver_postStartMaster_rdh | /**
* Called immediately after an active master instance has completed initialization. Will not be
* called on standby master instances unless they take over the active role.
*/
default void postStartMaster(final ObserverContext<MasterCoprocessorEnvironment> ctx) throws IOException {
} | 3.26 |
hbase_MasterObserver_postGetLocks_rdh | /**
* Called after a getLocks request has been processed.
*
* @param ctx
* the environment to interact with the framework and master
* @throws IOException
* if something went wrong
*/
default void postGetLocks(ObserverContext<MasterCoprocessorEnvironment> ctx) throws IOException {
} | 3.26 |
hbase_MetricRegistries_global_rdh | /**
* Return the global singleton instance for the MetricRegistries.
*
* @return MetricRegistries implementation.
*/
public static MetricRegistries global() {
return LazyHolder.GLOBAL;
} | 3.26 |
hbase_HBaseTrustManager_performHostVerification_rdh | /**
* Compares peer's hostname with the one stored in the provided client certificate. Performs
* verification with the help of provided HostnameVerifier.
*
* @param inetAddress
* Peer's inet address.
* @param certificate
* Peer's certificate
* @throws CertificateException
* Thrown if the provided certificate doesn't match the peer
* hostname.
*/
private void performHostVerification(InetAddress inetAddress, X509Certificate certificate) throws CertificateException {
String hostAddress = "";
String hostName = "";
try {
hostAddress = inetAddress.getHostAddress();
hostnameVerifier.verify(hostAddress, certificate);
} catch (SSLException addressVerificationException) {
// If we fail with hostAddress, we should try the hostname.
// The inetAddress may have been created with a hostname, in which case getHostName() will
// return quickly below. If not, a reverse lookup will happen, which can be expensive.
// We provide the option to skip the reverse lookup if preferring to fail fast.
// Handle logging here to aid debugging. The easiest way to check for an existing
// hostname is through toString, see javadoc.
String inetAddressString = inetAddress.toString();
if (!inetAddressString.startsWith("/")) {
LOG.debug("Failed to verify host address: {}, but inetAddress {} has a hostname, trying that", hostAddress, inetAddressString, addressVerificationException);
} else if (allowReverseDnsLookup) {
LOG.debug("Failed to verify host address: {}, attempting to verify host name with reverse dns", hostAddress, addressVerificationException);
} else {
LOG.debug("Failed to verify host address: {}, but reverse dns lookup is disabled", hostAddress, addressVerificationException);
throw new CertificateException("Failed to verify host address, and reverse lookup is disabled", addressVerificationException);
}
try {hostName = inetAddress.getHostName();
hostnameVerifier.verify(hostName, certificate);
} catch (SSLException hostnameVerificationException) {
LOG.error("Failed to verify host address: {}", hostAddress, addressVerificationException);
LOG.error("Failed to verify hostname: {}", hostName, hostnameVerificationException);
throw new CertificateException("Failed to verify both host address and host name", hostnameVerificationException);
}
}
} | 3.26 |
hbase_ProtobufMagic_lengthOfPBMagic_rdh | /**
* Returns Length of {@link #PB_MAGIC}
*/
public static int lengthOfPBMagic() {
return PB_MAGIC.length;
} | 3.26 |
hbase_ProtobufMagic_isPBMagicPrefix_rdh | /**
* Returns True if passed <code>bytes</code> has {@link #PB_MAGIC} for a prefix.
*/
public static boolean isPBMagicPrefix(final byte[] bytes, int
offset, int len) {
if ((bytes == null) || (len <
PB_MAGIC.length))
return false;
return compareTo(PB_MAGIC, 0, PB_MAGIC.length, bytes, offset, PB_MAGIC.length) == 0;
} | 3.26 |
hbase_TableRecordReader_getCurrentValue_rdh | /**
* Returns the current value.
*
* @return The current value.
* @throws IOException
* When the value is faulty.
* @throws InterruptedException
* When the job is aborted.
* @see org.apache.hadoop.mapreduce.RecordReader#getCurrentValue()
*/
@Override
public Result getCurrentValue() throws IOException, InterruptedException {
return this.recordReaderImpl.getCurrentValue();
} | 3.26 |
hbase_TableRecordReader_nextKeyValue_rdh | /**
* Positions the record reader to the next record.
*
* @return <code>true</code> if there was another record.
* @throws IOException
* When reading the record failed.
* @throws InterruptedException
* When the job was aborted.
* @see org.apache.hadoop.mapreduce.RecordReader#nextKeyValue()
*/
@Override
public boolean
nextKeyValue() throws IOException, InterruptedException {return this.recordReaderImpl.nextKeyValue();
} | 3.26 |
hbase_TableRecordReader_setTable_rdh | /**
*
* @param table
* the {@link Table} to scan.
*/
public void setTable(Table table) {
this.recordReaderImpl.setHTable(table);
} | 3.26 |
hbase_TableRecordReader_setScan_rdh | /**
* Sets the scan defining the actual details like columns etc.
*
* @param scan
* The scan to set.
*/public void setScan(Scan scan) {
this.recordReaderImpl.setScan(scan);
} | 3.26 |
hbase_TableRecordReader_getProgress_rdh | /**
* The current progress of the record reader through its data.
*
* @return A number between 0.0 and 1.0, the fraction of the data read.
* @see org.apache.hadoop.mapreduce.RecordReader#getProgress()
*/
@Override
public float getProgress() {
return this.recordReaderImpl.getProgress();
} | 3.26 |
hbase_TableRecordReader_restart_rdh | /**
* Restart from survivable exceptions by creating a new scanner.
*
* @param firstRow
* The first row to start at.
* @throws IOException
* When restarting fails.
*/
public void restart(byte[] firstRow) throws IOException {
this.recordReaderImpl.restart(firstRow);
} | 3.26 |
hbase_TableRecordReader_getCurrentKey_rdh | /**
* Returns the current key.
*
* @return The current key.
* @throws InterruptedException
* When the job is aborted.
* @see org.apache.hadoop.mapreduce.RecordReader#getCurrentKey()
*/
@Override
public ImmutableBytesWritable getCurrentKey() throws IOException, InterruptedException {
return this.recordReaderImpl.getCurrentKey();
} | 3.26 |
hbase_TableRecordReader_close_rdh | /**
* Closes the split.
*
* @see org.apache.hadoop.mapreduce.RecordReader#close()
*/
@Override
public void close()
{
this.recordReaderImpl.close();
} | 3.26 |
hbase_ProcedureStore_forceUpdate_rdh | /**
* Suggest that the upper layer should update the state of some procedures. Ignore this call
* will not effect correctness but performance.
* <p/>
* For a WAL based ProcedureStore implementation, if all the procedures stored in a WAL file
* have been deleted, or updated later in another WAL file, then we can delete the WAL file. If
* there are old procedures in a WAL file which are never deleted or updated, then we can not
* delete the WAL file and this will cause we hold lots of WAL file and slow down the master
* restarts. So here we introduce this method to tell the upper layer that please update the
* states of these procedures so that we can delete the old WAL file.
*
* @param procIds
* the id for the procedures
*/
default void forceUpdate(long[] procIds) {
} | 3.26 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.