HBASE-18511 Default no regions on master
Changes the configuration hbase.balancer.tablesOnMaster from list of table names to instead be a boolean; true if master carries tables/regions and false if it does not. Adds a new configuration hbase.balancer.tablesOnMaster.systemTablesOnly. If true, hbase.balancer.tablesOnMaster is considered true but only system tables are put on the master. M hbase-server/src/main/java/org/apache/hadoop/hbase/master/HMaster.java Master was claiming itself active master though it had stopped. Fix the activeMaster flag. Set it to false on exit. M hbase-server/src/main/java/org/apache/hadoop/hbase/master/LoadBalancer.java Add new configs and convenience methods for getting current state of settings. M hbase-server/src/main/java/org/apache/hadoop/hbase/master/balancer/BaseLoadBalancer.java Move configs up into super Interface and now the settings mean different, remove the no longer needed processing.
This commit is contained in:
Michael Stack
parent
acf9b87dca
commit
473446719b
|
|
@ -530,6 +530,17 @@ public class HMaster extends HRegionServer implements MasterServices {
|
|||
}
|
||||
}
|
||||
|
||||
// Main run loop. Calls through to the regionserver run loop.
|
||||
@Override
|
||||
public void run() {
|
||||
try {
|
||||
super.run();
|
||||
} finally {
|
||||
// If on way out, then we are no longer active master.
|
||||
this.activeMaster = false;
|
||||
}
|
||||
}
|
||||
|
||||
// return the actual infoPort, -1 means disable info server.
|
||||
private int putUpJettyServer() throws IOException {
|
||||
if (!conf.getBoolean("hbase.master.infoserver.redirect", true)) {
|
||||
|
|
@ -604,9 +615,8 @@ public class HMaster extends HRegionServer implements MasterServices {
|
|||
*/
|
||||
@Override
|
||||
protected void waitForMasterActive(){
|
||||
boolean tablesOnMaster = BaseLoadBalancer.tablesOnMaster(conf);
|
||||
while (!(tablesOnMaster && activeMaster)
|
||||
&& !isStopped() && !isAborted()) {
|
||||
boolean tablesOnMaster = LoadBalancer.isTablesOnMaster(conf);
|
||||
while (!(tablesOnMaster && activeMaster) && !isStopped() && !isAborted()) {
|
||||
sleeper.sleep();
|
||||
}
|
||||
}
|
||||
|
|
@ -644,7 +654,7 @@ public class HMaster extends HRegionServer implements MasterServices {
|
|||
protected void configureInfoServer() {
|
||||
infoServer.addServlet("master-status", "/master-status", MasterStatusServlet.class);
|
||||
infoServer.setAttribute(MASTER, this);
|
||||
if (BaseLoadBalancer.tablesOnMaster(conf)) {
|
||||
if (LoadBalancer.isTablesOnMaster(conf)) {
|
||||
super.configureInfoServer();
|
||||
}
|
||||
}
|
||||
|
|
@ -796,14 +806,16 @@ public class HMaster extends HRegionServer implements MasterServices {
|
|||
sleeper.skipSleepCycle();
|
||||
|
||||
// Wait for region servers to report in
|
||||
status.setStatus("Wait for region servers to report in");
|
||||
String statusStr = "Wait for region servers to report in";
|
||||
status.setStatus(statusStr);
|
||||
LOG.info(status);
|
||||
waitForRegionServers(status);
|
||||
|
||||
if (this.balancer instanceof FavoredNodesPromoter) {
|
||||
favoredNodesManager = new FavoredNodesManager(this);
|
||||
}
|
||||
// Wait for regionserver to finish initialization.
|
||||
if (BaseLoadBalancer.tablesOnMaster(conf)) {
|
||||
if (LoadBalancer.isTablesOnMaster(conf)) {
|
||||
waitForServerOnline();
|
||||
}
|
||||
|
||||
|
|
@ -1643,11 +1655,11 @@ public class HMaster extends HRegionServer implements MasterServices {
|
|||
LOG.debug("Unable to determine a plan to assign " + hri);
|
||||
return;
|
||||
}
|
||||
// TODO: What is this? I don't get it.
|
||||
if (dest.equals(serverName) && balancer instanceof BaseLoadBalancer
|
||||
&& !((BaseLoadBalancer)balancer).shouldBeOnMaster(hri)) {
|
||||
// To avoid unnecessary region moving later by balancer. Don't put user
|
||||
// regions on master. Regions on master could be put on other region
|
||||
// server intentionally by test however.
|
||||
// regions on master.
|
||||
LOG.debug("Skipping move of region " + hri.getRegionNameAsString()
|
||||
+ " to avoid unnecessary region moving later by load balancer,"
|
||||
+ " because it should not be on master");
|
||||
|
|
|
|||
|
|
@ -18,9 +18,10 @@
|
|||
*/
|
||||
package org.apache.hadoop.hbase.master;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.*;
|
||||
|
||||
import com.google.common.collect.ImmutableSet;
|
||||
import com.google.common.collect.UnmodifiableIterator;
|
||||
import org.apache.hadoop.conf.Configurable;
|
||||
import org.apache.hadoop.conf.Configuration;
|
||||
import org.apache.hadoop.hbase.ClusterStatus;
|
||||
|
|
@ -33,6 +34,9 @@ import org.apache.hadoop.hbase.classification.InterfaceAudience;
|
|||
import org.apache.hadoop.hbase.conf.ConfigurationObserver;
|
||||
|
||||
import edu.umd.cs.findbugs.annotations.Nullable;
|
||||
import org.apache.hadoop.hbase.security.access.AccessControlLists;
|
||||
import org.apache.hadoop.hbase.shaded.com.google.common.annotations.VisibleForTesting;
|
||||
import org.apache.hadoop.util.StringUtils;
|
||||
|
||||
/**
|
||||
* Makes decisions about the placement and movement of Regions across
|
||||
|
|
@ -50,6 +54,18 @@ import edu.umd.cs.findbugs.annotations.Nullable;
|
|||
*/
|
||||
@InterfaceAudience.Private
|
||||
public interface LoadBalancer extends Configurable, Stoppable, ConfigurationObserver {
|
||||
/**
|
||||
* Master can carry regions as of hbase-2.0.0.
|
||||
* By default, it carries no tables.
|
||||
* TODO: Add any | system as flags to indicate what it can do.
|
||||
*/
|
||||
public static final String TABLES_ON_MASTER = "hbase.balancer.tablesOnMaster";
|
||||
|
||||
/**
|
||||
* Master carries system tables.
|
||||
*/
|
||||
public static final String SYSTEM_TABLES_ON_MASTER =
|
||||
"hbase.balancer.tablesOnMaster.systemTablesOnly";
|
||||
|
||||
// Used to signal to the caller that the region(s) cannot be assigned
|
||||
// We deliberately use 'localhost' so the operation will fail fast
|
||||
|
|
@ -147,4 +163,15 @@ public interface LoadBalancer extends Configurable, Stoppable, ConfigurationObse
|
|||
* @param conf
|
||||
*/
|
||||
void onConfigurationChange(Configuration conf);
|
||||
|
||||
/**
|
||||
* @return true if Master carries regions
|
||||
*/
|
||||
static boolean isTablesOnMaster(Configuration conf) {
|
||||
return conf.getBoolean(TABLES_ON_MASTER, false);
|
||||
}
|
||||
|
||||
static boolean isSystemTablesOnlyOnMaster(Configuration conf) {
|
||||
return conf.getBoolean(SYSTEM_TABLES_ON_MASTER, false);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -35,6 +35,7 @@ import java.util.concurrent.ConcurrentHashMap;
|
|||
import java.util.concurrent.ConcurrentNavigableMap;
|
||||
import java.util.concurrent.ConcurrentSkipListMap;
|
||||
import java.util.concurrent.CopyOnWriteArrayList;
|
||||
import java.util.concurrent.atomic.AtomicBoolean;
|
||||
import java.util.function.Predicate;
|
||||
|
||||
import org.apache.commons.logging.Log;
|
||||
|
|
@ -109,7 +110,7 @@ public class ServerManager {
|
|||
private static final Log LOG = LogFactory.getLog(ServerManager.class);
|
||||
|
||||
// Set if we are to shutdown the cluster.
|
||||
private volatile boolean clusterShutdown = false;
|
||||
private AtomicBoolean clusterShutdown = new AtomicBoolean(false);
|
||||
|
||||
/**
|
||||
* The last flushed sequence id for a region.
|
||||
|
|
@ -423,7 +424,6 @@ public class ServerManager {
|
|||
/**
|
||||
* Adds the onlineServers list. onlineServers should be locked.
|
||||
* @param serverName The remote servers name.
|
||||
* @param sl
|
||||
*/
|
||||
@VisibleForTesting
|
||||
void recordNewServerWithLock(final ServerName serverName, final ServerLoad sl) {
|
||||
|
|
@ -583,7 +583,7 @@ public class ServerManager {
|
|||
|
||||
// If cluster is going down, yes, servers are going to be expiring; don't
|
||||
// process as a dead server
|
||||
if (this.clusterShutdown) {
|
||||
if (this.clusterShutdown.get()) {
|
||||
LOG.info("Cluster shutdown set; " + serverName +
|
||||
" expired; onlineServers=" + this.onlineServers.size());
|
||||
if (this.onlineServers.isEmpty()) {
|
||||
|
|
@ -591,7 +591,7 @@ public class ServerManager {
|
|||
}
|
||||
return;
|
||||
}
|
||||
|
||||
LOG.info("Processing expiration of " + serverName + " on " + this.master.getServerName());
|
||||
master.getAssignmentManager().submitServerCrash(serverName, true);
|
||||
|
||||
// Tell our listeners that a server was removed
|
||||
|
|
@ -790,12 +790,12 @@ public class ServerManager {
|
|||
private int getMinToStart() {
|
||||
// One server should be enough to get us off the ground.
|
||||
int requiredMinToStart = 1;
|
||||
if (BaseLoadBalancer.tablesOnMaster(master.getConfiguration())) {
|
||||
if (!BaseLoadBalancer.userTablesOnMaster(master.getConfiguration())) {
|
||||
// If Master is carrying regions but NOT user-space regions (the current default),
|
||||
// since the Master shows as a 'server', we need at least one more server to check
|
||||
// in before we can start up so up defaultMinToStart to 2.
|
||||
requiredMinToStart = 2;
|
||||
if (LoadBalancer.isTablesOnMaster(master.getConfiguration())) {
|
||||
if (LoadBalancer.isSystemTablesOnlyOnMaster(master.getConfiguration())) {
|
||||
// If Master is carrying regions but NOT user-space regions, it
|
||||
// still shows as a 'server'. We need at least one more server to check
|
||||
// in before we can start up so set defaultMinToStart to 2.
|
||||
requiredMinToStart = requiredMinToStart + 1;
|
||||
}
|
||||
}
|
||||
int minToStart = this.master.getConfiguration().getInt(WAIT_ON_REGIONSERVERS_MINTOSTART, -1);
|
||||
|
|
@ -944,12 +944,14 @@ public class ServerManager {
|
|||
}
|
||||
|
||||
public void shutdownCluster() {
|
||||
this.clusterShutdown = true;
|
||||
this.master.stop("Cluster shutdown requested");
|
||||
String statusStr = "Cluster shutdown requested of master=" + this.master.getServerName();
|
||||
LOG.info(statusStr);
|
||||
this.clusterShutdown.set(true);
|
||||
this.master.stop(statusStr);
|
||||
}
|
||||
|
||||
public boolean isClusterShutdown() {
|
||||
return this.clusterShutdown;
|
||||
return this.clusterShutdown.get();
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -973,7 +975,7 @@ public class ServerManager {
|
|||
public List<ServerName> createDestinationServersList(final List<ServerName> serversToExclude){
|
||||
final List<ServerName> destServers = getOnlineServersList();
|
||||
|
||||
if (serversToExclude != null){
|
||||
if (serversToExclude != null) {
|
||||
destServers.removeAll(serversToExclude);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -61,6 +61,7 @@ import org.apache.hadoop.hbase.shaded.com.google.common.base.Joiner;
|
|||
import org.apache.hadoop.hbase.shaded.com.google.common.collect.ArrayListMultimap;
|
||||
import org.apache.hadoop.hbase.shaded.com.google.common.collect.Lists;
|
||||
import org.apache.hadoop.hbase.shaded.com.google.common.collect.Sets;
|
||||
import org.apache.zookeeper.KeeperException;
|
||||
|
||||
/**
|
||||
* The base class for load balancers. It provides the the functions used to by
|
||||
|
|
@ -991,69 +992,22 @@ public abstract class BaseLoadBalancer implements LoadBalancer {
|
|||
|
||||
// slop for regions
|
||||
protected float slop;
|
||||
// overallSlop to controll simpleLoadBalancer's cluster level threshold
|
||||
// overallSlop to control simpleLoadBalancer's cluster level threshold
|
||||
protected float overallSlop;
|
||||
protected Configuration config;
|
||||
protected RackManager rackManager;
|
||||
private static final Random RANDOM = new Random(System.currentTimeMillis());
|
||||
private static final Log LOG = LogFactory.getLog(BaseLoadBalancer.class);
|
||||
|
||||
// Regions of these tables are put on the master by default.
|
||||
private static final String[] DEFAULT_TABLES_ON_MASTER =
|
||||
new String[] {AccessControlLists.ACL_TABLE_NAME.getNameAsString(),
|
||||
TableName.NAMESPACE_TABLE_NAME.getNameAsString(),
|
||||
TableName.META_TABLE_NAME.getNameAsString()};
|
||||
|
||||
public static final String TABLES_ON_MASTER =
|
||||
"hbase.balancer.tablesOnMaster";
|
||||
|
||||
protected final Set<String> tablesOnMaster = new HashSet<>();
|
||||
protected MetricsBalancer metricsBalancer = null;
|
||||
protected ClusterStatus clusterStatus = null;
|
||||
protected ServerName masterServerName;
|
||||
protected MasterServices services;
|
||||
|
||||
/**
|
||||
* By default, regions of some small system tables such as meta,
|
||||
* namespace, and acl are assigned to the active master. If you don't
|
||||
* want to assign any region to the active master, you need to
|
||||
* configure "hbase.balancer.tablesOnMaster" to "none".
|
||||
*/
|
||||
protected static String[] getTablesOnMaster(Configuration conf) {
|
||||
String valueString = conf.get(TABLES_ON_MASTER);
|
||||
if (valueString == null) {
|
||||
return DEFAULT_TABLES_ON_MASTER;
|
||||
}
|
||||
valueString = valueString.trim();
|
||||
if (valueString.equalsIgnoreCase("none")) {
|
||||
return null;
|
||||
}
|
||||
return StringUtils.getStrings(valueString);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if configured to put any tables on the active master
|
||||
*/
|
||||
public static boolean tablesOnMaster(Configuration conf) {
|
||||
String[] tables = getTablesOnMaster(conf);
|
||||
return tables != null && tables.length > 0;
|
||||
}
|
||||
|
||||
public static boolean userTablesOnMaster(Configuration conf) {
|
||||
String[] tables = getTablesOnMaster(conf);
|
||||
if (tables == null || tables.length == 0) {
|
||||
return false;
|
||||
}
|
||||
for (String tn:tables) {
|
||||
if (!tn.startsWith("hbase:")) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
protected boolean tablesOnMaster;
|
||||
protected boolean onlySystemTablesOnMaster;
|
||||
|
||||
@Override
|
||||
public void setConf(Configuration conf) {
|
||||
this.config = conf;
|
||||
setSlop(conf);
|
||||
if (slop < 0) slop = 0;
|
||||
else if (slop > 1) slop = 1;
|
||||
|
|
@ -1061,13 +1015,18 @@ public abstract class BaseLoadBalancer implements LoadBalancer {
|
|||
if (overallSlop < 0) overallSlop = 0;
|
||||
else if (overallSlop > 1) overallSlop = 1;
|
||||
|
||||
this.config = conf;
|
||||
String[] tables = getTablesOnMaster(conf);
|
||||
if (tables != null && tables.length > 0) {
|
||||
Collections.addAll(tablesOnMaster, tables);
|
||||
this.tablesOnMaster = LoadBalancer.isTablesOnMaster(this.config);
|
||||
this.onlySystemTablesOnMaster = LoadBalancer.isSystemTablesOnlyOnMaster(this.config);
|
||||
// If system tables on master, implies tablesOnMaster = true.
|
||||
if (this.onlySystemTablesOnMaster && !this.tablesOnMaster) {
|
||||
LOG.warn("Set " + TABLES_ON_MASTER + "=true because " + SYSTEM_TABLES_ON_MASTER + "=true");
|
||||
this.tablesOnMaster = true;
|
||||
}
|
||||
this.rackManager = new RackManager(getConf());
|
||||
regionFinder.setConf(conf);
|
||||
// Print out base configs. Don't print overallSlop since it for simple balancer exclusively.
|
||||
LOG.info("slop=" + this.slop + ", tablesOnMaster=" + this.tablesOnMaster +
|
||||
", systemTablesOnMaster=" + this.onlySystemTablesOnMaster);
|
||||
}
|
||||
|
||||
protected void setSlop(Configuration conf) {
|
||||
|
|
@ -1076,21 +1035,18 @@ public abstract class BaseLoadBalancer implements LoadBalancer {
|
|||
}
|
||||
|
||||
/**
|
||||
* Check if a region belongs to some small system table.
|
||||
* Check if a region belongs to some system table.
|
||||
* If so, the primary replica may be expected to be put on the master regionserver.
|
||||
*/
|
||||
public boolean shouldBeOnMaster(HRegionInfo region) {
|
||||
return tablesOnMaster.contains(region.getTable().getNameAsString())
|
||||
&& region.getReplicaId() == HRegionInfo.DEFAULT_REPLICA_ID;
|
||||
return this.onlySystemTablesOnMaster && region.isSystemTable();
|
||||
}
|
||||
|
||||
/**
|
||||
* Balance the regions that should be on master regionserver.
|
||||
*/
|
||||
protected List<RegionPlan> balanceMasterRegions(
|
||||
Map<ServerName, List<HRegionInfo>> clusterMap) {
|
||||
if (masterServerName == null
|
||||
|| clusterMap == null || clusterMap.size() <= 1) return null;
|
||||
protected List<RegionPlan> balanceMasterRegions(Map<ServerName, List<HRegionInfo>> clusterMap) {
|
||||
if (masterServerName == null || clusterMap == null || clusterMap.size() <= 1) return null;
|
||||
List<RegionPlan> plans = null;
|
||||
List<HRegionInfo> regions = clusterMap.get(masterServerName);
|
||||
if (regions != null) {
|
||||
|
|
@ -1135,22 +1091,25 @@ public abstract class BaseLoadBalancer implements LoadBalancer {
|
|||
}
|
||||
|
||||
/**
|
||||
* Assign the regions that should be on master regionserver.
|
||||
* If master is configured to carry system tables only, in here is
|
||||
* where we figure what to assign it.
|
||||
*/
|
||||
protected Map<ServerName, List<HRegionInfo>> assignMasterRegions(
|
||||
protected Map<ServerName, List<HRegionInfo>> assignMasterSystemRegions(
|
||||
Collection<HRegionInfo> regions, List<ServerName> servers) {
|
||||
if (servers == null || regions == null || regions.isEmpty()) {
|
||||
return null;
|
||||
}
|
||||
Map<ServerName, List<HRegionInfo>> assignments = new TreeMap<>();
|
||||
if (this.onlySystemTablesOnMaster) {
|
||||
if (masterServerName != null && servers.contains(masterServerName)) {
|
||||
assignments.put(masterServerName, new ArrayList<>());
|
||||
for (HRegionInfo region: regions) {
|
||||
for (HRegionInfo region : regions) {
|
||||
if (shouldBeOnMaster(region)) {
|
||||
assignments.get(masterServerName).add(region);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return assignments;
|
||||
}
|
||||
|
||||
|
|
@ -1243,7 +1202,7 @@ public abstract class BaseLoadBalancer implements LoadBalancer {
|
|||
public Map<ServerName, List<HRegionInfo>> roundRobinAssignment(List<HRegionInfo> regions,
|
||||
List<ServerName> servers) throws HBaseIOException {
|
||||
metricsBalancer.incrMiscInvocations();
|
||||
Map<ServerName, List<HRegionInfo>> assignments = assignMasterRegions(regions, servers);
|
||||
Map<ServerName, List<HRegionInfo>> assignments = assignMasterSystemRegions(regions, servers);
|
||||
if (assignments != null && !assignments.isEmpty()) {
|
||||
servers = new ArrayList<>(servers);
|
||||
// Guarantee not to put other regions on master
|
||||
|
|
@ -1350,10 +1309,12 @@ public abstract class BaseLoadBalancer implements LoadBalancer {
|
|||
if (shouldBeOnMaster(regionInfo)) {
|
||||
return masterServerName;
|
||||
}
|
||||
if (!LoadBalancer.isTablesOnMaster(getConf())) {
|
||||
// Guarantee we do not put any regions on master
|
||||
servers = new ArrayList<>(servers);
|
||||
// Guarantee not to put other regions on master
|
||||
servers.remove(masterServerName);
|
||||
}
|
||||
}
|
||||
|
||||
int numServers = servers == null ? 0 : servers.size();
|
||||
if (numServers == 0) {
|
||||
|
|
@ -1396,8 +1357,7 @@ public abstract class BaseLoadBalancer implements LoadBalancer {
|
|||
List<ServerName> servers) throws HBaseIOException {
|
||||
// Update metrics
|
||||
metricsBalancer.incrMiscInvocations();
|
||||
Map<ServerName, List<HRegionInfo>> assignments
|
||||
= assignMasterRegions(regions.keySet(), servers);
|
||||
Map<ServerName, List<HRegionInfo>> assignments = assignMasterSystemRegions(regions.keySet(), servers);
|
||||
if (assignments != null && !assignments.isEmpty()) {
|
||||
servers = new ArrayList<>(servers);
|
||||
// Guarantee not to put other regions on master
|
||||
|
|
|
|||
|
|
@ -43,6 +43,7 @@ import org.apache.hadoop.hbase.favored.FavoredNodesManager;
|
|||
import org.apache.hadoop.hbase.favored.FavoredNodesPlan;
|
||||
import org.apache.hadoop.hbase.favored.FavoredNodesPlan.Position;
|
||||
import org.apache.hadoop.hbase.favored.FavoredNodesPromoter;
|
||||
import org.apache.hadoop.hbase.master.LoadBalancer;
|
||||
import org.apache.hadoop.hbase.master.MasterServices;
|
||||
import org.apache.hadoop.hbase.master.RegionPlan;
|
||||
import org.apache.hadoop.hbase.util.Pair;
|
||||
|
|
@ -112,7 +113,7 @@ public class FavoredStochasticBalancer extends StochasticLoadBalancer implements
|
|||
metricsBalancer.incrMiscInvocations();
|
||||
|
||||
Set<HRegionInfo> regionSet = Sets.newHashSet(regions);
|
||||
Map<ServerName, List<HRegionInfo>> assignmentMap = assignMasterRegions(regions, servers);
|
||||
Map<ServerName, List<HRegionInfo>> assignmentMap = assignMasterSystemRegions(regions, servers);
|
||||
if (assignmentMap != null && !assignmentMap.isEmpty()) {
|
||||
servers = new ArrayList<>(servers);
|
||||
// Guarantee not to put other regions on master
|
||||
|
|
@ -311,10 +312,12 @@ public class FavoredStochasticBalancer extends StochasticLoadBalancer implements
|
|||
metricsBalancer.incrMiscInvocations();
|
||||
return masterServerName;
|
||||
}
|
||||
if (!LoadBalancer.isTablesOnMaster(getConf())) {
|
||||
// Guarantee we do not put any regions on master
|
||||
servers = new ArrayList<>(servers);
|
||||
// Guarantee not to put other regions on master
|
||||
servers.remove(masterServerName);
|
||||
}
|
||||
}
|
||||
|
||||
ServerName destination = null;
|
||||
if (!FavoredNodesManager.isFavoredNodeApplicable(regionInfo)) {
|
||||
|
|
|
|||
|
|
@ -116,6 +116,7 @@ import org.apache.hadoop.hbase.ipc.RpcServerInterface;
|
|||
import org.apache.hadoop.hbase.ipc.ServerNotRunningYetException;
|
||||
import org.apache.hadoop.hbase.ipc.ServerRpcController;
|
||||
import org.apache.hadoop.hbase.master.HMaster;
|
||||
import org.apache.hadoop.hbase.master.LoadBalancer;
|
||||
import org.apache.hadoop.hbase.master.RegionState.State;
|
||||
import org.apache.hadoop.hbase.master.balancer.BaseLoadBalancer;
|
||||
import org.apache.hadoop.hbase.mob.MobCacheConfig;
|
||||
|
|
@ -2899,8 +2900,8 @@ public class HRegionServer extends HasThread implements
|
|||
static private void createNewReplicationInstance(Configuration conf,
|
||||
HRegionServer server, FileSystem walFs, Path walDir, Path oldWALDir) throws IOException{
|
||||
|
||||
if ((server instanceof HMaster) &&
|
||||
(!BaseLoadBalancer.userTablesOnMaster(conf))) {
|
||||
if ((server instanceof HMaster) && (!LoadBalancer.isTablesOnMaster(conf) ||
|
||||
LoadBalancer.isSystemTablesOnlyOnMaster(conf))) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -49,6 +49,7 @@ import java.util.UUID;
|
|||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.concurrent.atomic.AtomicReference;
|
||||
|
||||
import edu.umd.cs.findbugs.annotations.Nullable;
|
||||
import org.apache.commons.io.FileUtils;
|
||||
import org.apache.commons.lang.RandomStringUtils;
|
||||
import org.apache.commons.logging.Log;
|
||||
|
|
@ -137,7 +138,6 @@ import org.apache.zookeeper.WatchedEvent;
|
|||
import org.apache.zookeeper.ZooKeeper;
|
||||
import org.apache.zookeeper.ZooKeeper.States;
|
||||
|
||||
import edu.umd.cs.findbugs.annotations.Nullable;
|
||||
import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor;
|
||||
import org.apache.hadoop.hbase.client.ColumnFamilyDescriptorBuilder;
|
||||
import org.apache.hadoop.hbase.client.TableDescriptorBuilder;
|
||||
|
|
|
|||
|
|
@ -665,7 +665,8 @@ public class MiniHBaseCluster extends HBaseCluster {
|
|||
}
|
||||
|
||||
/**
|
||||
* @return List of region server threads.
|
||||
* @return List of region server threads. Does not return the master even though it is also
|
||||
* a region server.
|
||||
*/
|
||||
public List<JVMClusterUtil.RegionServerThread> getRegionServerThreads() {
|
||||
return this.hbaseCluster.getRegionServers();
|
||||
|
|
|
|||
|
|
@ -53,6 +53,7 @@ import org.apache.hadoop.hbase.regionserver.HRegion;
|
|||
import org.apache.hadoop.hbase.regionserver.Store;
|
||||
import org.apache.hadoop.hbase.regionserver.StoreFile;
|
||||
import org.apache.hadoop.hbase.shaded.protobuf.RequestConverter;
|
||||
import org.apache.hadoop.hbase.master.LoadBalancer;
|
||||
import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.MergeTableRegionsRequest;
|
||||
import org.apache.hadoop.hbase.testclassification.ClientTests;
|
||||
import org.apache.hadoop.hbase.testclassification.LargeTests;
|
||||
|
|
@ -596,7 +597,8 @@ public class TestAdmin1 {
|
|||
}
|
||||
regs.add(loc.getRegionInfo());
|
||||
}
|
||||
if (numRS >= 2) {
|
||||
boolean tablesOnMaster = LoadBalancer.isTablesOnMaster(TEST_UTIL.getConfiguration());
|
||||
if (tablesOnMaster) {
|
||||
// Ignore the master region server,
|
||||
// which contains less regions by intention.
|
||||
numRS--;
|
||||
|
|
@ -605,7 +607,9 @@ public class TestAdmin1 {
|
|||
int min = (int)Math.floor(average);
|
||||
int max = (int)Math.ceil(average);
|
||||
for (List<HRegionInfo> regionList : server2Regions.values()) {
|
||||
assertTrue(regionList.size() == min || regionList.size() == max);
|
||||
assertTrue("numRS=" + numRS + ", min=" + min + ", max=" + max +
|
||||
", size=" + regionList.size() + ", tablesOnMaster=" + tablesOnMaster,
|
||||
regionList.size() == min || regionList.size() == max);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -47,6 +47,7 @@ import org.apache.hadoop.hbase.ServerName;
|
|||
import org.apache.hadoop.hbase.TableName;
|
||||
import org.apache.hadoop.hbase.TableNotEnabledException;
|
||||
import org.apache.hadoop.hbase.client.TableDescriptorBuilder.ModifyableTableDescriptor;
|
||||
import org.apache.hadoop.hbase.master.LoadBalancer;
|
||||
import org.apache.hadoop.hbase.master.MasterFileSystem;
|
||||
import org.apache.hadoop.hbase.testclassification.ClientTests;
|
||||
import org.apache.hadoop.hbase.testclassification.LargeTests;
|
||||
|
|
@ -209,6 +210,7 @@ public class TestAsyncTableAdminApi extends TestAsyncAdminBase {
|
|||
new byte[] { 4, 4, 4 }, new byte[] { 5, 5, 5 }, new byte[] { 6, 6, 6 },
|
||||
new byte[] { 7, 7, 7 }, new byte[] { 8, 8, 8 }, new byte[] { 9, 9, 9 }, };
|
||||
int expectedRegions = splitKeys.length + 1;
|
||||
boolean tablesOnMaster = LoadBalancer.isTablesOnMaster(TEST_UTIL.getConfiguration());
|
||||
createTableWithDefaultConf(tableName, Optional.of(splitKeys));
|
||||
|
||||
boolean tableAvailable = admin.isTableAvailable(tableName, splitKeys).get();
|
||||
|
|
@ -256,7 +258,9 @@ public class TestAsyncTableAdminApi extends TestAsyncAdminBase {
|
|||
hri = hris.next().getRegionInfo();
|
||||
assertTrue(Bytes.equals(hri.getStartKey(), splitKeys[8]));
|
||||
assertTrue(hri.getEndKey() == null || hri.getEndKey().length == 0);
|
||||
if (tablesOnMaster) {
|
||||
verifyRoundRobinDistribution(regions, expectedRegions);
|
||||
}
|
||||
|
||||
// Now test using start/end with a number of regions
|
||||
|
||||
|
|
@ -310,7 +314,10 @@ public class TestAsyncTableAdminApi extends TestAsyncAdminBase {
|
|||
hri = hris.next().getRegionInfo();
|
||||
assertTrue(Bytes.equals(hri.getStartKey(), new byte[] { 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 }));
|
||||
assertTrue(hri.getEndKey() == null || hri.getEndKey().length == 0);
|
||||
if (tablesOnMaster) {
|
||||
// This don't work if master is not carrying regions. FIX. TODO.
|
||||
verifyRoundRobinDistribution(regions, expectedRegions);
|
||||
}
|
||||
|
||||
// Try once more with something that divides into something infinite
|
||||
startKey = new byte[] { 0, 0, 0, 0, 0, 0 };
|
||||
|
|
@ -328,7 +335,10 @@ public class TestAsyncTableAdminApi extends TestAsyncAdminBase {
|
|||
"Tried to create " + expectedRegions + " regions " + "but only found " + regions.size(),
|
||||
expectedRegions, regions.size());
|
||||
System.err.println("Found " + regions.size() + " regions");
|
||||
if (tablesOnMaster) {
|
||||
// This don't work if master is not carrying regions. FIX. TODO.
|
||||
verifyRoundRobinDistribution(regions, expectedRegions);
|
||||
}
|
||||
|
||||
// Try an invalid case where there are duplicate split keys
|
||||
splitKeys = new byte[][] { new byte[] { 1, 1, 1 }, new byte[] { 2, 2, 2 },
|
||||
|
|
|
|||
|
|
@ -28,6 +28,7 @@ import org.apache.hadoop.hbase.HBaseTestingUtility;
|
|||
import org.apache.hadoop.hbase.MiniHBaseCluster;
|
||||
import org.apache.hadoop.hbase.ServerName;
|
||||
import org.apache.hadoop.hbase.master.HMaster;
|
||||
import org.apache.hadoop.hbase.master.LoadBalancer;
|
||||
import org.apache.hadoop.hbase.regionserver.HRegionServer;
|
||||
import org.apache.hadoop.hbase.security.User;
|
||||
import org.apache.hadoop.hbase.testclassification.SmallTests;
|
||||
|
|
@ -154,9 +155,9 @@ public class TestClientClusterStatus {
|
|||
Assert.assertNotNull(status);
|
||||
Assert.assertNotNull(status.getServers());
|
||||
// exclude a dead region server
|
||||
Assert.assertEquals(SLAVES - 1, numRs);
|
||||
Assert.assertEquals(SLAVES, numRs);
|
||||
// live servers = primary master + nums of regionservers
|
||||
Assert.assertEquals(status.getServers().size() - 1, numRs);
|
||||
Assert.assertEquals(status.getServers().size() + 1 /*Master*/, numRs);
|
||||
Assert.assertTrue(status.getRegionsCount() > 0);
|
||||
Assert.assertNotNull(status.getDeadServerNames());
|
||||
Assert.assertEquals(1, status.getDeadServersSize());
|
||||
|
|
|
|||
|
|
@ -95,6 +95,7 @@ import org.apache.hadoop.hbase.io.encoding.DataBlockEncoding;
|
|||
import org.apache.hadoop.hbase.io.hfile.BlockCache;
|
||||
import org.apache.hadoop.hbase.io.hfile.CacheConfig;
|
||||
import org.apache.hadoop.hbase.ipc.CoprocessorRpcChannel;
|
||||
import org.apache.hadoop.hbase.master.LoadBalancer;
|
||||
import org.apache.hadoop.hbase.protobuf.ProtobufUtil;
|
||||
import org.apache.hadoop.hbase.protobuf.generated.ClientProtos.MutationProto;
|
||||
import org.apache.hadoop.hbase.protobuf.generated.ClientProtos.MutationProto.MutationType;
|
||||
|
|
@ -4328,9 +4329,11 @@ public class TestFromClientSide {
|
|||
|
||||
// test that the same unmanaged connection works with a new
|
||||
// Admin and can connect to the new master;
|
||||
boolean tablesOnMaster = LoadBalancer.isTablesOnMaster(TEST_UTIL.getConfiguration());
|
||||
try (Admin admin = conn.getAdmin()) {
|
||||
assertTrue(admin.tableExists(tableName));
|
||||
assertTrue(admin.getClusterStatus().getServersSize() == SLAVES + 1);
|
||||
assertTrue(admin.getClusterStatus().getServersSize() ==
|
||||
SLAVES + (tablesOnMaster? 1: 0));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -44,6 +44,7 @@ import org.apache.hadoop.hbase.MiniHBaseCluster;
|
|||
import org.apache.hadoop.hbase.TableName;
|
||||
import org.apache.hadoop.hbase.client.Put;
|
||||
import org.apache.hadoop.hbase.client.Table;
|
||||
import org.apache.hadoop.hbase.master.LoadBalancer;
|
||||
import org.apache.hadoop.hbase.regionserver.HRegion;
|
||||
import org.apache.hadoop.hbase.regionserver.HRegionServer;
|
||||
import org.apache.hadoop.hbase.regionserver.Region;
|
||||
|
|
@ -259,7 +260,8 @@ public class TestBlockReorder {
|
|||
|
||||
MiniHBaseCluster hbm = htu.startMiniHBaseCluster(1, 1);
|
||||
hbm.waitForActiveAndReadyMaster();
|
||||
HRegionServer targetRs = hbm.getMaster();
|
||||
HRegionServer targetRs = LoadBalancer.isTablesOnMaster(hbm.getConf())? hbm.getMaster():
|
||||
hbm.getRegionServer(0);
|
||||
|
||||
// We want to have a datanode with the same name as the region server, so
|
||||
// we're going to get the regionservername, and start a new datanode with this name.
|
||||
|
|
|
|||
|
|
@ -100,7 +100,13 @@ public class TestMasterMetrics {
|
|||
request.setLoad(sl);
|
||||
|
||||
master.getMasterRpcServices().regionServerReport(null, request.build());
|
||||
boolean tablesOnMaster = LoadBalancer.isTablesOnMaster(TEST_UTIL.getConfiguration());
|
||||
if (tablesOnMaster) {
|
||||
metricsHelper.assertCounter("cluster_requests", expectedRequestNumber, masterSource);
|
||||
} else {
|
||||
metricsHelper.assertCounterGt("cluster_requests", expectedRequestNumber, masterSource);
|
||||
|
||||
}
|
||||
|
||||
expectedRequestNumber = 15000;
|
||||
|
||||
|
|
@ -110,7 +116,11 @@ public class TestMasterMetrics {
|
|||
request.setLoad(sl);
|
||||
|
||||
master.getMasterRpcServices().regionServerReport(null, request.build());
|
||||
if (tablesOnMaster) {
|
||||
metricsHelper.assertCounter("cluster_requests", expectedRequestNumber, masterSource);
|
||||
} else {
|
||||
metricsHelper.assertCounterGt("cluster_requests", expectedRequestNumber, masterSource);
|
||||
}
|
||||
|
||||
master.stopMaster();
|
||||
}
|
||||
|
|
@ -118,8 +128,9 @@ public class TestMasterMetrics {
|
|||
@Test
|
||||
public void testDefaultMasterMetrics() throws Exception {
|
||||
MetricsMasterSource masterSource = master.getMasterMetrics().getMetricsSource();
|
||||
metricsHelper.assertGauge( "numRegionServers", 2, masterSource);
|
||||
metricsHelper.assertGauge( "averageLoad", 1, masterSource);
|
||||
boolean tablesOnMaster = LoadBalancer.isTablesOnMaster(TEST_UTIL.getConfiguration());
|
||||
metricsHelper.assertGauge( "numRegionServers",1 + (tablesOnMaster? 1: 0), masterSource);
|
||||
metricsHelper.assertGauge( "averageLoad", 1 + (tablesOnMaster? 0: 1), masterSource);
|
||||
metricsHelper.assertGauge( "numDeadRegionServers", 0, masterSource);
|
||||
|
||||
metricsHelper.assertGauge("masterStartTime", master.getMasterStartTime(), masterSource);
|
||||
|
|
|
|||
|
|
@ -40,10 +40,11 @@ public class TestMasterMetricsWrapper {
|
|||
private static final Log LOG = LogFactory.getLog(TestMasterMetricsWrapper.class);
|
||||
|
||||
private static final HBaseTestingUtility TEST_UTIL = new HBaseTestingUtility();
|
||||
private static final int NUM_RS = 4;
|
||||
|
||||
@BeforeClass
|
||||
public static void setup() throws Exception {
|
||||
TEST_UTIL.startMiniCluster(1, 4);
|
||||
TEST_UTIL.startMiniCluster(1, NUM_RS);
|
||||
}
|
||||
|
||||
@AfterClass
|
||||
|
|
@ -63,7 +64,9 @@ public class TestMasterMetricsWrapper {
|
|||
assertEquals(master.getMasterStartTime(), info.getStartTime());
|
||||
assertEquals(master.getMasterCoprocessors().length, info.getCoprocessors().length);
|
||||
assertEquals(master.getServerManager().getOnlineServersList().size(), info.getNumRegionServers());
|
||||
assertEquals(5, info.getNumRegionServers());
|
||||
int regionServerCount =
|
||||
NUM_RS + (LoadBalancer.isTablesOnMaster(TEST_UTIL.getConfiguration())? 1: 0);
|
||||
assertEquals(regionServerCount, info.getNumRegionServers());
|
||||
|
||||
String zkServers = info.getZookeeperQuorum();
|
||||
assertEquals(zkServers.split(",").length, TEST_UTIL.getZkCluster().getZooKeeperServerNum());
|
||||
|
|
@ -74,11 +77,11 @@ public class TestMasterMetricsWrapper {
|
|||
TEST_UTIL.getMiniHBaseCluster().waitOnRegionServer(index);
|
||||
// We stopped the regionserver but could take a while for the master to notice it so hang here
|
||||
// until it does... then move forward to see if metrics wrapper notices.
|
||||
while (TEST_UTIL.getHBaseCluster().getMaster().getServerManager().getOnlineServers().size() !=
|
||||
4) {
|
||||
while (TEST_UTIL.getHBaseCluster().getMaster().getServerManager().getOnlineServers().size() ==
|
||||
regionServerCount ) {
|
||||
Threads.sleep(10);
|
||||
}
|
||||
assertEquals(4, info.getNumRegionServers());
|
||||
assertEquals(regionServerCount - 1, info.getNumRegionServers());
|
||||
assertEquals(1, info.getNumDeadRegionServers());
|
||||
assertEquals(1, info.getNumWALFiles());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -26,7 +26,6 @@ import java.net.InetAddress;
|
|||
import java.net.UnknownHostException;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
|
||||
import org.apache.commons.logging.Log;
|
||||
import org.apache.commons.logging.LogFactory;
|
||||
|
|
@ -65,6 +64,7 @@ import org.junit.AfterClass;
|
|||
import org.junit.BeforeClass;
|
||||
import org.junit.Rule;
|
||||
import org.junit.Test;
|
||||
import org.junit.Ignore;
|
||||
import org.junit.experimental.categories.Category;
|
||||
import org.junit.rules.TestName;
|
||||
import org.junit.rules.TestRule;
|
||||
|
|
@ -82,6 +82,7 @@ import org.mockito.Mockito;
|
|||
public class TestMasterNoCluster {
|
||||
private static final Log LOG = LogFactory.getLog(TestMasterNoCluster.class);
|
||||
private static final HBaseTestingUtility TESTUTIL = new HBaseTestingUtility();
|
||||
|
||||
@Rule public final TestRule timeout = CategoryBasedTimeout.builder().
|
||||
withTimeout(this.getClass()).withLookingForStuckThread(true).build();
|
||||
|
||||
|
|
@ -149,7 +150,7 @@ public class TestMasterNoCluster {
|
|||
* @throws InterruptedException
|
||||
* @throws org.apache.hadoop.hbase.shaded.com.google.protobuf.ServiceException
|
||||
*/
|
||||
@Test
|
||||
@Ignore @Test // Disabled since HBASE-18511. Reenable when master can carry regions.
|
||||
public void testFailover() throws Exception {
|
||||
final long now = System.currentTimeMillis();
|
||||
// Names for our three servers. Make the port numbers match hostname.
|
||||
|
|
@ -253,7 +254,7 @@ public class TestMasterNoCluster {
|
|||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
@Ignore @Test // Disabled since HBASE-18511. Reenable when master can carry regions.
|
||||
public void testNotPullingDeadRegionServerFromZK()
|
||||
throws IOException, KeeperException, InterruptedException {
|
||||
final Configuration conf = TESTUTIL.getConfiguration();
|
||||
|
|
|
|||
|
|
@ -107,7 +107,6 @@ public class TestBaseLoadBalancer extends BalancerTestBase {
|
|||
}
|
||||
|
||||
public static class MockBalancer extends BaseLoadBalancer {
|
||||
|
||||
@Override
|
||||
public List<RegionPlan> balanceCluster(Map<ServerName, List<HRegionInfo>> clusterState) {
|
||||
return null;
|
||||
|
|
@ -118,7 +117,6 @@ public class TestBaseLoadBalancer extends BalancerTestBase {
|
|||
Map<ServerName, List<HRegionInfo>> clusterState) throws HBaseIOException {
|
||||
return null;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -149,8 +147,10 @@ public class TestBaseLoadBalancer extends BalancerTestBase {
|
|||
hris.add(HRegionInfo.FIRST_META_REGIONINFO);
|
||||
tmp.add(master);
|
||||
Map<ServerName, List<HRegionInfo>> plans = loadBalancer.roundRobinAssignment(hris, tmp);
|
||||
if (LoadBalancer.isTablesOnMaster(loadBalancer.getConf())) {
|
||||
assertTrue(plans.get(master).contains(HRegionInfo.FIRST_META_REGIONINFO));
|
||||
assertEquals(1, plans.get(master).size());
|
||||
}
|
||||
int totalRegion = 0;
|
||||
for (List<HRegionInfo> regions: plans.values()) {
|
||||
totalRegion += regions.size();
|
||||
|
|
|
|||
|
|
@ -0,0 +1,200 @@
|
|||
/**
|
||||
* 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.balancer;
|
||||
|
||||
import org.apache.commons.logging.Log;
|
||||
import org.apache.commons.logging.LogFactory;
|
||||
import org.apache.hadoop.conf.Configuration;
|
||||
import org.apache.hadoop.hbase.*;
|
||||
import org.apache.hadoop.hbase.client.Table;
|
||||
import org.apache.hadoop.hbase.master.HMaster;
|
||||
import org.apache.hadoop.hbase.master.LoadBalancer;
|
||||
import org.apache.hadoop.hbase.regionserver.Region;
|
||||
import org.apache.hadoop.hbase.testclassification.MediumTests;
|
||||
import org.apache.hadoop.hbase.util.JVMClusterUtil;
|
||||
import org.apache.hadoop.hbase.util.Threads;
|
||||
import org.junit.After;
|
||||
import org.junit.Before;
|
||||
import org.junit.Rule;
|
||||
import org.junit.Test;
|
||||
import org.junit.experimental.categories.Category;
|
||||
import org.junit.rules.TestName;
|
||||
import org.junit.rules.TestRule;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
/**
|
||||
* Test options for regions on master; none, system, or any (i.e. master is like any other
|
||||
* regionserver). Checks how regions are deployed when each of the options are enabled.
|
||||
* It then does kill combinations to make sure the distribution is more than just for startup.
|
||||
*/
|
||||
@Category({MediumTests.class})
|
||||
public class TestRegionsOnMasterOptions {
|
||||
private static final Log LOG = LogFactory.getLog(TestRegionsOnMasterOptions.class);
|
||||
@Rule public TestName name = new TestName();
|
||||
@Rule public final TestRule timeout = CategoryBasedTimeout.builder().withTimeout(this.getClass()).
|
||||
withLookingForStuckThread(true).build();
|
||||
private final static HBaseTestingUtility TEST_UTIL = new HBaseTestingUtility();
|
||||
private Configuration c;
|
||||
private String tablesOnMasterOldValue;
|
||||
private String systemTablesOnMasterOldValue;
|
||||
private static final int SLAVES = 3;
|
||||
private static final int MASTERS = 2;
|
||||
// Make the count of REGIONS high enough so I can distingush case where master is only carrying
|
||||
// system regions from the case where it is carrying any region; i.e. 2 system regions vs more
|
||||
// if user + system.
|
||||
private static final int REGIONS = 12;
|
||||
private static final int SYSTEM_REGIONS = 2; // ns and meta -- no acl unless enabled.
|
||||
|
||||
@Before
|
||||
public void setup() {
|
||||
this.c = TEST_UTIL.getConfiguration();
|
||||
this.tablesOnMasterOldValue = c.get(LoadBalancer.TABLES_ON_MASTER);
|
||||
this.systemTablesOnMasterOldValue = c.get(LoadBalancer.SYSTEM_TABLES_ON_MASTER);
|
||||
}
|
||||
|
||||
@After
|
||||
public void tearDown() {
|
||||
unset(LoadBalancer.TABLES_ON_MASTER, this.tablesOnMasterOldValue);
|
||||
unset(LoadBalancer.SYSTEM_TABLES_ON_MASTER, this.systemTablesOnMasterOldValue);
|
||||
}
|
||||
|
||||
private void unset(final String key, final String value) {
|
||||
if (value == null) {
|
||||
c.unset(key);
|
||||
} else {
|
||||
c.set(key, value);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testRegionsOnAllServers() throws Exception {
|
||||
c.setBoolean(LoadBalancer.TABLES_ON_MASTER, true);
|
||||
c.setBoolean(LoadBalancer.SYSTEM_TABLES_ON_MASTER, false);
|
||||
int rsCount = (REGIONS + SYSTEM_REGIONS)/(SLAVES + 1/*Master*/);
|
||||
checkBalance(rsCount, rsCount);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoRegionOnMaster() throws Exception {
|
||||
c.setBoolean(LoadBalancer.TABLES_ON_MASTER, false);
|
||||
c.setBoolean(LoadBalancer.SYSTEM_TABLES_ON_MASTER, false);
|
||||
int rsCount = (REGIONS + SYSTEM_REGIONS)/SLAVES;
|
||||
checkBalance(0, rsCount);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSystemTablesOnMaster() throws Exception {
|
||||
c.setBoolean(LoadBalancer.TABLES_ON_MASTER, true);
|
||||
c.setBoolean(LoadBalancer.SYSTEM_TABLES_ON_MASTER, true);
|
||||
// IS THIS SHORT-CIRCUIT RPC? Yes. Here is how it looks currently if I have an exception
|
||||
// thrown in doBatchMutate inside a Region.
|
||||
//
|
||||
// java.lang.Exception
|
||||
// at org.apache.hadoop.hbase.regionserver.HRegion.doBatchMutate(HRegion.java:3845)
|
||||
// at org.apache.hadoop.hbase.regionserver.HRegion.put(HRegion.java:2972)
|
||||
// at org.apache.hadoop.hbase.regionserver.RSRpcServices.mutate(RSRpcServices.java:2751)
|
||||
// at org.apache.hadoop.hbase.client.ClientServiceCallable.doMutate(ClientServiceCallable.java:55)
|
||||
// at org.apache.hadoop.hbase.client.HTable$3.rpcCall(HTable.java:585)
|
||||
// at org.apache.hadoop.hbase.client.HTable$3.rpcCall(HTable.java:579)
|
||||
// at org.apache.hadoop.hbase.client.RegionServerCallable.call(RegionServerCallable.java:126)
|
||||
// at org.apache.hadoop.hbase.client.RpcRetryingCallerImpl.callWithRetries(RpcRetryingCallerImpl.java:106)
|
||||
// at org.apache.hadoop.hbase.client.HTable.put(HTable.java:589)
|
||||
// at org.apache.hadoop.hbase.master.TableNamespaceManager.insertIntoNSTable(TableNamespaceManager.java:156)
|
||||
// at org.apache.hadoop.hbase.master.procedure.CreateNamespaceProcedure.insertIntoNSTable(CreateNamespaceProcedure.java:222)
|
||||
// at org.apache.hadoop.hbase.master.procedure.CreateNamespaceProcedure.executeFromState(CreateNamespaceProcedure.java:76)
|
||||
// at org.apache.hadoop.hbase.master.procedure.CreateNamespaceProcedure.executeFromState(CreateNamespaceProcedure.java:40)
|
||||
// at org.apache.hadoop.hbase.procedure2.StateMachineProcedure.execute(StateMachineProcedure.java:181)
|
||||
// at org.apache.hadoop.hbase.procedure2.Procedure.doExecute(Procedure.java:847)
|
||||
// at org.apache.hadoop.hbase.procedure2.ProcedureExecutor.execProcedure(ProcedureExecutor.java:1440)
|
||||
// at org.apache.hadoop.hbase.procedure2.ProcedureExecutor.executeProcedure(ProcedureExecutor.java:1209)
|
||||
// at org.apache.hadoop.hbase.procedure2.ProcedureExecutor.access$800(ProcedureExecutor.java:79)
|
||||
// at org.apache.hadoop.hbase.procedure2.ProcedureExecutor$WorkerThread.run(ProcedureExecutor.java:1719)
|
||||
//
|
||||
// If I comment out the ConnectionUtils ConnectionImplementation content, I see this:
|
||||
//
|
||||
// java.lang.Exception
|
||||
// at org.apache.hadoop.hbase.regionserver.HRegion.doBatchMutate(HRegion.java:3845)
|
||||
// at org.apache.hadoop.hbase.regionserver.HRegion.put(HRegion.java:2972)
|
||||
// at org.apache.hadoop.hbase.regionserver.RSRpcServices.mutate(RSRpcServices.java:2751)
|
||||
// at org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos$ClientService$2.callBlockingMethod(ClientProtos.java:41546)
|
||||
// at org.apache.hadoop.hbase.ipc.RpcServer.call(RpcServer.java:406)
|
||||
// at org.apache.hadoop.hbase.ipc.CallRunner.run(CallRunner.java:133)
|
||||
// at org.apache.hadoop.hbase.ipc.RpcExecutor$Handler.run(RpcExecutor.java:278)
|
||||
// at org.apache.hadoop.hbase.ipc.RpcExecutor$Handler.run(RpcExecutor.java:258)
|
||||
|
||||
checkBalance(SYSTEM_REGIONS, REGIONS/SLAVES);
|
||||
}
|
||||
|
||||
private void checkBalance(int masterCount, int rsCount) throws Exception {
|
||||
MiniHBaseCluster cluster = TEST_UTIL.startMiniCluster(MASTERS, SLAVES);
|
||||
TableName tn = TableName.valueOf(this.name.getMethodName());
|
||||
try {
|
||||
Table t = TEST_UTIL.createMultiRegionTable(tn, HConstants.CATALOG_FAMILY, REGIONS);
|
||||
LOG.info("Server: " + cluster.getMaster().getServerManager().getOnlineServersList());
|
||||
List<Region> regions = cluster.getMaster().getOnlineRegions();
|
||||
int mActualCount = regions.size();
|
||||
if (masterCount == 0 || masterCount == SYSTEM_REGIONS) {
|
||||
// 0 means no regions on master.
|
||||
assertEquals(masterCount, mActualCount);
|
||||
} else {
|
||||
// This is master as a regionserver scenario.
|
||||
checkCount(masterCount, mActualCount);
|
||||
}
|
||||
// Allow that balance is not exact. FYI, getRegionServerThreads does not include master
|
||||
// thread though it is a regionserver so we have to check master and then below the
|
||||
// regionservers.
|
||||
for (JVMClusterUtil.RegionServerThread rst: cluster.getRegionServerThreads()) {
|
||||
regions = rst.getRegionServer().getOnlineRegions();
|
||||
int rsActualCount = regions.size();
|
||||
checkCount(rsActualCount, rsCount);
|
||||
}
|
||||
HMaster oldMaster = cluster.getMaster();
|
||||
cluster.killMaster(oldMaster.getServerName());
|
||||
oldMaster.join();
|
||||
while (cluster.getMaster() == null ||
|
||||
cluster.getMaster().getServerName().equals(oldMaster.getServerName())) {
|
||||
Threads.sleep(10);
|
||||
}
|
||||
while (!cluster.getMaster().isInitialized()) {
|
||||
Threads.sleep(10);
|
||||
}
|
||||
LOG.info("Cluster is up; running balancer");
|
||||
cluster.getMaster().balance();
|
||||
regions = cluster.getMaster().getOnlineRegions();
|
||||
int mNewActualCount = regions.size();
|
||||
if (masterCount == 0 || masterCount == SYSTEM_REGIONS) {
|
||||
// 0 means no regions on master. After crash, should still be no regions on master.
|
||||
// If masterCount == SYSTEM_REGIONS, means master only carrying system regions and should
|
||||
// still only carry system regions post crash.
|
||||
assertEquals(masterCount, mNewActualCount);
|
||||
}
|
||||
} finally {
|
||||
LOG.info("Running shutdown of cluster");
|
||||
TEST_UTIL.shutdownMiniCluster();
|
||||
}
|
||||
}
|
||||
|
||||
private void checkCount(int actual, int expected) {
|
||||
assertTrue("Actual=" + actual + ", expected=" + expected,
|
||||
actual >= (expected - 2) && actual <= (expected + 2)); // Lots of slop +/- 2
|
||||
}
|
||||
}
|
||||
|
|
@ -31,6 +31,7 @@ import org.apache.hadoop.hbase.CoordinatedStateManager;
|
|||
import org.apache.hadoop.hbase.CoordinatedStateManagerFactory;
|
||||
import org.apache.hadoop.hbase.HBaseTestingUtility;
|
||||
import org.apache.hadoop.hbase.HConstants;
|
||||
import org.apache.hadoop.hbase.master.LoadBalancer;
|
||||
import org.apache.hadoop.hbase.testclassification.MediumTests;
|
||||
import org.apache.hadoop.hbase.testclassification.RegionServerTests;
|
||||
import org.apache.hadoop.hbase.master.HMaster;
|
||||
|
|
@ -111,7 +112,8 @@ public class TestClusterId {
|
|||
}
|
||||
TEST_UTIL.startMiniHBaseCluster(1, 1);
|
||||
HMaster master = TEST_UTIL.getHBaseCluster().getMaster();
|
||||
assertEquals(2, master.getServerManager().getOnlineServersList().size());
|
||||
int expected = LoadBalancer.isTablesOnMaster(TEST_UTIL.getConfiguration())? 2: 1;
|
||||
assertEquals(expected, master.getServerManager().getOnlineServersList().size());
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -39,8 +39,10 @@ import org.apache.hadoop.hbase.LocalHBaseCluster;
|
|||
import org.apache.hadoop.hbase.MiniHBaseCluster;
|
||||
import org.apache.hadoop.hbase.ServerName;
|
||||
import org.apache.hadoop.hbase.master.HMaster;
|
||||
import org.apache.hadoop.hbase.master.LoadBalancer;
|
||||
import org.apache.hadoop.hbase.master.ServerListener;
|
||||
import org.apache.hadoop.hbase.master.ServerManager;
|
||||
import org.apache.hadoop.hbase.master.balancer.BaseLoadBalancer;
|
||||
import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionServerStartupResponse;
|
||||
import org.apache.hadoop.hbase.testclassification.MediumTests;
|
||||
import org.apache.hadoop.hbase.testclassification.RegionServerTests;
|
||||
|
|
@ -74,7 +76,7 @@ public class TestRSKilledWhenInitializing {
|
|||
private static final int NUM_RS = 2;
|
||||
|
||||
/**
|
||||
* Test verifies whether a region server is removing from online servers list in master if it went
|
||||
* Test verifies whether a region server is removed from online servers list in master if it went
|
||||
* down after registering with master. Test will TIMEOUT if an error!!!!
|
||||
* @throws Exception
|
||||
*/
|
||||
|
|
@ -98,18 +100,18 @@ public class TestRSKilledWhenInitializing {
|
|||
for (int i = 0; i < NUM_RS; i++) {
|
||||
cluster.getRegionServers().get(i).start();
|
||||
}
|
||||
// Now wait on master to see NUM_RS + 1 servers as being online, thats NUM_RS plus
|
||||
// the Master itself (because Master hosts hbase:meta and checks in as though it a RS).
|
||||
// Expected total regionservers depends on whether Master can host regions or not.
|
||||
int expectedTotalRegionServers = NUM_RS + (LoadBalancer.isTablesOnMaster(conf)? 1: 0);
|
||||
List<ServerName> onlineServersList = null;
|
||||
do {
|
||||
onlineServersList = master.getMaster().getServerManager().getOnlineServersList();
|
||||
} while (onlineServersList.size() < (NUM_RS + 1));
|
||||
} while (onlineServersList.size() < expectedTotalRegionServers);
|
||||
// Wait until killedRS is set. Means RegionServer is starting to go down.
|
||||
while (killedRS.get() == null) {
|
||||
Threads.sleep(1);
|
||||
}
|
||||
// Wait on the RegionServer to fully die.
|
||||
while (cluster.getLiveRegionServers().size() > NUM_RS) {
|
||||
while (cluster.getLiveRegionServers().size() >= expectedTotalRegionServers) {
|
||||
Threads.sleep(1);
|
||||
}
|
||||
// Make sure Master is fully up before progressing. Could take a while if regions
|
||||
|
|
@ -134,7 +136,8 @@ public class TestRSKilledWhenInitializing {
|
|||
}
|
||||
// Try moving region to the killed server. It will fail. As by-product, we will
|
||||
// remove the RS from Master online list because no corresponding znode.
|
||||
assertEquals(NUM_RS + 1, master.getMaster().getServerManager().getOnlineServersList().size());
|
||||
assertEquals(expectedTotalRegionServers,
|
||||
master.getMaster().getServerManager().getOnlineServersList().size());
|
||||
LOG.info("Move " + hri.getEncodedName() + " to " + killedRS.get());
|
||||
master.getMaster().move(hri.getEncodedNameAsBytes(),
|
||||
Bytes.toBytes(killedRS.get().toString()));
|
||||
|
|
|
|||
|
|
@ -83,8 +83,7 @@ public class TestRegionOpen {
|
|||
final TableName tableName = TableName.valueOf(TestRegionOpen.class.getSimpleName());
|
||||
ThreadPoolExecutor exec = getRS().getExecutorService()
|
||||
.getExecutorThreadPool(ExecutorType.RS_OPEN_PRIORITY_REGION);
|
||||
|
||||
assertEquals(0, exec.getCompletedTaskCount());
|
||||
long completed = exec.getCompletedTaskCount();
|
||||
|
||||
HTableDescriptor htd = new HTableDescriptor(tableName);
|
||||
htd.setPriority(HConstants.HIGH_QOS);
|
||||
|
|
@ -94,7 +93,7 @@ public class TestRegionOpen {
|
|||
admin.createTable(htd);
|
||||
}
|
||||
|
||||
assertEquals(1, exec.getCompletedTaskCount());
|
||||
assertEquals(completed + 1, exec.getCompletedTaskCount());
|
||||
}
|
||||
|
||||
@Test(timeout = 60000)
|
||||
|
|
|
|||
|
|
@ -40,6 +40,7 @@ import org.apache.hadoop.hbase.coprocessor.RegionCoprocessorEnvironment;
|
|||
import org.apache.hadoop.hbase.coprocessor.RegionObserver;
|
||||
import org.apache.hadoop.hbase.coprocessor.RegionServerCoprocessorEnvironment;
|
||||
import org.apache.hadoop.hbase.coprocessor.RegionServerObserver;
|
||||
import org.apache.hadoop.hbase.master.HMaster;
|
||||
import org.apache.hadoop.hbase.regionserver.wal.WALEdit;
|
||||
import org.apache.hadoop.hbase.testclassification.MediumTests;
|
||||
import org.apache.hadoop.hbase.testclassification.RegionServerTests;
|
||||
|
|
@ -94,16 +95,19 @@ public class TestRegionServerAbort {
|
|||
|
||||
@After
|
||||
public void tearDown() throws Exception {
|
||||
String className = StopBlockingRegionObserver.class.getName();
|
||||
for (JVMClusterUtil.RegionServerThread t : cluster.getRegionServerThreads()) {
|
||||
HRegionServer rs = t.getRegionServer();
|
||||
RegionServerCoprocessorHost cpHost = rs.getRegionServerCoprocessorHost();
|
||||
StopBlockingRegionObserver cp = (StopBlockingRegionObserver)
|
||||
cpHost.findCoprocessor(StopBlockingRegionObserver.class.getName());
|
||||
StopBlockingRegionObserver cp = (StopBlockingRegionObserver)cpHost.findCoprocessor(className);
|
||||
cp.setStopAllowed(true);
|
||||
}
|
||||
((StopBlockingRegionObserver) cluster.getMaster().getRegionServerCoprocessorHost().findCoprocessor(
|
||||
StopBlockingRegionObserver.class.getName()
|
||||
)).setStopAllowed(true);
|
||||
HMaster master = cluster.getMaster();
|
||||
RegionServerCoprocessorHost host = master.getRegionServerCoprocessorHost();
|
||||
if (host != null) {
|
||||
StopBlockingRegionObserver obs = (StopBlockingRegionObserver) host.findCoprocessor(className);
|
||||
if (obs != null) obs.setStopAllowed(true);
|
||||
}
|
||||
testUtil.shutdownMiniCluster();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -32,6 +32,7 @@ import org.apache.commons.logging.LogFactory;
|
|||
import org.apache.hadoop.conf.Configuration;
|
||||
import org.apache.hadoop.hbase.HBaseConfiguration;
|
||||
import org.apache.hadoop.hbase.HBaseTestingUtility;
|
||||
import org.apache.hadoop.hbase.master.LoadBalancer;
|
||||
import org.apache.hadoop.hbase.testclassification.MediumTests;
|
||||
import org.apache.hadoop.hbase.testclassification.RegionServerTests;
|
||||
import org.apache.hadoop.hbase.zookeeper.ZKUtil;
|
||||
|
|
@ -101,7 +102,8 @@ public class TestRegionServerHostname {
|
|||
ZooKeeperWatcher zkw = TEST_UTIL.getZooKeeperWatcher();
|
||||
List<String> servers = ZKUtil.listChildrenNoWatch(zkw, zkw.znodePaths.rsZNode);
|
||||
// there would be NUM_RS+1 children - one for the master
|
||||
assertTrue(servers.size() == NUM_RS+1);
|
||||
assertTrue(servers.size() ==
|
||||
NUM_RS + (LoadBalancer.isTablesOnMaster(TEST_UTIL.getConfiguration())? 1: 0));
|
||||
for (String server : servers) {
|
||||
assertTrue("From zookeeper: " + server + " hostname: " + hostName,
|
||||
server.startsWith(hostName.toLowerCase(Locale.ROOT)+","));
|
||||
|
|
@ -153,11 +155,14 @@ public class TestRegionServerHostname {
|
|||
|
||||
@Test(timeout=30000)
|
||||
public void testRegionServerHostnameReportedToMaster() throws Exception {
|
||||
TEST_UTIL.getConfiguration().setBoolean(HRegionServer.RS_HOSTNAME_DISABLE_MASTER_REVERSEDNS_KEY, true);
|
||||
TEST_UTIL.getConfiguration().setBoolean(HRegionServer.RS_HOSTNAME_DISABLE_MASTER_REVERSEDNS_KEY,
|
||||
true);
|
||||
TEST_UTIL.startMiniCluster(NUM_MASTERS, NUM_RS);
|
||||
boolean tablesOnMaster = LoadBalancer.isTablesOnMaster(TEST_UTIL.getConfiguration());
|
||||
int expectedRS = NUM_RS + (tablesOnMaster? 1: 0);
|
||||
try (ZooKeeperWatcher zkw = TEST_UTIL.getZooKeeperWatcher()) {
|
||||
List<String> servers = ZKUtil.listChildrenNoWatch(zkw, zkw.znodePaths.rsZNode);
|
||||
assertEquals("should be NUM_RS+1 children - one for master", NUM_RS + 1, servers.size());
|
||||
assertEquals(expectedRS, servers.size());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -55,6 +55,7 @@ import org.apache.hadoop.hbase.client.Scan;
|
|||
import org.apache.hadoop.hbase.client.Table;
|
||||
import org.apache.hadoop.hbase.client.TableDescriptor;
|
||||
import org.apache.hadoop.hbase.client.TableDescriptorBuilder;
|
||||
import org.apache.hadoop.hbase.master.LoadBalancer;
|
||||
import org.apache.hadoop.hbase.test.MetricsAssertHelper;
|
||||
import org.apache.hadoop.hbase.testclassification.LargeTests;
|
||||
import org.apache.hadoop.hbase.testclassification.RegionServerTests;
|
||||
|
|
@ -103,11 +104,13 @@ public class TestRegionServerMetrics {
|
|||
private static byte[] qualifier = Bytes.toBytes("qual");
|
||||
private static byte[] val = Bytes.toBytes("val");
|
||||
private static Admin admin;
|
||||
private static boolean TABLES_ON_MASTER;
|
||||
|
||||
@BeforeClass
|
||||
public static void startCluster() throws Exception {
|
||||
metricsHelper = CompatibilityFactory.getInstance(MetricsAssertHelper.class);
|
||||
TEST_UTIL = new HBaseTestingUtility();
|
||||
TABLES_ON_MASTER = LoadBalancer.isTablesOnMaster(TEST_UTIL.getConfiguration());
|
||||
conf = TEST_UTIL.getConfiguration();
|
||||
conf.getLong("hbase.splitlog.max.resubmit", 0);
|
||||
// Make the failure test faster
|
||||
|
|
@ -241,7 +244,7 @@ public class TestRegionServerMetrics {
|
|||
|
||||
@Test
|
||||
public void testRegionCount() throws Exception {
|
||||
metricsHelper.assertGauge("regionCount", 1, serverSource);
|
||||
metricsHelper.assertGauge("regionCount", TABLES_ON_MASTER? 1: 3, serverSource);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -283,32 +286,42 @@ public class TestRegionServerMetrics {
|
|||
doNGets(10, true); // true = batch
|
||||
|
||||
metricsRegionServer.getRegionServerWrapper().forceRecompute();
|
||||
if (TABLES_ON_MASTER) {
|
||||
assertCounter("totalRequestCount", requests + 41);
|
||||
assertCounter("totalRowActionRequestCount", rowActionRequests + 50);
|
||||
assertCounter("readRequestCount", readRequests + 20);
|
||||
}
|
||||
|
||||
|
||||
assertCounter("writeRequestCount", writeRequests + 30);
|
||||
|
||||
doNPuts(30, true);
|
||||
|
||||
metricsRegionServer.getRegionServerWrapper().forceRecompute();
|
||||
if (TABLES_ON_MASTER) {
|
||||
assertCounter("totalRequestCount", requests + 42);
|
||||
assertCounter("totalRowActionRequestCount", rowActionRequests + 80);
|
||||
assertCounter("readRequestCount", readRequests + 20);
|
||||
}
|
||||
assertCounter("writeRequestCount", writeRequests + 60);
|
||||
|
||||
doScan(10, false); // test after batch put so we have enough lines
|
||||
metricsRegionServer.getRegionServerWrapper().forceRecompute();
|
||||
if (TABLES_ON_MASTER) {
|
||||
assertCounter("totalRequestCount", requests + 52);
|
||||
assertCounter("totalRowActionRequestCount", rowActionRequests + 90);
|
||||
assertCounter("readRequestCount", readRequests + 30);
|
||||
}
|
||||
assertCounter("writeRequestCount", writeRequests + 60);
|
||||
numScanNext += 10;
|
||||
|
||||
doScan(10, true); // true = caching
|
||||
metricsRegionServer.getRegionServerWrapper().forceRecompute();
|
||||
if (TABLES_ON_MASTER) {
|
||||
assertCounter("totalRequestCount", requests + 53);
|
||||
assertCounter("totalRowActionRequestCount", rowActionRequests + 100);
|
||||
assertCounter("readRequestCount", readRequests + 40);
|
||||
}
|
||||
assertCounter("writeRequestCount", writeRequests + 60);
|
||||
numScanNext += 1;
|
||||
}
|
||||
|
|
@ -341,7 +354,7 @@ public class TestRegionServerMetrics {
|
|||
TEST_UTIL.getAdmin().flush(tableName);
|
||||
|
||||
metricsRegionServer.getRegionServerWrapper().forceRecompute();
|
||||
assertGauge("storeCount", 1);
|
||||
assertGauge("storeCount", TABLES_ON_MASTER? 1: 7);
|
||||
assertGauge("storeFileCount", 1);
|
||||
}
|
||||
|
||||
|
|
@ -424,8 +437,10 @@ public class TestRegionServerMetrics {
|
|||
}
|
||||
numScanNext += NUM_SCAN_NEXT;
|
||||
assertRegionMetrics("scanCount", NUM_SCAN_NEXT);
|
||||
if (TABLES_ON_MASTER) {
|
||||
assertCounter("ScanSize_num_ops", numScanNext);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testScanTime() throws Exception {
|
||||
|
|
@ -442,8 +457,10 @@ public class TestRegionServerMetrics {
|
|||
}
|
||||
numScanNext += NUM_SCAN_NEXT;
|
||||
assertRegionMetrics("scanCount", NUM_SCAN_NEXT);
|
||||
if (TABLES_ON_MASTER) {
|
||||
assertCounter("ScanTime_num_ops", numScanNext);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testScanSizeForSmallScan() throws Exception {
|
||||
|
|
@ -456,12 +473,16 @@ public class TestRegionServerMetrics {
|
|||
for (int nextCount = 0; nextCount < NUM_SCAN_NEXT; nextCount++) {
|
||||
Result result = resultScanners.next();
|
||||
assertNotNull(result);
|
||||
if (TABLES_ON_MASTER) {
|
||||
assertEquals(1, result.size());
|
||||
}
|
||||
}
|
||||
numScanNext += NUM_SCAN_NEXT;
|
||||
assertRegionMetrics("scanCount", NUM_SCAN_NEXT);
|
||||
if (TABLES_ON_MASTER) {
|
||||
assertCounter("ScanSize_num_ops", numScanNext);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMobMetrics() throws IOException, InterruptedException {
|
||||
|
|
|
|||
|
|
@ -41,6 +41,7 @@ import org.apache.hadoop.hbase.filter.BinaryComparator;
|
|||
import org.apache.hadoop.hbase.filter.CompareFilter;
|
||||
import org.apache.hadoop.hbase.filter.RowFilter;
|
||||
import org.apache.hadoop.hbase.filter.SingleColumnValueFilter;
|
||||
import org.apache.hadoop.hbase.master.LoadBalancer;
|
||||
import org.apache.hadoop.hbase.testclassification.MediumTests;
|
||||
import org.apache.hadoop.hbase.util.Bytes;
|
||||
import org.junit.AfterClass;
|
||||
|
|
@ -87,6 +88,7 @@ public class TestRegionServerReadRequestMetrics {
|
|||
|
||||
@BeforeClass
|
||||
public static void setUpOnce() throws Exception {
|
||||
// Default starts one regionserver only.
|
||||
TEST_UTIL.startMiniCluster();
|
||||
admin = TEST_UTIL.getAdmin();
|
||||
serverNames = admin.getClusterStatus().getServers();
|
||||
|
|
@ -121,8 +123,16 @@ public class TestRegionServerReadRequestMetrics {
|
|||
|
||||
assertEquals(expectedReadRequests,
|
||||
requestsMap.get(Metric.REGION_READ) - requestsMapPrev.get(Metric.REGION_READ));
|
||||
boolean tablesOnMaster = LoadBalancer.isTablesOnMaster(TEST_UTIL.getConfiguration());
|
||||
if (tablesOnMaster) {
|
||||
// If NO tables on master, then the single regionserver in this test carries user-space
|
||||
// tables and the meta table. The first time through, the read will be inflated by meta
|
||||
// lookups. We don't know which test will be first through since junit randomizes. This
|
||||
// method is used by a bunch of tests. Just do this check if master is hosting (system)
|
||||
// regions only.
|
||||
assertEquals(expectedReadRequests,
|
||||
requestsMap.get(Metric.SERVER_READ) - requestsMapPrev.get(Metric.SERVER_READ));
|
||||
}
|
||||
assertEquals(expectedFilteredReadRequests,
|
||||
requestsMap.get(Metric.FILTERED_REGION_READ)
|
||||
- requestsMapPrev.get(Metric.FILTERED_REGION_READ));
|
||||
|
|
|
|||
|
|
@ -31,6 +31,7 @@ import org.apache.hadoop.hbase.HConstants;
|
|||
import org.apache.hadoop.hbase.LocalHBaseCluster;
|
||||
import org.apache.hadoop.hbase.ServerName;
|
||||
import org.apache.hadoop.hbase.MiniHBaseCluster.MiniHBaseClusterRegionServer;
|
||||
import org.apache.hadoop.hbase.master.LoadBalancer;
|
||||
import org.apache.hadoop.hbase.master.ServerManager;
|
||||
import org.apache.hadoop.hbase.testclassification.MediumTests;
|
||||
import org.apache.hadoop.hbase.util.JVMClusterUtil.MasterThread;
|
||||
|
|
@ -83,8 +84,9 @@ public class TestRegionServerReportForDuty {
|
|||
// Use a random unique port
|
||||
cluster.getConfiguration().setInt(HConstants.MASTER_PORT, HBaseTestingUtility.randomFreePort());
|
||||
// master has a rs. defaultMinToStart = 2
|
||||
cluster.getConfiguration().setInt(ServerManager.WAIT_ON_REGIONSERVERS_MINTOSTART, 2);
|
||||
cluster.getConfiguration().setInt(ServerManager.WAIT_ON_REGIONSERVERS_MAXTOSTART, 2);
|
||||
boolean tablesOnMaster = LoadBalancer.isTablesOnMaster(testUtil.getConfiguration());
|
||||
cluster.getConfiguration().setInt(ServerManager.WAIT_ON_REGIONSERVERS_MINTOSTART, tablesOnMaster? 2: 1);
|
||||
cluster.getConfiguration().setInt(ServerManager.WAIT_ON_REGIONSERVERS_MAXTOSTART, tablesOnMaster? 2: 1);
|
||||
master = cluster.addMaster();
|
||||
rs = cluster.addRegionServer();
|
||||
LOG.debug("Starting master: " + master.getMaster().getServerName());
|
||||
|
|
@ -110,8 +112,10 @@ public class TestRegionServerReportForDuty {
|
|||
// Start a new master and use another random unique port
|
||||
// Also let it wait for exactly 2 region severs to report in.
|
||||
cluster.getConfiguration().setInt(HConstants.MASTER_PORT, HBaseTestingUtility.randomFreePort());
|
||||
cluster.getConfiguration().setInt(ServerManager.WAIT_ON_REGIONSERVERS_MINTOSTART, 3);
|
||||
cluster.getConfiguration().setInt(ServerManager.WAIT_ON_REGIONSERVERS_MAXTOSTART, 3);
|
||||
cluster.getConfiguration().setInt(ServerManager.WAIT_ON_REGIONSERVERS_MINTOSTART,
|
||||
tablesOnMaster? 3: 2);
|
||||
cluster.getConfiguration().setInt(ServerManager.WAIT_ON_REGIONSERVERS_MAXTOSTART,
|
||||
tablesOnMaster? 3: 2);
|
||||
backupMaster = cluster.addMaster();
|
||||
LOG.debug("Starting new master: " + backupMaster.getMaster().getServerName());
|
||||
backupMaster.start();
|
||||
|
|
@ -121,7 +125,8 @@ public class TestRegionServerReportForDuty {
|
|||
// Do some checking/asserts here.
|
||||
assertTrue(backupMaster.getMaster().isActiveMaster());
|
||||
assertTrue(backupMaster.getMaster().isInitialized());
|
||||
assertEquals(backupMaster.getMaster().getServerManager().getOnlineServersList().size(), 3);
|
||||
assertEquals(backupMaster.getMaster().getServerManager().getOnlineServersList().size(),
|
||||
tablesOnMaster? 3: 2);
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -70,10 +70,7 @@ import org.apache.hadoop.hbase.coprocessor.MasterCoprocessorEnvironment;
|
|||
import org.apache.hadoop.hbase.coprocessor.MasterObserver;
|
||||
import org.apache.hadoop.hbase.coprocessor.ObserverContext;
|
||||
import org.apache.hadoop.hbase.exceptions.UnexpectedStateException;
|
||||
import org.apache.hadoop.hbase.master.HMaster;
|
||||
import org.apache.hadoop.hbase.master.MasterRpcServices;
|
||||
import org.apache.hadoop.hbase.master.NoSuchProcedureException;
|
||||
import org.apache.hadoop.hbase.master.RegionState;
|
||||
import org.apache.hadoop.hbase.master.*;
|
||||
import org.apache.hadoop.hbase.master.RegionState.State;
|
||||
import org.apache.hadoop.hbase.master.assignment.AssignmentManager;
|
||||
import org.apache.hadoop.hbase.master.assignment.RegionStates;
|
||||
|
|
@ -830,9 +827,14 @@ public class TestSplitTransactionOnCluster {
|
|||
// hbase:meta We don't want hbase:meta replay polluting our test when we later crash
|
||||
// the table region serving server.
|
||||
int metaServerIndex = cluster.getServerWithMeta();
|
||||
assertTrue(metaServerIndex == -1); // meta is on master now
|
||||
// TODO: When we change master so it doesn't carry regions, be careful here.
|
||||
HRegionServer metaRegionServer = cluster.getMaster();
|
||||
boolean tablesOnMaster = LoadBalancer.isTablesOnMaster(TESTING_UTIL.getConfiguration());
|
||||
if (tablesOnMaster) {
|
||||
// Need to check master is supposed to host meta... perhaps it is not.
|
||||
throw new UnsupportedOperationException();
|
||||
// TODO: assertTrue(metaServerIndex == -1); // meta is on master now
|
||||
}
|
||||
HRegionServer metaRegionServer = tablesOnMaster?
|
||||
cluster.getMaster(): cluster.getRegionServer(metaServerIndex);
|
||||
int tableRegionIndex = cluster.getServerWith(hri.getRegionName());
|
||||
assertTrue(tableRegionIndex != -1);
|
||||
HRegionServer tableRegionServer = cluster.getRegionServer(tableRegionIndex);
|
||||
|
|
|
|||
|
|
@ -30,6 +30,7 @@ import org.apache.hadoop.hbase.client.Connection;
|
|||
import org.apache.hadoop.hbase.client.ConnectionFactory;
|
||||
import org.apache.hadoop.hbase.client.Put;
|
||||
import org.apache.hadoop.hbase.client.Table;
|
||||
import org.apache.hadoop.hbase.master.LoadBalancer;
|
||||
import org.apache.hadoop.hbase.regionserver.DefaultStoreEngine;
|
||||
import org.apache.hadoop.hbase.regionserver.HRegionServer;
|
||||
import org.apache.hadoop.hbase.regionserver.Region;
|
||||
|
|
@ -169,7 +170,12 @@ public class TestFlushWithThroughputController {
|
|||
}
|
||||
assertEquals(0.0, regionServer.getFlushPressure(), EPSILON);
|
||||
Thread.sleep(5000);
|
||||
boolean tablesOnMaster = LoadBalancer.isTablesOnMaster(hbtu.getConfiguration());
|
||||
if (tablesOnMaster) {
|
||||
// If no tables on the master, this math is off and I'm not sure what it is supposed to be
|
||||
// when meta is on the regionserver and not on the master.
|
||||
assertEquals(10L * 1024 * 1024, throughputController.getMaxThroughput(), EPSILON);
|
||||
}
|
||||
Table table = conn.getTable(tableName);
|
||||
Random rand = new Random();
|
||||
for (int i = 0; i < 10; i++) {
|
||||
|
|
|
|||
|
|
@ -48,6 +48,7 @@ import org.apache.hadoop.hbase.security.access.Permission.Action;
|
|||
import org.apache.hadoop.hbase.testclassification.MediumTests;
|
||||
import org.apache.hadoop.hbase.testclassification.SecurityTests;
|
||||
import org.apache.hadoop.hbase.util.Bytes;
|
||||
import org.apache.hadoop.hbase.util.JVMClusterUtil;
|
||||
import org.junit.AfterClass;
|
||||
import org.junit.BeforeClass;
|
||||
import org.junit.Test;
|
||||
|
|
@ -150,9 +151,15 @@ public class TestNamespaceCommands extends SecureTestUtil {
|
|||
// Wait for the ACL table to become available
|
||||
UTIL.waitTableAvailable(AccessControlLists.ACL_TABLE_NAME.getName(), 30 * 1000);
|
||||
|
||||
ACCESS_CONTROLLER = (AccessController) UTIL.getMiniHBaseCluster().getMaster()
|
||||
.getRegionServerCoprocessorHost()
|
||||
.findCoprocessor(AccessController.class.getName());
|
||||
// Find the Access Controller CP. Could be on master or if master is not serving regions, is
|
||||
// on an arbitrary server.
|
||||
for (JVMClusterUtil.RegionServerThread rst:
|
||||
UTIL.getMiniHBaseCluster().getLiveRegionServerThreads()) {
|
||||
ACCESS_CONTROLLER = (AccessController)rst.getRegionServer().getRegionServerCoprocessorHost().
|
||||
findCoprocessor(AccessController.class.getName());
|
||||
if (ACCESS_CONTROLLER != null) break;
|
||||
}
|
||||
if (ACCESS_CONTROLLER == null) throw new NullPointerException();
|
||||
|
||||
UTIL.getAdmin().createNamespace(NamespaceDescriptor.create(TEST_NAMESPACE).build());
|
||||
UTIL.getAdmin().createNamespace(NamespaceDescriptor.create(TEST_NAMESPACE2).build());
|
||||
|
|
|
|||
Loading…
Reference in New Issue